Jason Zhao's List: Java 基础

• Java 语言中的泛型基本上完全在编译器中实现，由编译器执行类型检查和类型推断，然后生成普通的非泛型的字节码。这种实现技术称为 擦除（erasure）（编译器使用泛型类型信息保证类型安全，然后在生成字节码之前将其清除）
• 泛型不是协变的
• 如果 Number是 Integer的超类型，那么 Number[]也是 Integer[]的超类型
• 数组能够协变而泛型不能协变的另一个后果是，不能实例化泛型类型的数组（new List<String>[3]是不合法的），除非类型参数是一个未绑定的通配符（new List<?>[3]是合法的）

2 more annotations...

• • $("strong").css('background-color','#fff').css('font-weight','normal').css('color','#4b4b4b')
• 通过知道使用泛型定义的变量的类型限制，编译器可以在一个高得多的程度上验证类型假设
• 类型安全。
• 类型错误现在就可以在编译时被捕获了，而不是在运行时当作 ClassCastException 展示出来。将类型检查从运行时挪到编译时有助于您更容易找到错误，并可提高程序的可靠性。
• 消除强制类型转换。
• 潜在的性能收益。
• 多类型信息可用于编译器这一事实，为未来版本的 JVM 的优化带来可能
• 除了异常类型、枚举或匿名内部类以外，任何类都可以具有类型参数。
• 泛型不是协变的
• 解决方案是使用类型通配符
• 可以从中检索元素，但是不能添加元素。原因不是编译器知道哪些方法修改列表哪些方法不修改列表，而是（大多数）变化的方法比不变化的方法需要更多的类型信息
• 注意下面的代码将能工作，因为它不依赖于编译器必须知道关于 lu 的类型参数的任何信息
• 之所以声明泛型方法，一般是因为您想要在该方法的多个参数之间宣称一个类型约束

• 为什么您选择使用泛型方法，而不是将类型 T 添加到类定义呢？（至少）有两种情况应该这样做：

   

  当泛型方法是静态的时，这种情况下不能使用类类型参数。

   

  当 T 上的类型约束对于方法真正是局部的时，这意味着没有在相同类的另一个 方法签名中使用相同 类型 T 的约束。通过使得泛型方法的类型参数对于方法是局部的，可以简化封闭类型的签名
• V extends Number
• 在没有类型限制时，假设类型参数由 Object 限制
• 泛型类最常见的用例是容器类（比如集合框架）或者值持有者类（比如 WeakReference 或 ThreadLocal）
• array = (V[]) new Object[capacity];
• 也可以使用反射来实例化数组。但是这样做需要给构造函数传递一个附加的参数 —— 一个类常量，比如 Foo.class。
• 改善集合类的类型安全是 Java 语言中泛型的主要动机
• 这阐述了泛型化一个现有的类要比定义一个新的泛型类难得多，因为您必须注意不要更改类的语义或者破坏现有的非泛型代码
• 如何创建一个 Class<T> 类型的实例？就像使用非泛型代码一样，有两种方式：调用方法 Class.forName() 或者使用类常量 X.class。Class.forName() 被定义为返回 Class<?>。另一方面，类常量 X.class 被定义为具有类型 Class<X>，所以 String.class 是 Class<String> 类型的。
• 第一部分指出，作为 Enum 的类型参数的类本身必须是 Enum 的子类型，所以您不能声明一个类 X 扩展 Enum<Integer>。第二部分指出，任何扩展 Enum 的类必须传递它本身 作为类型参数。您不能声明 X 扩展 Enum<Y>，即使 Y 扩展 Enum。
• 声明为 List 类型而不是 List<Something> 类型的变量，叫做原始类型
• List 是原始类型；List<?> 是具有未知类型参数的泛型。编译器将以不同的方式对待它们，并很可能发出更少的警告。

23 more annotations...

• 使用 Class.forName 载入指定的类，然后调用 getDeclaredMethods 来获取这个类中定义了的方法列表
• 第一步是获得你想操作的类的 java.lang.Class 对象
• 第二步是调用诸如 getDeclaredMethods 的方法，以取得该类中定义的所有方法的列表。
• 第三步了——使用 reflection API 来操作这些信息
• 参数类型、异常类型和返回值类型
• Modifier，它也是一个 reflection 类，用来描述字段成员的修饰语，如“private int”。这些修饰语自身由整数描述，而且使用 Modifier.toString 来返回以“官方”顺序排列的字符串描述 (如“static”在“final”之前)
• 根据方法的名称来执行方法
• reflection 可以从正在运行的程序中根据名称找到对象的字段并改变它

6 more annotations...

• Java 源程序（.java 文件）在经过 Java 编译器编译之后就被转换成 Java 字节代码（.class 文件）。类加载器负责读取 Java 字节代码，并转换成 java.lang.Class类的一个实例。每个这样的实例用来表示一个 Java 类。通过此实例的 newInstance()方法就可以创建出该类的一个对象。
• 引导类加载器
• 扩展类加载器
• 系统类加载器
• 开发人员可以通过继承 java.lang.ClassLoader类的方式实现自己的类加载器，以满足一些特殊的需求
• 有些 JDK 的实现对于父类加载器是引导类加载器的情况，getParent()方法返回 null
• Java 虚拟机不仅要看类的全名是否相同，还要看加载此类的类加载器是否一样。只有两者都相同的情况，才认为两个类是相同的
• 代理模式是为了保证 Java 核心库的类型安全。所有 Java 应用都至少需要引用 java.lang.Object类，也就是说在运行的时候，java.lang.Object这个类需要被加载到 Java 虚拟机中。如果这个加载过程由 Java 应用自己的类加载器来完成的话，很可能就存在多个版本的 java.lang.Object类，而且这些类之间是不兼容的。通过代理模式，对于 Java 核心库的类的加载工作由引导类加载器来统一完成，保证了 Java 应用所使用的都是同一个版本的 Java 核心库的类，是互相兼容的
• Class.forName的一个很常见的用法是在加载数据库驱动的时候
• 比如您的应用通过网络来传输 Java 类的字节代码，为了保证安全性，这些字节代码经过了加密处理。这个时候您就需要自己的类加载器来从某个网络地址上读取加密后的字节代码，接着进行解密和验证，最后定义出要在 Java 虚拟机中运行的类来

8 more annotations...

• HashMap不是线程安全的，因此如果在使用迭代器的过程中有其他线程修改了map，那么将抛出ConcurrentModificationException，这就是所谓fail-fast策略
• 在迭代器初始化过程中会将这个值赋给迭代器的expectedModCount
• JDK1.0引入了第一个关联的集合类HashTable，它是线程安全的。HashTable的所有方法都是同步的
• JDK5.0util.concurrent包中引入对Map线程安全的实现ConcurrentHashMap，比起synchronizedMap，它提供了更高的灵活性。同时进行的读和写操作都可以并发地执行
• ArrayList也是非线程安全的
• util.concurrent包也提供了一个线程安全的ArrayList替代者CopyOnWriteArrayList

4 more annotations...

• 当size>=容量*加载因子大于或等于table.length，容量扩大一倍

• 1.根据key的hash值（hashCode()）,到HashMap提供的hash方法里面加工一下(这里暂时这么理解)

   

  

   

      static int hash(int h) {         // This function ensures that hashCodes that differ only by         // constant multiples at each bit position have a bounded         // number of collisions (approximately 8 at default load factor).         h ^= (h >>> 20) ^ (h >>> 12);         return h ^ (h >>> 7) ^ (h >>> 4);     }

   

  

   

  　　　　　　这是一段神奇的代码~表示看不懂，你们可以深入研究。参数h为对象hashcode()方法返回值。

   

   

   

  　　2.取到加工后的hash码后然后根据indexFor()方法取到index(这里可以说是hash算法的核心，所有操作的基于它的。)

   

   

      static int indexFor(int h, int length) {         return h & (length-1);     }

  • Hash算法的核心！！看看就好==
• 如果条件满足，数组扩大一倍,也就是调用resize(length)方法

  • Rehash这个Map！

1 more annotation...

• 当内存空间不足，Java虚拟机宁愿抛出OutOfMemoryError错误，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足的问题
• 如果一个对象只具有软引用，则内存空间足够，垃圾回收器就不会回收它；如果内存空间不足了，就会回收这些对象的内存
• 在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存
• 虚引用必须和引用队列 （ReferenceQueue）联合使用。当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之 关联的引用队列中
• 如果程序发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动
• ◆单条引用路径可及性判断:在这条路径中，最弱的一个引用决定对象的可及性。

   

  ◆多条引用路径可及性判断:几条路径中，最强的一条的引用决定对象的可及性
• 如果能重新获取那些尚未被回收的Java对象的引用，必将减少不必要的访问，大大提高程序的运行速度
• SoftReference
• 有两个引用路径，一个是来自SoftReference对象的软引用，一个来自变量aReference的强引用，所以这个MyObject对象是强可及对象
• 当软可及对象被回收之后，虽然这个SoftReference对象的get()方法返回null,但这个SoftReference对象已经不再具有存在的价值，需要一个适当的清除机制，避免大量SoftReference对象带来的内存泄漏
• ReferenceQueue
• 那么当这个SoftReference所软引用的aMyOhject被垃圾收集器回收的同时，ref所强引用的SoftReference对象被列入ReferenceQueue
• WeakHashMap能够节约存储空间，可用来缓存那些非必须存在的数据

11 more annotations...

• 1、静态集合类引起内存泄露：
   像HashMap、Vector等的使用最容易出现内存泄露，这些静态变量的生命周期和应用程序一致，他们所引用的所有的对象Object也不能被释放，因为他们也将一直被Vector等引用着

  • 用WeakReference，比如WeakHashMap
• 2、当集合里面的对象属性被修改后，再调用remove（）方法时不起作用。

  • 如果集合中的元素类型重载了hashcode()方法，并且修改的属性影响了hashcode的值，这样remove()就不会起作用！
• 调用一个控件的诸如addXXXListener()等方法来增加监听器，但往往在释放对象的时候却没有记住去删除这些监听器，从而增加了内存泄漏的机会
• 数据库连接（dataSourse.getConnection()），网络连接(socket)和io连接，除非其显式的调用了其close（）方法将其连接关闭，否则是不会自动被GC 回收的
• 如果使用连接池，情况就不一样了，除了要显式地关闭连接，还必须显式地关闭Resultset  Statement 对象
• 内部类和外部模块等的引用
• 单例对象在被初始化后将在JVM的整个生命周期中存在（以静态变量的方式），如果单例对象持有外部对象的引用，那么这个外部对象将不能被jvm正常回收，导致内存泄露

5 more annotations...

• 栈的优势是，存取速度比堆要快，仅次于寄存器，栈数据可以共享。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。栈中主要存放一些基本类 型的变量（,int, short, long, byte, float, double, boolean, char）和对象句柄

  • 栈：速度快、可共享、生存期确定、不灵活
    堆：动态分配大小、灵活、存取速度慢
• 就是存在栈中的数据可以共享
• 因为这种情况a的修改并不会影响到b, 它是由编译器完成的，它有利于节省空间
• 而对于String str = new String("abc")；的代码，则一概在堆中创建新对象

2 more annotations...