java继承与接口

java中接口与继承的关系
（1）java不支持多重继承，也就是说子类至多只能有一个父类
（2）子类继承了其父类中不是私有的成员变量和成员方法，作为自己的成员变量和方法
（3）子类中定义的成员变量和父类中定义的成员变量相同时，则父类中的成员变量不能被继承
（4）子类中定义的成员方法，并且这个成员方法的名字，返回类型，及参数个数和类型与父类的某个成员方法完全相同，则父类的成员方法不能被继承。
代码如下：

  public class test_java {
     
      public static String a = "a";
      private String b = "b";
      {
          System.out.println("no static");
          System.out.println("b:"+b);
      }
      static{
         System.out.println("static");
         System.out.println("a:"+a);
     }
     public test_java() {
         // TODO Auto-generated constructor stub
         this("Un");
         System.out.println("test_java() "+this.b);
     }
     public test_java(String c){
         this.b = c;
         System.out.println("test_java(string)" +this.b);
     }
     public static void main(String[]args ){
         new test_java();
    
     }
}

输出如下：
static
a:a
no static
b:b
test_java(string)Un
test_java() Un
分析一下：
         1 在实例化对象时， 先对给静态变量分配内存空间并初始化，然后执行静态块。
因此，在这里会输出：
static
a:a
a:a的输出也说明是先初始化静态变量然后再执行静态块，否则a将为null。同时，如果将“"a:"+a”修改为“"a:"+b”，eclipse自动报错也说明静态变量－>静态快，再其它。
2然后在内存中为Employee分配内存空间，并做默认初始化（即所有变量初始化为默认值，这里都初始化为null）。
3 默认初始化完成后，开始显示初始化。即执行“private String b = "b";
”，将b初始化"b"，并且执行非静态方法块；因此在这里会有以下输出：
no static
b:b
4 最后才调用默认构造函数，在默认构造函数中调用了带参数的构造函数，所以在这里先输出带参数构造test_java(string)，此时b已经被修改为“Un”，再输出test_java()。
         可以看出： 如果在类内有静态变量和静态块，就先静态后非静态，最后才是构造函数；
接下分析一下
抽象类、子类的变量和函数与父类的关系

父类：

  //父类，抽象类
  abstract public class A {
      static{
          System.out.println("A");
      }
      int i;
      A(int i){
          this.i = i;
          System.out.println("A "+i);
     }
     abstract public void f1();
     abstract public void f2();
     public void f3(){
         System.out.println("A f3 "+i);
     }
}

父类是个抽象类，可以有自己的数据成员，也可以有非abstarct的成员方法。但是不能被实例化。
子类1：

  //子类，
public class C1 extends A{
 
       C1(int i) {
          super(i);
          i++;
          System.out.println("C1 "+i);
      }
      @Override
      public void f1() {
         System.out.println("C1 f1 "+i);
     }
     @Override
     public void f2() {   
     }   
     public void f3(){
         i = 5;
         System.out.println("C1 f3 "+i);
         System.out.println("C1 f3 super "+super.i);
         super.f3();
     }
}


         该子类C1实现了父类所有的方法，抽象和非抽象的。

  // 子类
  public class C2 extends A{
 
      C2(int i) {
          super(i); // 必须在第一行，且
          this.i=8;
          System.out.println("C2 "+this.i);       
      }
 
     @Override
     public void f1() {
         // TODO Auto-generated method stub
     }

     @Override
     public void f2() {
         // TODO Auto-generated method stub
         System.out.println("C2 f2 "+i);
     }
}

子类C2实现了父类的抽象方法。子类在继承抽象类时，必须实现抽象类中的所有抽象方法。
来看看下面一段代码会有什么样的输出。
    public static void main(String[]args ){
       System.out.println("main start");
       C1 c1 = new C1(0);
       C2 c2 = new C2(0);
       System.out.println("new");
       c1.f1();
       c1.f2();
       c1.f3();
       System.out.println("c1 over");
       c2.f1();
       c2.f2();
       c2.f3();    
    }
先自己看看，再来对照结果:
main start
A
A 0
C1 1
A 0
C2 8
new
C1 f1 0
C1 f3 5
C1 f3 super 5
A f3 5
c1 over
C2 f2 8
A f3 8
         还是有点多。我们来仔细分析一下。
         从整体上来说，我们知道从对象的内存角度来说，假设现在有一个父类Father,它里面的变量需要占用1M内存.有一个它的子类Son,它里面的变量需要占用0.5M内存.
现在通过代码来看看内存的分配情况:
Father f = new Father();//系统将分配1M内存.
Son s = new Son();//系统将分配1.5M内存!因为子类中有一个隐藏的引用super会指向父类实例,所以在实例化子类之前会先实例化一个父类,也就是说会先执行父类的构造函数.由于s中包含了父类的实例,所以s可以调用父类的方法.
         有了整体认识，来一个一个看输出。
         1、C1 c1 = new C1(0);对应输出了A ；A 0；C1 1；先输出A，这点同时验证了子类先初始化父类，再执行父类构造函数A 0；再子类的构造函数C1 1.
         2、C2 c2 = new C2(0);对应输出了A 0；C2 8；看出父类初始化只有一次，当构造函数必须在执行一次。
         3、子类c1实现了自己的f1、f2、f3，使用时就是使用的自己的实现；子类c2没有实现f3，调用父类的实现。但是只使用父类的方法，数据成员还是自己的，所有输出“A f3 8”。
         由此，可推断，这三个类内存结构如图：
父类A        子类C1      子类C2
i
I
I
F1
F2
F3
F1
F2
F3
F1
F2
F3

F1
F2
F3
F1
F2
         现在在回去看看开头出的四点，确实是那样，并且后面对凌乱的代码验证有更好的认识。下面讲讲继承中的一些其它内容。
super关键字

super关键字在java中的作用是使被屏蔽的成员变量或者成员方法或变为可见，或者说用来引用被屏蔽的成员变量和成员成员方法。super是用在子类中，目的是访问直接父类中被屏蔽的成员。
父类引用指向子类对象

         Father f = new Father();//系统将分配1M内存.
Son s = new Son();//系统将分配1.5M内存!因为子类中有一个隐藏的引用super会指向父类实例,所以在实例化子类之前会先实例化一个父类,也就是说会先执行父类的构造函数.由于s中包含了父类的实例,所以s可以调用父类的方法.
Son s1 = s;//s1指向那1.5M的内存.
Father f1 = (Father)s;//这时f1会指向那1.5M内存中的1M内存,即是说,f1只是指向了s中实例的父类实例对象,所以f1只能调用父类的方法(存储在1M内存中),而不能调用子类的方法(存储在0.5M内存中).
Son s2 = (Son)f;//这句代码运行时会报ClassCastException.因为f中只有1M内存,而子类的引用都必须要有1.5M的内存,所以无法转换.
Son s3 = (Son)f1;//这句可以通过运行,这时s3指向那1.5M的内存.由于f1是由s转换过来的,所以它是有1.5M的内存的,只是它指向的只有1M内存.