父类与子类中调用顺序的剖析

任何一个类，在执行一个方法前必须要先安代码的顺序初始化所有的静态块，然后调用main函数，

在生成一个类对象的时候，父类对象必须先生成，没有父类哪有什么子类。

对于属性的调用来说，哪个类调用的就是哪个的属性。

对于方法来说

非静态方法，并且父类中有，子类中也有，对象是有子类生成的，那么这个时候，调用子类中的方法。

如果是静态方法，跟当前的类有关，哪个类就调用那个类的方法，不看是否覆盖.

class ParentClass {
	public static String s = "parent static field s";
	public String d = "parent field d";
	static {
		System.out.println(s);
	}
	public ParentClass() {
		System.out.println("ParentClass");
	}
	public void d() {
		System.out.println("parent method d");
	}
	public static void s() {
		System.out.println("parent static method s");
	}
}
class SonClass extends ParentClass {
	public static String s = "son static field s";
	public String d = "son field d";
	static {
		System.out.println(s);
	}
	public SonClass() {
		System.out.println("sonClass");
	}
	public void d() {
		System.out.println("son method d");
	}
	public static void s() {
		System.out.println("son static method s");
	}
}
public class DemoDynMethod {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		// 在调用main函数前要先初始化所有的静态块,所以=="我比main优先(程序的最后面)"先打印出来 然后是下面这句话
		System.out.println("我是main函数打印出来的My Test Demo!!!");
		// 在生成一个子类对象之前要先生成父类对象
		// 如果父类对象又有静态块（静态块包括静态属性）
		// 那么在调用任何方法前都要先初始化静态块。
		// 所以先打印父类静态块的内容 ================》parent static field s
		// 这个时候不是说要调用父类的构造函数，而是要看，子类里面是不是也有静态块，
		// 子类中有静态块，那么由于静态块的初始化要高于任何方法，所以要继续初始化子类的静态块
		// 此时打印的是=============》son static field s子类的静态块
		// 再往下就是调用父类的构造函数，调用子类的构造函数
		// 因此下面一句话有四句输出分别为：
		// parent static field s
		// son static field s
		// ParentClass
		// sonClass
		SonClass son = new SonClass();
		System.out.println("=============================");
		//对于属性来说，只跟当前的类有关，所以下面两个输出的全是子类的内容
		System.out.println("Son.s====》"+son.s);
		System.out.println("Son.d====》"+son.d);

		System.out.println("=============================");
		// 把子对象向上转型
		ParentClass parentSon = son;
		// 调用方法d，这是一个非静态的方法，而且子类覆盖了父类的方法，所以打印的是子类的方法==》son method d
		parentSon.d();
		System.out.println("********************************");
		// 调用静态方法s，这是个静态的方法，虽然父类覆盖了子类的方法，但是静态的只是跟随当前的类。
		// 所以打印的为父类的方法
		parentSon.s();
		System.out.println("￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥");

		//对于属性来说，只跟当前的类有关，所以下面两个输出的全是父类的内容
		System.out.println("parentSon.s====》"+parentSon.s);
		System.out.println("parentSon.d====》"+parentSon.d);
	}
	static {
		System.out.println("我比main优先");
	}
}

 再用一个例子加深大家的理解，大家可以复制到eclipse中运行试试看，继承是面向对象中非常重要的一个特征，希望可以帮到你们。

public class Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		A1 a=new B1();
		B1 b=new B1();
		a.h();
		b.t();
	}
}
class A1{
	int k=6;
	static int j=7;
	public void t(){
		System.out.println("A1中的k="+k);
	}
	public static void h(){
		System.out.println("A1中的j="+j);
	}
	public A1(){
		System.out.println("这是A1中public！");
		t();
		System.out.println("这是A1中的构造方法中");
		h();	
		System.out.println("这是A1中构造方法后！");
	}
}
class B1 extends A1{
	int k=8;
	static int j=9;
	static{
		System.out.println("-----静态方法static开始-----");
		new A1().t();
		System.out.println("-----静态方法static结束-----");
	}
	public B1(){
		System.out.println("这是B1中public！");
		t();
		h();
		System.out.println("这是B1中构造方法！");
	}
	public void t(){
		System.out.println("B1中的k="+k);
	}
	public static void h(){
		System.out.println("B1中的j="+j);
	}	

}