Java内存泄漏：指无用对象持续占有内存或无用对象的内存得不到及时释放，从而造成空间的浪费称为内存泄露。Java内存泄露的根本原因，指长生命周期的对象持有短生命周期对象的引用就很可能发生内存泄露，尽管短生命周期对象已经不再需要，但是因为长生命周期对象持有短生命周期对象引用而导致不能被回收。

1. 静态集合类引起的内存泄露，HashMap, Vector等他们引用的所有短生命周期对象当没用后，如果没有从集合中remove都是内存泄漏
2. 在hashset集合中，当你自定义你的hashcode()方法后，当集合里面的对象属性(影响hashcode计算的属性)被修改后，hashcode()发生改变，再调用remove()方法时不起作用，不会把对象从hashset中移除
3. 监听器 通常一个应用当中会用到很多监听器，我们会调用一个控件的诸如addXXXListener()等方法来增加监听器，但往往在释放对象的时候却没有记住删除这些监听器，从而增加了内存泄漏的机会。
4. 各种连接 数据库连接，网络连接和io连接，除非其显示的调用了其close()方法将其连接关闭，否则是不会自动被GC回收的
5. 内部类和外部模块等的引用 内部类的引用是比较容易遗忘的一种，而且一旦没释放可能导致一系列对象没有释放。小心外部模块不经意的引用，如果a模块引用了对象b,public void registerMsg(Object b); 注意是否有对b引用没有去除
6. 单例模式 单例对象在被初始化后将在JVM的整个生命周期中存在（以静态变量的方式），如果单例对象持有外部对象的引用，那么这个外部对象将不能被jvm正常回收，内存泄漏。

Volatile 关键字，当我们使用volatile关键字去修饰变量时，所有线程都会直接读取该变量并且不缓存它，意思是不会从寄存器中去读取，这就确保了线程读取到的变量是同内存中是一致的。

1. public（公共的）：被public所修饰的属性和方法可以被所有类访问。
2. protected（受保护的）：被protected所修饰的属性和方法可以在类内部、相同包以及该类的子类所访问。
3. private（私有的）：被private所修饰的属性和方法只能在该类内部使用
4. 默认的（不加任何访问修饰符）：在类内部以及相同包下面的类所使用。

String s = “aaa”;（采用字面值方式赋值）

1. 查找String Pool中是否存在“aaa”这个对象，如果不存在，则在String Pool中创建一个“aaa”对象，然后将String Pool中的这个“aaa”对象的地址返回来，赋给引用变量s，这样s会指向String Pool中的这个“aaa”字符串对象
2. 如果存在，则不创建任何对象，直接将String Pool中的这个“aaa”对象地址返回来，赋给s引用。

String s = new String(“aaa”);

1. 首先在String Pool中查找有没有“aaa”这个字符串对象，如果有，则不在String Pool中再去创建“aaa”这个对象了，直接在堆中（heap）中创建一个“aaa”字符串对象，然后将堆中的这个“aaa”对象的地址返回来，赋给s引用，导致s指向了堆中创建的这个“aaa”字符串对象。
2. 如果没有，则首先在String Pool中创建一个“aaa“对象，然后再在堆中（heap）创建一个”aaa“对象，然后将堆中的这个”aaa“对象的地址返回来，赋给s引用，导致s指向了堆中所创建的这个”aaa“对象。

1. int[] a = new int[10]
2. Int a[] = new int[10];
3. Int[] a = {0,1,2,3,4,5,6,7,8,9};

当向ArrayList添加一个对象时，实际上就是将该对象放置到了ArrayList底层所维护的数组当中；当向LinkedList中添加一个对象时，实际上LinkedList内部会生成一个Entry对象，该Entry对象的结构为：

Entry
{
Entry previous;
Object element;
Entry next;
}

其中的Object类型的元素element就是我们向LinkedList中所添加的元素，然后Entry又构造好了向前与向后的引用previous、next，最后将生成的这个Entry对象加入到了链表当中。换句话说，LinkedList中所维护的是一个个的Entry对象。

当使用HashSet时，hashCode()方法就会得到调用，判断已经存储在集合中的对象的hash code值是否与增加的对象的hash code值一致；如果不一致，直接加进去；如果一致，再进行equals方法的比较，equals方法如果返回true，表示对象已经加进去了，就不会再增加新的对象，否则加进去。
如果我们重写equals方法，那么也要重写hashCode方法，反之亦然。 注意String类重写了hashCode（）方法和equals()方法，new 两个相同字符串的String对象只有一个能加进去。

1. 使用Class类的静态方法forName：Class.forName(“java.lang.String”);
2. 使用类的.class语法：String.class;
3. 使用对象的getClass()方法：String s = “aa”; Class<?> clazz = s.getClass();

1. 先获得Class对象，然后通过该Class对象的newInstance()方法直接生成即可：
   Class<?> classType = String.class; Object obj = classType.newInstance();
2. 先获得Class对象，然后通过该对象获得对应的Constructor对象，再通过该Constructor对象的newInstance()方法生成：
   Class<?> classType = Customer.class; Constructor cons = classType.getConstructor(new Class[]{}); Object obj = cons.newInstance(new Object[]{});
   若想通过类的带参数的构造方法生成对象，只能使用下面这一种方式：
   Class<?> classType = Customer.class; Constructor cons = classType.getConstructor(new Class[]{String.class, int.class}); Object obj = cons.newInstance(new Object[]{“hello”, 3});

1. 创建一个实现接口InvocationHandler的类，它必须实现invoke方法
2. 创建被代理的类以及接口
3. 通过Proxy的静态方法 newProxyInstance(ClassLoader loader,Class[] interfaces,InvocationHandler h)创建一个代理
4. 通过代理调用方法

1. 静态内部类（static inner class）：只能访问外部类的静态成员变量与静态方法，生成静态内部类对象的方式为：
   OuterClass.InnerClass inner = new OuterClass.InnerClass();
2. 成员内部类（member inner class）：可以访问外部类的静态与非静态的方法与成员变量。生成成员内部类对象的方式为：
   OuterClass.InnerClass inner = new OuterClass().new InnerClass();
   若想在局部内部类中访问外部类的成员变量，语法为：OuterClass.this.a;
3. 局部内部类（Local Inner Class）：定义在方法当中，只能访问方法中声明的final类型的变量。
4. 匿名内部类（Anonymous Inner Class）：匿名内部类会隐式地继承一个父类或实现一个接口。

1. 加载：查找并加载类的二进制数据。把字节码文件加载到内存中
2. 连接：
3. 验证：确保被加载的类的正确性 （编译后的字节码是否正确）
4. 准备：为类的静态变量分配内存，并将其初始化（分配默认值）
5. 解析：把类中的符号引用转换为直接引用
6. 初始化：为类的静态变量赋予正确的初始值（正确的初始值指用户附的，执行静态代码块）

1. 创建类的实例
2. 访问某个类或接口的静态变量，或者对该静态变量赋值
3. 调用类的静态方法
4. 反射（如 Class.forName(“xxx”)）
5. 初始化一个类的子类
6. Java虚拟机启动时被标明为启动类的类（同一个Java文件包含多个类）

1. Java虚拟机自带的加载器
   1. 根类加载器（BootStrap）使用C++编写，程度员无法在Java代码中获得
   2. 扩展类加载器，使用Java代码实现
   3. 系统类加载器（应用加载器），使用Java代码实现
2. 用户自定义的类加载器都是java.lang.ClassLoader的子类，用户可以定制类的加载方式