初始化块 ，上溯，多态

//初始化块的执行顺序是按定义的顺序执行,最后才轮到构造器
//对于非静态初始化块，每次新建一个对象都会执行一次，而对于静态初始化块，只在第一次新建对象时执行
//所以非静态初始化块相当于构造函数的方法体
class A{
	
	{System.out.println("一个非静态初始化块");}
	static {System.out.println("一个静态初始化块");}
	A(){};
}
public class Notknow{
	public static void main(String args[])
	{
		A a=new A();
		A b=new A();
	}
}

//子类方法对父类方法的覆盖
class A extends B{
	 int i=5;
	 static int j=4;
	 A(){
		 System.out.println("i ="+i);
		 System.out.println("j ="+j);
	 }
	 void m()
	 {
		 System.out.println("i="+i);
		 System.out.println("j="+j);
	 }
}
class B {
	B(){
		m();
	}
	void m(){}
}
public class nnn{
	public static void main(String args[]){
	A a =new A();
	//B b=new B();
	}
	
}

结果

i=0

j=4
i =5

j =4

在Java中，除了static方法和final方法，其他所有的方法都是动态绑定。

A a=new B();a作为A的引用仍然只能引用A类的成员变量和成员方法。但是若引用的成员方法在B类重写了的话就会引用被重写的版本，因为加载B类的时候先加载A类的方法，再加载B类的方法如果已经有该方法（A类的同名方法）则把该方法指向新的方法（B类的方法）  (这里指的同名方法不包括重载的同名方法）

//关于JAVA的上溯（A a= new B()）.B子类上溯到A父类时a的表现———即用父类的成员变量值，用子类的方法。

class A{
	int i=1;
	static int j=11;
	static String m1(){
		return "A's class method";
	}
	String m2(){
		return "A's instance method";
	}
	String m3(){
		return "A's instance method";
	}
}
class B extends A{
	int i=2;
	static int j=12;
	static String m1(){
		return "B's class method";
	}
	String m2(){
		return "B's instance method";
	}
}
public class Notknow{
	public static void main(String agrs[]){
		A x= new B();
		System.out.println("(1) x.i="+x.i);
		//用父类的成员变量
		System.out.println("(2) (B)x.i="+((B)x).i);
		//下溯后当然用子类的成员变量
		System.out.println("(3) x.j="+x.j);
		//静态变量与上面普通成员变量表现相同
		System.out.println("(4)(B)x.j="+((B)x).j);
		//静态变量与上面普通成员变量表现相同
		System.out.println("(5) x.m1()="+x.m1());
		//本来应该用子类的方法，但该方法是静态方法，仍然调用父类的静态方法。
		System.out.println("(6) ((B)x).m1()="+((B)x).m1());
		System.out.println("(7) x.m2()="+x.m2());
		//非静态方法，调用子类的
		System.out.println("(8) x.m3()="+x.m3());
	}
}

<span style="font-size:18px;">似乎如果子类覆盖了父类的方法，在子类的对象中再也不能调用该被覆盖的父类方法，但我们可以通过在子类中调用super.m1()如此来在某些情况仍然可以调用</span><span style="font-size:18px; font-family: Arial, Helvetica, sans-serif;">被覆盖（重写）的父类方法</span>

</pre><pre name="code" class="java">

</pre><pre name="code" class="java">//向上转型，在运行时，会遗忘子类对象中与父类对象中不同的方法。也会覆盖与父类中相同的方法--重写。（方法名，参数都相同）
//所以a2,可以调用的方法就是，A中有的，但是B中没有的方法，和B中的重写A的方法。
class A {  
    public String show(D obj){  
           return ("A and D");  
    }   
    public String show(A obj){  
           return ("A and A");  
    }   
}   
class B extends A{  
    public String show(B obj){  
           return ("B and B");  
    }  
    public String show(A obj){  
           return ("B and A");  
    } 
}  
class C extends B{}   
class D extends B{}
public class Nntknow {

	public static void main(String[] args) throws CloneNotSupportedException {
		A a1 = new A();  
        A a2 = new B();  
        B b = new B();  
        C c = new C();   
        D d = new D();   
        System.out.println(a1.show(b));    
        System.out.println(a1.show(c));   
        System.out.println(a1.show(d));     
        System.out.println(a2.show(b));     
        System.out.println(a2.show(c));     
        System.out.println(a2.show(d));     
        System.out.println(b.show(b));      
        System.out.println(b.show(c));      
        System.out.println(b.show(d));    
		
	}

}

A and A
A and A
A and D
B and A
B and A
A and D
B and B
B and B
A and D

</pre><pre>