class对象及类的初始化过程

第十四章类型信息

14.2 加载，链接，初始化 具体详细 简洁明了

• Java字节代码的表现形式是字节数组（byte[]），而Java类在JVM中的表现形式是java.lang.Class类的对象。
• 这三个步骤中，对开发人员直接可见的是Java类的加载，通过使用Java类加载器（class loader）可以在运行时刻动态的加载一个Java类；而链接和初始化则是在使用Java类之前会发生的动作。
• 所有的类都是在对其第一次使用时，动态加载到JVM中的。当程序创建第一个对类的静态成员的引用时，就会加载这个类。这个证明构造方法也是类的静态方法，及时在构造器之前并没有使用statis关键字。因此，使用new操作符创建类的新对象也会被当做对类的静态成员的引用。

JVM和类

• 首先编译：javac将.java文件编译为.class字节码文件。然后运行：调用Java命令运行Java程序时，该命令将会启动一条Java虚拟机进程，进行类的初始化。不管该Java程序启动了多少条线程，创建了多少个变量，它们都处于该Java虚拟机进程里，共享该JVM进程的内存区。当系统出现以下几种情况时，JVM进程将被终止：

  • 程序运行到最后正常结束；
  • 程序运行到使用System.exit()或Runtime.getRuntime.exit()代码结束程序；
  • 程序运行过程中遇到未捕获的异常或错误而结束；
  • 程序所在的平台强制结束了JVM进程。

符号引用和直接引用

• 在java中，一个java类将会编译成一个class文件。在编译时，java类并不知道引用类的实际内存地址，因此只能使用符号引用来代替。比如org.simple.People类引用org.simple.Tool类，在编译时People类并不知道Tool类的实际内存地址，因此只能使用符号org.simple.Tool(假设)来表示Tool类的地址。而在类装载器装载People类时，此时可以通过虚拟机获取Tool类 的实际内存地址，因此便可以既将符号org.simple.Tool替换为Tool类的实际内存地址，即直接引用地址。

1. 加载

• 类加载器分成两类：启动类加载器（bootstrap）和用户自定义的类加载器（user-defined）。两者的区别在于启动类加载器是由JVM的原生代码实现的，而用户自定义的类加载器都继承自Java中的java.lang.ClassLoader类
• 类加载器需要完成的最终功能是定义一个Java类，即把Java字节代码转换成JVM中的java.lang.Class类的对象。

• Java类加载器有两个比较重要的特征：层次组织结构和代理模式。层次组织结构指的是每个类加载器都有一个父类加载器，通过getParent()方法可以获取到。类加载器通过这种父亲-后代的方式组织在一起，形成树状层次结构。代理模式则指的是一个类加载器既可以自己完成Java类的定义工作，也可以代理给其它的类加载器来完成。由于代理模式的存在，启动一个类的加载过程的类加载器和最终定义这个类的类加载器可能并不是一个。前者称为初始类加载器，而后者称为定义类加载器。两者的关联在于：一个Java类的定义类加载器是该类所导入的其它Java类的初始类加载器。比如类A通过import导入了类 B，那么由类A的定义类加载器负责启动类B的加载过程。

  一般的类加载器在尝试自己去加载某个Java类之前，会首先代理给其父类加载器。当父类加载器找不到的时候，才会尝试自己加载。这个逻辑是封装在java.lang.ClassLoader类的loadClass()方法中的。一般来说，父类优先的策略就足够好了。在某些情况下，可能需要采取相反的策略，即先尝试自己加载，找不到的时候再代理给父类加载器。这种做法在Java的Web容器中比较常见，也是Servlet规范推荐的做法。比如，Apache Tomcat为每个Web应用都提供一个独立的类加载器，使用的就是自己优先加载的策略。IBM WebSphere Application Server则允许Web应用选择类加载器使用的策略。

• 类加载器的一个重要用途是在JVM中为相同名称的Java类创建隔离空间。在JVM中，判断两个类是否相同，不仅是根据该类的二进制名称，还需要根据两个类的定义类加载器。只有两者完全一样，才认为两个类的是相同的。因此，即便是同样的Java字节代码，被两个不同的类加载器定义之后，所得到的Java类也是不同的。如果试图在两个类的对象之间进行赋值操作，会抛出java.lang.ClassCastException。这个特性为同样名称的Java类在JVM中共存创造了条件。

2. 链接

• Java类的链接指的是将Java类的二进制代码合并到JVM的运行状态之中的过程。在链接之前，这个类必须被成功加载。类的链接包括验证、准备和解析等几个步骤。1.验证是用来确保Java类的二进制表示在结构上是完全正确的。如果验证过程出现错误的话，会抛出java.lang.VerifyError错误。2.准备过程则是创建Java类中的静态域，并将这些域的值设为默认值。准备过程并不会执行代码。3.在一个Java类中会包含对其它类或接口的形式引用，包括它的父类、所实现的接口、方法的形式参数和返回值的Java类等。解析的过程就是确保这些被引用的类能被正确的找到。解析的过程可能会导致其它的Java类被加载【当程序主动使用某个类时，如果该类还没有被加载到内存中，系统会通过加载、连接、初始化这三个步骤来对该类进行初始化（如果没有意外，JVM将会连续完成这三个步骤，所以有时也会把这三个步骤统称为类的加载或初始化)】。
• 不同的JVM实现可能选择不同的解析策略。一种做法是在链接的时候，就递归的把所有依赖的形式引用都进行解析。而另外的做法则可能是只在一个形式引用真正需要的时候才进行解析。也就是说如果一个Java类只是被引用了，但是并没有被真正用到，那么这个类有可能就不会被解析。考虑下面的代码：

public class LinkTest {   
   public static void main(String[] args) {       
      ToBeLinked toBeLinked = null;       
      System.out.println("Test link.");   
   }
}

类 LinkTest引用了类ToBeLinked，但是并没有真正使用它，只是声明了一个变量，并没有创建该类的实例或是访问其中的静态域。在 Oracle的JDK 6中，如果把编译好的ToBeLinked的Java字节代码删除之后，再运行LinkTest，程序不会抛出错误。这是因为ToBeLinked类没有被真正用到，而Oracle的JDK 6所采用的链接策略使得ToBeLinked类不会被加载，因此也不会发现ToBeLinked的Java字节代码实际上是不存在的。如果把代码改成ToBeLinked toBeLinked = new ToBeLinked();之后，再按照相同的方法运行，就会抛出异常了。因为这个时候ToBeLinked这个类被真正使用到了，会需要加载这个类。

3. 初始化

• 当一个Java类第一次被真正使用到的时候，JVM会进行该类的初始化操作。
• 初始化过程的主要操作是执行静态代码块和初始化静态域。
• 在一个类被初始化之前，它的直接父类也需要被初始化。但是，一个接口的初始化，不会引起其父接口的初始化。
• 在初始化的时候，会按照源代码中从上到下的顺序依次执行静态代码块和初始化静态域

• hh

  public class StaticTest {   
  public static int X = 10;   
  public static void main(String[] args) {       
      System.out.println(Y); //输出60   
  }   
     static {       
        X = 30;   
     }  
     public static int Y = X * 2;
  }

  在上面的代码中，在初始化的时候，静态域的初始化和静态代码块的执行会从上到下依次执行。因此变量X的值首先初始化成10，后来又被赋值成30；而变量Y的值则被初始化成60。main最后执行。

  Java类和接口的初始化只有在特定的时机才会发生，这些时机包括：

  1. 创建一个Java类的实例。如MyClass obj = new MyClass()
  2. 调用一个Java类中的静态方法。如MyClass.sayHello()
  3. 给Java类或接口中声明的静态域赋值。如MyClass.value = 10
  4. 访问Java类或接口中声明的静态域，并且该域不是常值变量。如 int value = MyClass.value
  5. 在顶层Java类中执行assert语句。
  6. 通过Java反射API也可能造成类和接口的初始化。需要注意的是，当访问一个Java类或接口中的静态域的时候，只有真正声明这个域的类或接口才会被初始化。考虑下面的代码：
     

     class B {   
        static int value = 100;   
        static {       
           System.out.println("Class B is initialized."); //输出   
        }
     }
     class A extends B {   
        static {       
           System.out.println("Class A is initialized."); //不会输出   
        }
     }
     public class InitTest {   
        public static void main(String[] args) {       
           System.out.println(A.value); //输出100   
        }
     }

  在上述代码中，类InitTest通过A.value引用了类B中声明的静态域value。由于value是在类B中声明的，只有类B会被初始化，而类A则不会被初始化。

自定义类加载器

• 在 Java应用开发过程中，可能会需要创建应用自己的类加载器。典型的场景包括实现特定的Java字节代码查找方式、对字节代码进行加密/解密以及实现同名 Java类的隔离等。创建自己的类加载器并不是一件复杂的事情，只需要继承自java.lang.ClassLoader类并覆写对应的方法即可。 java.lang.ClassLoader中提供的方法有不少，下面介绍几个创建类加载器时需要考虑的：

  • defineClass()：这个方法用来完成从Java字节代码的字节数组到java.lang.Class的转换。这个方法是不能被覆写的，一般是用原生代码来实现的。
  • findLoadedClass()：这个方法用来根据名称查找已经加载过的Java类。一个类加载器不会重复加载同一名称的类。
  • findClass()：这个方法用来根据名称查找并加载Java类。
  • loadClass()：这个方法用来根据名称加载Java类。
  • resolveClass()：这个方法用来链接一个Java类。

  这里比较 容易混淆的是findClass()方法和loadClass()方法的作用。前面提到过，在Java类的链接过程中，会需要对Java类进行解析，而解析可能会导致当前Java类所引用的其它Java类被加载。在这个时候，JVM就是通过调用当前类的定义类加载器的loadClass()方法来加载其它类的。findClass()方法则是应用创建的类加载器的扩展点。应用自己的类加载器应该覆写findClass()方法来添加自定义的类加载逻辑。 loadClass()方法的默认实现会负责调用findClass()方法。

  前面提到，类加载器的代理模式默认使用的是父类优先的策略。这个策略的实现是封装在loadClass()方法中的。如果希望修改此策略，就需要覆写loadClass()方法。

  下面的代码给出了自定义的类加载的常见实现模式：

  public class MyClassLoader extends ClassLoader {   
      protected Class<?> findClass(String name) throws ClassNotFoundException {       
      byte[] b = null; //查找或生成Java类的字节代码       
      return defineClass(name, b, 0, b.length);   
      }
  }

编译期常量

• 如果一个static final值是编译期常量，如 static final age =10,(个人觉得如果没有设初始值，也算编译期常量吧，0)那么这个值不需要对其所在类进行初始化就可以被读取。但是，如果只是一个static final,还不足以确保这种行为例如，static final age =10+3;因为他不是一个编译期常量，他的值在运行期，代码运行后才能确定。

java中静态属性，静态方法 和 静态初始化器(静态态代码段)

• 非static的方法是属于某个对象的方法，在这个对象创建时对象的方法在内存中拥有自己专用的代码段；而static的方法是属于整个类的，它在内存中的代码段将随着类的定义而分配和装载，不被任何一个对象专有：
• 构造函数是在用new运算符产生新对象时由系统自动执行，而静态初始化器则是在它所属的类加载入内存时由系统调用运行的，当然是先有类，再有对象；而且静态块在给类分配内存的时候就会被执行，和静态变量一样。所以静态初始化器先于构造函数。；
• static 与实例无关，哪怕你创建实例后，你在销毁实例后，static里面的东西依然存在，直到线程over。
  JAVA在执行程序的时候首先装载类，然后找main()
  所以，在装载类的时候，遇到static马上执行，
  因此，

14.3 强制类型转换

• 首先我们先构造一个Son对象，然后用一个Father类型变量引用它：

  Father father = new Son();

  在这里Son 对象实例被向上转型为father了，但是请注意这个Son对象实例在内存中的本质还是Son类型的，只不过它的能力临时被消弱了而已，如果我们想变强怎么办？将其对象类型还原！

  Son son = (Son)father;

  这条语句是可行的，其实father引用仍然是Father类型的，只不过是将它的能力加强了，将其加强后转交给son引用了，Son对象实例在son的变量的引用下，恢复真身，可以使用全部功能了。

• 前面提到父类强制转换成子类并不是总是成功，那么在什么情况下它会失效呢？

  当引用类型的真实身份是父类本身的类型时，强制类型转换就会产生错误。例如：
  Father father = new Father();

  Son son = (Son) father;

  这个系统会抛出ClassCastException异常信息。

14.5 Class类型信息

• 每一个Class类的对象就代表了一种被加载进入JVM的类，他代表了该类的一种信息映射。
• 开发者可以通过三种途径获得一个类的Class对象：
  
  1. Class类的ForName()方法的返回值。
  2. 访问所有类都用的静态属性—class
  3. 调用父类Obejct的方法getClass()，并不是静态的。
• 在Class类中，定义许多关于一个类详细信息的方法。例如，getName(),getMethod(),getConstructoe(),newInstance()等可以用于反射开发，还有isInstance()和isInterface()等一些关于类的功能方法。
• Class > Methods > isInstance(obj) 判断一个对象属于不属于这个类型。子类也算

public boolean isInstance(Object obj)
Determines if the specified Object is assignment-compatible with the object represented by this Class. This
method is the dynamic equivalent of the Java language instanceof operator. The method returns true if the
specified Object argument is non-null and can be cast to the reference type represented by this Class
object without raising a ClassCastException. It returns false otherwise.

• isAssignableFrom(Class

public boolean isAssignableFrom(Class<?> cls)
Determines if the class or interface represented by this Class object is either the same as, or is a superclass or superinterface of, the class or interface represented by the specified Class parameter. It returns true if so; otherwise it returns false. If this Class object represents a primitive type, this method returns true if the specified Class parameter is exactly this Class object; otherwise it returns false.

14.6 反射:运行时的类信息

• RTTI与反射的真正区别：
  对RTTI来说，编译器在编译时打开和检查.class文件(换句话说，我们可以通过“普通”方式调用对象的所有方法。)。而对于反射来说，.class文件在编译时是不可获取的，所以是在运行时打开和检查.class文件。
• java用Class类来代表了所有的类，方便了开发者掌控类信息。通过Class，开发者可以得到属性(Field)，方法(Method)，构造器(Construrtor)，修饰符(Modifier)。
• 操作类的成员变量(Field):getXXX,setXXX
  
class FieldTest{
public String name;
public String age;
}
FieldTest test = new FieldTest();
Field f = FieldTest.class.getDeclaredField("age");
int val = (Intesget)f.get(test);

• 操作类的方法(静态和非静态) getMethod getMethods
  
Class<MethodTest> c = MethodTest.class;
Method m = c.getDeclaredMethod("m2",String.class);
MethodTest obj = c.newInstance();
m.invoke(obj,"我知道了,要传参数啊,玛德");

• 使用构造器进行实例化
  
Class<Student> studentClass = Student.class;
cons = studentClass.getConstructor(String.class, int.class);
stu = cons.newInstance("wang", 20);
System.out.println(stu);


14.7 实现动态代理

class DynamicProxyObj implements InvocationHandler{
    private Inter realObj;

    public DynamicProxyObj(Inter realObj) {
        this.realObj = realObj;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("------proxy:"+ proxy.getClass() + " , method " + method + " , args "+ args);
        if(args!=null)
        for(Object arg : args) {System.out.println("   "+arg);}
        return method.invoke(realObj, args);


Inter proxy = (Inter)Proxy.newProxyInstance(Inter.class.getClassLoader(), new Class[]{ Inter.class }, new DynamicProxyObj(r));
proxy.doFirst();
proxyi.doSecond("22");

14.8 空对象

    public static class NullPerson extends Person implements  Null{
        private NullPerson(){
            super("None", "None", "None");
        }
    }

public static final Person NULL= new NullPerson();