java继承与接口_继承至抽象类c1,c1抽象类中有两个抽象方法f1与f2,s1类-CSDN博客

java继承与接口

前两天写东西，本来想把定义和实现分开来写的。类A有两个方法f1和f2，想把类A的定义、f1的实现和f2的实现分为三个java文件来写，看了看抽象类和接口。不过貌似都不是搞这个的样子。（求方法）

总结一下，自己看的继承和接口。

继承

Java中很基本的概念。如书所言：

（1）java不支持多重继承，也就是说子类至多只能有一个父类

（2）子类继承了其父类中不是私有的成员变量和成员方法，作为自己的成员变量和方法

（3）子类中定义的成员变量和父类中定义的成员变量相同时，则父类中的成员变量不能被继承

（4）子类中定义的成员方法，并且这个成员方法的名字，返回类型，及参数个数和类型与父类的某个成员方法完全相同，则父类的成员方法不能被继承。

其实看这个，远远不够啊。还是看代码，能跑出什么来才是真啊。

先看看java对象如何初始化过程吧。

代码如下：

 1 public class test_java {
 2     
 3     public static String a = "a";
 4     private String b = "b";
 5     {
 6         System.out.println("no static");
 7         System.out.println("b:"+b);
 8     }
 9     static{
10         System.out.println("static");
11         System.out.println("a:"+a);
12     }
13     public test_java() {
14         // TODO Auto-generated constructor stub
15         this("Un");
16         System.out.println("test_java() "+this.b);
17     }
18     public test_java(String c){
19         this.b = c;
20         System.out.println("test_java(string)" +this.b);
21     }
22     public static void main(String[]args ){
23         new test_java();
24     
25     }
26 }

输出如下：

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()。

可以看出：如果在类内有静态变量和静态块，就先静态后非静态，最后才是构造函数；

接下分析一下

抽象类、子类的变量和函数与父类的关系

父类：

 1 //父类，抽象类
 2 abstract public class A { 
 3     static{
 4         System.out.println("A");
 5     }
 6     int i;
 7     A(int i){
 8         this.i = i;
 9         System.out.println("A "+i);
10     }
11     abstract public void f1();
12     abstract public void f2();
13     public void f3(){
14         System.out.println("A f3 "+i);
15     }
16 }

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

子类1：

 1 //子类，
 2 public class C1 extends A{
 3 
 4     C1(int i) {
 5         super(i);
 6         i++;
 7         System.out.println("C1 "+i);
 8     }
 9     @Override
10     public void f1() {
11         System.out.println("C1 f1 "+i);
12     }
13     @Override
14     public void f2() {    
15     }    
16     public void f3(){
17         i = 5;
18         System.out.println("C1 f3 "+i); 
19         System.out.println("C1 f3 super "+super.i);
20         super.f3();
21     }
22 }

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

 1 // 子类
 2 public class C2 extends A{
 3 
 4     C2(int i) {
 5         super(i); // 必须在第一行，且
 6         this.i=8;
 7         System.out.println("C2 "+this.i);        
 8     }
 9 
10     @Override
11     public void f1() {
12         // TODO Auto-generated method stub
13     }
14 
15     @Override
16     public void f2() {
17         // TODO Auto-generated method stub
18         System.out.println("C2 f2 "+i);
19     }
20 }