首页 > 代码库 > Java 接口与类

Java 接口与类

2024-10-29 16:44:39   209人阅读

最近组里的任务还不是很忙，在看mybatis的内容，发现项目里很多接口，就把今后要改造的部分代码看了一下。在读前辈的代码的时候，发现一个特点：接口的多继承很多。于是就到网上找了些继承和接口的用法，重温一下，也总结一下下。

继承

1.Java中的类不支持多继承，即一个子类至多有一个父类。

2.子类继承了父类中的不是私有的成员变量和成员方法。

3.当子类中的成员变量和成员方法和父类中的一致时，那么父类的方法被覆盖了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public class Test {
     
    publicstatic String a = "a";
    privateString b = "b";
     
    {
        System.out.println("no static");
        System.out.println("b:"+ b);
    }
     
    static{
        System.out.println("static");
        System.out.println("a:"+a);
    }
     
    publicTest(){
        this("un");
        System.out.println("Test():"+this.b);
    }
     
    publicTest(String val){
        this.b = val;
        System.out.println("Test(val):"+this.b);
    }
     
    publicstatic void main(String[] args) {
        newTest();
    }
}

 

输出如下：

1
2
3
4
5
6
static
a:a
no static
b:b
Test(val):un
Test():un

 

做一下解释：

1.在实例化对象时，先对静态变量分配内存空间并初始化，然后执行静态块。

2.初始化所有的非静态变量为默认值，然后再显示初始化，即执行 b = “b”。

3.初始化完非静态变量执行非静态方法块。

4.执行构造函数，在默认构造函数中调用了带参数的构造函数。

 

抽线类、子类的成员变量和成员方法和父类的关系

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public abstract class Parent {
    //父类是一个抽象类，可以有自己的成员变量和成员函数，成员变量和成员函数可以是abstract的，也可以是非abstract的。但是父类不能被实例化
    static{
        System.out.println("Parent");
    }
     
    inti;
     
    Parent(inti){
        this.i = i;
        System.out.println("Parant:"+i);
    }
     
    abstractpublic void f1();
    abstractpublic void f2();
    publicvoid f3(){
        System.out.println("Parennt f3():"+ i);
    }
 
}

子类1：实现了父类的所有方法，包括抽象和非抽象的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public class Child1 extendsParent {
 
    //子类继承抽象的父类，必须实现其所有抽象方法及构造函数。
    Child1(inti) {
        super(i);
        i++;
        System.out.println("Child1:"+ i);
    }
 
    @Override
    publicvoid f1() {
        System.out.println("Child1:f1():"+i);
 
    }
 
    @Override
    publicvoid f2() {
        // TODO Auto-generated method stub
 
    }
     
    publicvoid f3(){
        this.i =5;
        System.out.println("Child f3():"+ i);
        System.out.println("Child f3() spuer "+ super.i);
        super.f3();
    }
 
}

子类2：实现了父类的抽象方法。子类在继承抽象类时，必须实现抽象类中的所有抽象方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class Child2 extendsParent {
 
    Child2(inti) {
        super(i);//必须在第一行
        this.i =8;
        System.out.println("C2 "+ this.i);
    }
 
    @Override
    publicvoid f1() {
        // TODO Auto-generated method stub
 
    }
 
    @Override
    publicvoid f2() {
        // TODO Auto-generated method stub
        System.out.println("Child2 f2():"+ i);
    }
 
}

写个main函数，执行一下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public static void main(String[] args) {
    System.out.println("main start");
    Child1 c1 =new Child1(0);
    Child2 c2 =new Child2(0);
     
    System.out.println("new");
     
    c1.f1();
    c1.f2();
    c1.f3();
     
    System.out.println("Child1 over");
     
    c2.f1();
    c2.f2();
    c2.f3();
     
}

 

我们知道子类继承父类，对于子类来说拥有父类的非私有化的成员变量及成员方法的访问权限。如果从占用空间的量上作比方，父类和子类都有两个同样类型，但是名称不一样的变量，如果父类占用内存空间是1M，那么子类占用的内存空间2M，这是假设的情况，因为子类中有一个隐藏的引用super会指向父类实例，在实例化子类之前会先实例化一个父类，也就是先执行父类的构造函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
Parent
main start
Parant:0
Child1:1
Parant:0
Child2 8
new
Child1:f1():0
Child f3():5
Child f3() spuer 5
Parennt f3():5
Child1 over
Child2 f2():8
Parennt f3():8

 

子类Child2没有实现父类的f3方法，调用父类的实现，但是只使用父类的方法，数据成员还是自己的。

Super关键字

super关键字在Java中的作用是使被屏蔽的成员变量或者成员方法变为可见。或者说用来引用被屏蔽的成员变量和成员方法。

 

接口

Java语言不支持一个类有多个直接的父类，但是可以实现多个接口，间接地实现了多继承。java接口中的方法都是public,abstract类型的，没有方法体，不能实例化。接口就是一个纯抽象类，只有抽象方法，绝对没有实现。实现接口即是在给自己的类添加一个或者多个方法。使用接口是为了在设计模式上的规范。

 

接口有利于代码功能的扩展，即增加功能。继承则是有利于代码功能的修改（修改完善功能）。这里旧功能的修改和新功能的增加，都是不修改父类的功能，父类的功能仍然可用。

Java 接口与类


联系
我们