Java基础：方法重写和多态

示例代码：

子类的方法与父类的方法具有相同的返回类型和签名，子类方法重写父类方法。

1. class A{
2.     int i,j;                    //父类变量
3.     A(int a,int b){       //父类构造
4.         i=a;
5.         j=b;
6.     }
7.     void show(){         //父类方法
8.         System.out.println(i+"   "+j);
9.     }
10. }
11. class B extends A{     //继承父类
12.     int k;                         //子类变量
13.     B(int a,int b,int c){   //子类构造
14.         super(a,b);          //调用父类构造
15.         k=c;
16.     }
17.     void show(){         //子类方法重写父类方法，会隐藏父类方法
18.         System.out.println(i+"   "+j);
19.     }
20.     void show(String msg){      //子类方法，重载父类方法（方法签名不同，称为重载）
21.         //super.show();                 //显示调用父类方法
22.         System.out.println(msg+k);
23.     }
24. }
25. class Override{
26.     public static void main(String[] args){
27.         B b=new B(1,2,3);
28.         b.show("This is k: ");
29.         b.show();       
30.     }
31. }

---------------------------------------------------------------------------------------------------

多态：父类对象可以引用子类对象，引用不同对象造成不同结果，称为多态。

1. class Sup{                   //父类
2.     void who(){
3.         System.out.println("Sup");
4.     }
5. }
6. class Sub1 extends Sup{          //子类
7.     void who(){
8.         System.out.println("Sub1");
9.     }
10. }
11. class Sub2 extends Sup{       //子类
12.     void who(){
13.         System.out.println("Sub2");
14.     }
15. }
16. class DynDispDemo{
17.     public static void main(String[] args){
18.         Sup sup=new Sup();           //父类对象
19.         Sub1 sub1=new Sub1();    //子类对象
20.         Sub2 sub2=new Sub2();    //子类对象
21.         
22.         Sup supf;       //父类对象
23.         
24.         supf=sup;     //父类对象引用父类对象
25.         supf.who();  //调用父类方法
26.         
27.         supf=sub1;  //父类对象引用子类对象
28.         supf.who();  //调用子类方法
29.         
30.         supf=sub2; //父类对象引用子类对象
31.         supf.who();  //调用子类方法
32.     }
33. }