今天看毕老师视频的时候，
看到老师用写到：
List list =new ArrayList();

突然想问，为什么要用父类接口引用来指向子类接口呢、。

联想到父类引用指向子类对象，于是我写了代码具体对比了，父类引用和子类自建对象的具体区别
得出结论是：
//【结论。父类引用指向之类的时候，只能使用父类中的方法，和子类覆盖掉父类中的方法，静态的方法不可被调用】
  【子类创建子类对象，不仅能覆盖父类方法，还可以有独立方法。扩张性更强。】
应用到接口上，应该是子接口功能更强大才对啊。
但是老师这么写必然有原因，不知道是我没注意听，还是怎么回事，反正现在很困惑，求指导！~

下面的代码是父类引用和子类自建对象的具体区别

1. public class Test98 {
   
2.         public static void main(String [] args){
   
3.                
   
4.                 AA ab =new BB();//先调用AA的构造方法，然后调用BB的构造方法
   
5.                 System.out.println(ab.b);//变量是不可以被继承覆盖的，所以这里是AA的值，而不是BB的值
   
6.                 System.out.println(ab.a);
   
7.                 ab.show1();//父类创建子类对象，子类该方法覆盖了父类的该方法。
   
8.                 ab.show2();//父类独有方法。
   
9.                 ab.show3();
   
10.                 ab.show4();//父类静态方法
    
11.                 //ab.show5();//报错
    
12.                 //ab.show6();//报错     //父类引用 不能调用子类的 特有方法，和静态方法。
    
13.                 System.out.println("--------------------------------------------");
    
14.                 BB bb = new BB();//首先还是执行AA，BB的构造方法
    
15.                 System.out.println(bb.a);
    
16.                 System.out.println(bb.b);//子类的同名与父类的成员变量并未覆盖到父类。
    
17.                 System.out.println(bb.c);
    
18.                 System.out.println(bb.d);
    
19.                 bb.show1();//子类覆盖父类的方法
    
20.                 bb.show2();//子类没有，父类独有方法
    
21.                 bb.show3();//子类静态方法覆盖父类静态方法
    
22.                 bb.show4();//子类没有，父类独有方法
    
23.                 bb.show5();
    
24.                 bb.show6();//5，6 都是子类特有的方法或静态方法。
    
25.                
    
26.                 //【结论。父类引用指向之类的时候，只能使用父类中的方法，和子类覆盖掉父类中的方法，静态的方法不可被调用】
    
27.                 //【子类创建子类对象，不仅能覆盖父类方法，还可以有独立方法。扩张性更强。】
    
28.                
    
29.                 //类名调用不在该问题讨论范围，可以忽略
    
30. 
    
31.         }
    
32. }
    
33. class  AA{
    
34.         public static int a=0;
    
35.         public int b=1;
    
36.         
    
37.         AA(){
    
38.                 System.out.println("A的构造方法");
    
39.         }
    
40.         public void show1(){
    
41.                 System.out.println("A的show1111方法");
    
42.         }
    
43.         public void show2(){
    
44.                 System.out.println("AAshow22222方法【父类特有方法】");
    
45.         }
    
46.         public static void show3(){
    
47.                 System.out.println("AA的static静态show33333方法");
    
48.         }
    
49.         public static void show4(){
    
50.                 System.out.println("AA的static静态show44444方法【父类特有静态方法】");
    
51.         }
    
52. }
    
53. class BB extends AA{
    
54.         public static int c=99;
    
55.         public int d=1001;
    
56.         public static int a=110;//和父类同样静态 同名变量
    
57.         public int b=120;//和父类同名变量
    
58.         
    
59.         BB(){
    
60.                 System.out.println("BB的构造方法");
    
61.         }
    
62.         public void show1(){//覆盖--和父类重复
    
63.                 System.out.println("BB的show11111方法");
    
64.         }
    
65.         public void show5(){
    
66.                 System.out.println("BB的show5555方法【子类特有】");
    
67.         }
    
68.         public static void show3(){//覆盖--和父类重复
    
69.                 System.out.println("BB的静态show333333方法");
    
70.         }
    
71.         public static void show6(){
    
72.                 System.out.println("BB的静态show66666方法【子类特有】");
    
73.         }
    
74. }
    

复制代码

//这个是一种面向接口编程的思想。
/**
就拿List和 ArrayList来说：
定义一个方法：
A,public void show（ArrayList list){}

B,public void show(List list){}

方法A只可以接受ArrayList类型对象。
方法B可以接受List类型或实现了List接口的子类对象。
当然，方法只对共享数据的操作。
*/

skill20 发表于 2014-5-19 15:15
//这个是一种面向接口编程的思想。
/**
就拿List和 ArrayList来说：

我百度了一下，
主要也是这个意思，
如果用ArrayList来实现的话，比如以后换成LinkedList 的话会非常麻烦，
而用List的话，只需要简单的修改即可完成功能的蜕变。