//初始化块的执行顺序是按定义的顺序执行,最后才轮到构造器
//对于非静态初始化块,每次新建一个对象都会执行一次,而对于静态初始化块,只在第一次新建对象时执行
//所以非静态初始化块相当于构造函数的方法体
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=4i =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>