package com.uno.staticBlock;

import java.lang.reflect.Field;
import java.util.Vector;

/**
 * 验证静态代码块和构造代码块执行顺序
 * 
 * 1.加载父类静态代码块
 * 2.加载子类静态代码块
 * 3.加载父类构造代码块
 * 4.父类构造方法
 * 5.子类构造代码块
 * 6.子类构造方法
 * @author uno
 *
 */
public class StaticBlock {

	//1.加载MyClass时，不一定会执行static代码块
	static ClassLoader loader = Thread.currentThread().getContextClassLoader();
	public static void main(String[] args) {
		printClassesOfClassLoader(loader);
//		testClassLoader();
		new SON();
		printClassesOfClassLoader(loader);
	}
	/**
	 * 测试静态代码块是否执行
	 * 
	 * 2017年11月20日
	 * author: leipan
	 */
	public static void testClassLoader(){
//		System.out.println("此方法加载class后不会执行static代码块," + MyClass.class + ",但会加载到ClassLoader中。");
	}
	
	
	 public static void printClassesOfClassLoader(ClassLoader loader){  
	        try {  
	            Field classesF = ClassLoader.class.getDeclaredField("classes");  
	            classesF.setAccessible(true);  
	            Vector<Class<?>> classes = (Vector<Class<?>>) classesF.get(loader);  
	            for(Class c : classes) {  
	                System.out.println(c);  
	            }  
	        } catch (NoSuchFieldException e) {  
	            e.printStackTrace();  
	        } catch (IllegalAccessException e) {  
	            e.printStackTrace();  
	        }  
	    }  
}

class Father {
	static {
		System.out.println("Father static exec。");
	}
	{
		System.out.println("Father unstatic exec。");
	}
	
	public Father (){
		System.out.println("Father Construction。");
	}
}
class SON extends Father{
	static {
		System.out.println("myClass static exec。");
	}
	{
		System.out.println("myClass unstatic exec。");
	}
	public SON (){
		System.out.println("Son construction。");
	}
}
 

 
 
结果：
 

class com.uno.staticBlock.StaticBlock
Father static exec。
myClass static exec。
Father unstatic exec。
Father Construction。
myClass unstatic exec。
Son construction。
class com.uno.staticBlock.StaticBlock
class com.uno.staticBlock.Father
class com.uno.staticBlock.SON


 

 

    对静态代码块以及构造函数的执行先后顺序，一直很迷惑，现用下面的这段小程序来简明扼要的叙述一下，以加深理解，与君共勉....
 

                               
 
                 public class Fu {
 
                                       static {
                                             System.out.print(1);
 
                                                   }
 
                                       public Fu() {
                                              System.out.print(2);
                                                  }
                                           }
 
                public class Zi extends Fu {
 
                                        static {
                                             System.out.print("a");
                                                  }
 
                                        public Zi() {
                                             System.out.print("b");
                                                    }
                                            }
 
            public class demo {
 
                           public static void main(String[] args) {
                                          Fu fu = new Zi();
                                          fu = new Zi();
                                                       }
                                              }
 
 

  1.
 
 
        当父类与子类都有静态代码块和构造函数的时候，执行顺序如下：
 
        父类静态代码块 > 子类静态代码块 java虚拟机加载类时，就会执行该块代码。
 
        父类构造函数 > 子类构造函数 （先有父亲，后有孩子）
 
        如果是多级继承关系的话，高层的父类首先执行，然后依次递减
 
     总结：静态优先执行，父类优先于子类执行
                 静态代码块是在JVM加载类的时候执行的，而且静态代码块执行且仅执行一次
 
 
 2.
 
        在调用类中的方法时，在方法体执行之前，首先要对类中的成员变量进行赋值，如果代码中没有赋具体的值，就会赋予变量默认值。成员变量的赋值顺序按照前后顺序进行。如果代码中既有直接赋值，也有构造方法赋值，那么根据先后顺序执行

Java在它开始运行之前并非被完全加载，其各个部分仅在必需时才加载。
 
 import java.awt.Color;

 

 

 import smallbird.Tools;

 

 

 public class Parent {

 


 
public static final String RG_CODE="025";

 


 
public static String CITY_NAME="南京";

 


 
public static Color COLOR_RED=new Color(255,0,0); 

 


 
public static final Object obj=new Child();

 


 
static {

 
System.out.println("static code block."+Tools.getNowDate());

 
}

 

 

 
public Parent() {

 
System.out.println("Parent's Constructor."+Tools.getNowDate());

 
}

 


 
public void speak() {

 
System.out.println("Parent's speak.");

 
}

 } 

 
 
1、建议将一些常量声明为final static编译期常量。
 

 
 
若仅声明为static，打印Parent.CITY_NAME时会先执行静态代码块，而打印Parent.RG_CODE却不会。
 
public static final Color COLOR_RED=new Color(255,0,0); 引用类似这些非常数静态域时会执行static代码块，
 
2、使用.class来获得对类的引用不会初始化
 

 
 
3、先初始化静态属性，再执行静态代码块
 
System.out.println("test: "+new Parent());
 
 
执行结果：
 
Parent's Constructor.2015-06-29 22:06:55,577
 Child's Constructor.
 static code block.2015-06-29 22:06:55,578
 Parent's Constructor.2015-06-29 22:06:55,578
 test: basic.Parent@ae94e92
 

public class A {

    static{
        System.out.print(1);
    }
    public A(){
        System.out.print(2);
    }
}

public class B extends A{

    static{
        System.out.print("a");
    }
    public B(){
        System.out.print("b");
    }
}

public class C {

    public static void main(String[] args){
        A a = new B();
        a = new B();
    }
}

父类与子类执行的先后顺序
静态变量的执行特性
方法重写（override）的注意事项
1.
当父类与子类都有静态代码块和构造函数的时候，执行顺序如下：
父类静态代码块 > 子类静态代码块
父类构造函数 > 子类构造函数（先有父亲，后有孩子）
如果是多级继承关系的话，最高层的父类首先执行，然后依次递减

总结：静态优先执行，父类优先执行
注意：静态代码块是在JVM加载类的时候执行的，而且静态代码块执行且仅执行一次

2.
在调用类中的方法时，在方法体执行之前，首先要对类中的成员变量进行赋值，如果代码中没有赋具体的值，也有默认值。成员变量的赋值顺序按照前后顺序进行。
如果有既有直接赋值，也有构造方法赋值，那么根据先后顺序执行

3.
重写（Override） 重载（Overload)
 重载是方法名字，返回类型一致，唯一不同的是方法的参数不同（参数类型不同，或者参数类型不同）

重写：
1. 发生方法重写的两个方法返回值，方法名，参数列表必须完全一致
2. 子类抛出的异常不能超过父类相应的方法抛出的异常
3. 子类方法的访问级别不能低于父类相应方法的访问级别（public，package，protected， private）

多态：父类的引用指向了子类的对象，调用时执行的方法也是子类的方法，父类的方法并不会被执行

所谓多态就是父类或者接口类型的引用可以指向子类或者实现该接口的类的实例（对象）

看了上面的说明，大家也应该知道上面的程序输出结果了。
输出结果为：1a2b2b