java类型系统知识点总结

时间:2023-12-27 11:13:19

下面的东西是在一天内用了三个编辑器写的,所以风格有点不太统一

  1. 一:下午完成

  2. 主要看了java的类型系统,具体如下。

  3. 1)接口

  4. 作为又一个引用类型,接口可以说是一种特殊的类,可以有属性和行为(字段和方法),但是都是受限的。

  5. 不过java8里面倒是加了新功能,可以使用默认方法。

  6. 对于接口中的强制方法(抽象方法),子类必须全部实现。

  7. 对于默认方法觉得有必要举个例子。

  8. java.util.List接口中有一个sort()默认方法,定义如下。

  9. interface list<E>{

  10. publi default void sort(Comparator <? super E> c ){//其实这个方法有些不太理解java类型系统知识点总结

  11. Collections.<E>sort(this,c);

  12. }

  13. }

  14. 还有一种是全空的标记接口,不需要在子类中实现任何方法,主要是方便将类的实例作为接口的有效实例,比如java.io.serializable接口,就是声明这个类的实例可以安全序列化(貌似是一种转换机制)。

  15. 2)java泛型

  16. 容器类型一般叫做泛型:

  17. interface Box<T>{

  18. void box (T t);

  19. T unbox();

  20. }

  21. 使用泛型可以增强程序的安全性——编译时会检查类型错误

  22. <T> 还有个名字叫参数类型,参数类型始终是引用类型,它的值不能使用基本类型。

  23. 在java中使用菱形句法可以省略重复的类型值:List<CerteredCircle> shapes = new ArrayList<>();

  24. 非泛型的List一般叫做原始类型(就是比较low了)

  25. 参数化类型也不能实例化,比如ArrayList<T>,但是编译时也需要了解这是什么类型,怎么办呢?使用通配<?>

  26. ArrayList<?> mysteryList = unknowList():

  27. Object o = mysteryList.get(0);

  28. java语言是禁止实例化负载为未知类型的容器类型,比如List<?> unknows = new ArrayList<?>();

  29. 还有合法的List<?> objets = new ArrayList<String>();

  30. 这表明,List<String>是List<?>的子类型。但是List<?>都不是List<T>子类型。

  31. 还有就是类型变体(有点抽象),举个例子就是List<cat>是List<? extends pet>子类型,因为List是Cat对象的制造者。

  32. 可以理解为PECS原则(制造者使用extends,使用者使用super)

  33. 作为java泛型的使用者,我们需要理解类型擦除(有点难理解)的基本知识,特别是运行时对泛型的处理方式。

  34. 这里再说一下编译时和运行时的一些差别,就是对比javac和JVM的区别。

  35. List<String> l = new ArrayList<>();

  36. System.out.println(l);

  37. 究竟有什么不同呢?可以想一下 l 的类型,结果是编译和运行两个阶段是不一样的。javac把l 看作List-of-String类型,会依照这个检查句法错误。

  38. 而jvm 呢,把l看成是ArrayList类型的对象,还因为要擦除类型,所以运行时l是原始类型(,,自己都有点糊涂了)

  39. java类型系统知识点总结java类型系统知识点总结java类型系统知识点总结

  40. 3)枚举和注解

  41. 这个还是举个例子更清楚:

  42. 枚举:

  43. public enum RegularPolygon{

  44. TRIANGLE(3),SQUARE(4);

  45. private Shape shape;

  46. public Shape getShape(){

  47. rerurn shape;

  48. }

  49. private RegularPolygon(int sides){

  50. switch(sides){
    case 3:

  51. shape = new Triangle(1,1,1,60,60,60);//边长和角度

  52. break;

  53. case 4:

  54. shape = new Rectangle(1,1);

  55. break;

  56. }

  57. }

  58. }

  59. 需要说明的是枚举实例是由java运行时创建的,在外部不能实例化,所以将构造方法声明为私有方法。

  60. 注解:(是一种特殊的接口)

  61. 常用的有@Override,@Deprecated,@SuppressWarnings,@SafeVarargs(变长参数方法提供警告静默),@FunctionInterface。

  62. 还有自定义注解,就是使用元注解@Target,@Retention。

  63. 看一个示例

  64. @Target(ElementType.METHOD)

  65. @Retention(RetentionPolicy.RUNTIME)

  66. public @interface Nickname{

  67. String[] value() default {} ;

  68. }

  69. 二:晚上计划

  70. 将剩余的两个知识点看完,嵌套类型和lambda表达式

  71. 三:遇到问题

  72. 有些知识点即使看过了还是不能充分理解,大概这就是看书的局限性吧

  73. 四:收获感悟

  74. 对于java8的lambda表达式,自己一直都是只闻其名,没有真正了解和使用过,这次要弥补这个缺憾。

  75. 分割线---------------------------------------------------------------------------------------------

    一:晚上完成

  76. 4)嵌套类型
    1.  先说一下自己对国外的翻译书籍《java技术手册》和国内著名博客的粗浅理解

    A 首先国外的书讲的知识点是精辟到位的,不止是为了方便读者理解而书写的,更多的是为了阐明某个知识点,但是这样会导致读起来左拐右拐的,有深有浅,对于初学者来说是不太好理解的,需要你有一定的知识积累,才能不受那些专业词汇的煎熬。

  77. B 而国内的博客文章就是春风化雨了,在国人普遍逻辑上尽可能以一种方便理解的视角去解读知识点,让你很快的就熟悉并掌握,不多涉及底层。
  78. C 只能说两者各有特点吧,与我而言,还是看博客更爽一点,等理解了再去翻看国外的技术书籍估计会有另外的收获
  79. 大神就是大神,代码境界真的是甩我几条街,我就不献丑了,也是为了大家能看懂。
  80. 再说说顶层类型有哪些(类、接口、枚举),它们都是包的直接成员。
    1. 引入嵌套的目的:深入访问另一个类型的内部实现;在特定情况下使用某个类型。

      有四种类型(不能简单的说是内部类或是匿名类,因为不能说静态成员类型是内部类),静态成员类型、非静态成员类型、局部类、匿名类。

    /**
    * 四种不同类型的内部类
    * @author Administrator
    *
    */
    public class OuterOfInnerClass {
    int out_x = 0;

    public void method() {
    Inner1 inner1 = new Inner1();
    final int a = -1;
    //在方法体内部定义的内部类,只允许使用抽象或终态
    /**
    * 局部内部类
    *
    */
    class Inner2 {
    public void method() {
    out_x = 3;
    System.out.println(a);
    }
    }
    Inner2 inner2 = new Inner2();
    }
    /**
    *成员内部类 Inner Class
    *
    */
    public class Inner1 {

    }
    /**
    * 静态内部类 Static Nested Class
    *
    */
    public static class Inner3 {
    int a = new OuterOfInnerClass().out_x;
    public void aa() {

    }
    }

    public ParentAbstract rr() {
    /**
    * 匿名内部类
    */
    return new ParentAbstract() {
    void save() {
    }
    };
    }
    public void testInner1() {
    int b = 1;
    OuterOfInnerClass oo = new OuterOfInnerClass();

    OuterOfInnerClass.Inner1 inner1 = oo.new Inner1();
    }

    }

    abstract class ParentAbstract {
    abstract void save();
    }  

5):lambda表达式
听说,lambda表达式的很多功能都能使用嵌套类通过回调和处理程序等模式实现(我是没有见过)
有些人喜欢把lambda表达式当成“匿名方法”(是吗?)
做一个简单的对比吧。
A 使用匿名类定义一个FilenameFilter类,列出后缀是.java的文件
File dir = new File("/src");
String[] filelist = dir.list(new FilenameFilter(){
public boolean accept(File f, String s)
  return s.endWith(".java");
}
} );
B 使用lambda表达式,上述代码可以简化为:
File dir = new File("/src");
String [] filelist = dir.list((f,s) -> {return s.endwith(".java");});
天呐,这真是太方便了!!!
C 因为可以把lambda表达式看成是没有名称的方法,所以可以这样使用:(Myobject myObj) -> myObj.toString()
java8提供了一种句法可以更方便
MyObject::toString 哈哈,真的是简洁
D 函数式编程有一个共识:把函数当成值,存入变量
对于java开发者刚开始接触的话建议使用这三个基本习语map() filter() reduce()
但是还是要记得java没有结构类型,没有“真正的”函数类型
二:明天计划
只是看书的话某些语法知识点还是理解的不透彻,还是找点做项目实战吧
三:遇到问题
希望可以见到更多使用内部类的代码,看看真正这种东西是用在那些地方的
四:总结思考
感觉这样翻看知识点效率有点低,没有针对性,还是 “做中学” 吧