覆盖与隐藏的区别.txt

关于java考试的很多内容 希望对大家有所帮助 谢谢

覆盖与隐藏的区别
下面这个例子很好地说明了它们的区别：
class Father
{
        public static void getStr()
        {
                System.out.println("abc");
        }
        public void getString()
        {
                System.out.println("123");
        }
}

class Son extends Father
{
        public static void getStr()
        {
                System.out.println("def");
        }
        public void getString()
        {
                System.out.println("456");
        }
        public static void main(String[] args)
        {
                Father f=new Son();  //父类的引用指向子类的对象
                f.getStr();         //此时依然调用父类的getStr()方法，打印出abc
                f.getString();       //此时调用子类的getString()方法，打印出456
        }
} 



class food {
String name="food";
public void showMess(String mess){
System.out.println("food.showMess="+mess);
}
}

class bread extends food{
String name="bread";
public void showMess(String mess){
System.out.println("bread.showMess="+mess);
}
public static void main(String[] args) 
{
bread b=new bread(); 
food f=b;
f.showMess("f");  
//f.showMess()调用的是b的showMess方法
System.out.println("f.name"+f.name); 
//那为什么这里f.name为"food",不是b的name子段?
}
} 
创建一个父类的引用，指向子类的实例对象。该对象有两个name ,即super.name和this.name。因为是父类的引用，所以调用的是super.name，而在运行的时候，子类方法覆盖了父类的方法，据动态绑定，引用所指向的是一个实例化对象的那个方法，在这，也就是复写的那个方法。



该程序展示了在继承关系中，方法的传递分配关系

class A {    
A() {        
System.out.println("A的构造被调用");    
}    
void f() {System.out.println("A.f()");   
 }
}
class B extends A {    
B() { System.out.println("B的构造被调用");    
}    
void f() { 
//重写了A类的f方法        
System.out.println("B.f()");    
}
}
class C extends A {    
C() {        System.out.println("C的构造被调用"); 
   }    
void fc() {        System.out.println("C.fc()");  
  }
}
public class LearnInheritMethod {   
 public static void main(String args[]) {        System.out.println("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");    
    B bb = new B();      
  A ab;       
 ab = (A) bb;//以上三行相当于A ab = new B();  
               ab.f(); //A型的ab调用的竟是B类重载过的f      
  //（原因：与域不同，调用两次构造，并不能产生两个f方法，而是第二次的覆盖了第一次的，这时两个类型共同拥有第二次产生的f）  
      ((B) ab).f(); //B型的ab调用的竟…竟也是B类重载过的f     
   //竟然可以由父转子（原因：因为ab是由bb转来的，只要bb还没被释放，ab就还可以转回去）       
 System.out.println("cccccccccccccccccccccccccccccc");     
   A ac = new C();        ac.f(); //ac.fc()非法       
 //原因：虽然类型对方法不能起选择作用（因为就一套，两个类型共用），但是类型对方法还是由屏蔽作用（即只能访问该类中声明过的方法）      
  ((C) ac).f();     
   ((C) ac).fc();   
 }
}


该程序展示了在继承关系中，域的传递分配关系

class A{    int x1,x2;    A(){        x1=1;        x2=2;        System.out.println("A的构造被调用");    }}class B extends A{    char x2;  //x2甚至可以是int型的    int x3;    B(){        x2='#';  //此x2与A中的x2各占各的内存        x3=33;         System.out.println("B的构造被调用");    }}public class LearnInheritField {    public static void main(String[] args) {        B b =new B();  //创建b时，调用了构造A()和构造B()，且分配了4份内存（但没人可以同时拥有它们），分别存放a＝1，b＝2，b＝‘＃’，c＝33       //A型实例拥有的域：A.x1＝1，A.x2＝2      //B型实例拥有的域：A.x1＝1(继承)，B.x2＝‘＃’(重载)，B.x3＝33(自定义)               System.out.println(((A)b).x2);  //类型转化时，并不再调用构造，而b的值却可以随类型改变，说明了有两份b，且用类型加以却别               System.out.println(b.x2);  //两个x2是互斥的，即一个类型只能访问到其相应的x2       }}