浅谈接口知识点

1、interface修饰接口

interface IStudy {
    
}
1
2
3

用interface修饰的都叫做接口

2、接口当中的成员变量

接口可以有成员变量，其中的成员变量默认public static final 修饰的。

interface IStudy { 
    int a = 10;
    public static final int b = 10;
}
1
2
3
4

所以在定义成员变量的时候要赋初始值。

3、接口的成员方法

接口也可以有成员方法，他们默认都是public abstract修饰的。

interface IStudy {
    int a = 10;
    public static final int b = 10;
    public void func();
    public abstract void func2();
    void func3();
}
1
2
3
4
5
6
7

4、接口的普通成员方法

接口中的普通成员方法是不能有具体的实现的。

原因很简单，因为普通成员方法都是默认public abstract修饰的，是抽象方法，所以不能有具体的实现。

5、接口的成员方法的实现

在接口中如果想要完成对成员方法的实现，必须用default修饰该成员方法。

interface IStudy {
    //发生编译错误，因为没有具体的实现
    default void func4();
   
}
1
2
3
4
5

6、接口的静态成员方法

接口可以有静态成员方法，但同default修饰的成员方法一样，必须要有方法体。

在默认情况下，静态成员方法是默认由public修饰的。

7、接口不能实例化

接口不能够实例化。

8、类和接口的关系

类要想使用接口，用到implements关键字，他们之间的关系称作实现。

interface IStudy {
    
}
class B implements IStudy {
    
}
1
2
3
4
5
6

9、接口的使用

接口是可以引用具体实现类的，此时发生的是向上转型。

interface IChargeLine {
    void ChargeWay();
}
class USB implements IChargeLine {
    @Override
    public void ChargeWay() {
        System.out.println("using USB to charge");
    }
}
class TypeC implements IChargeLine {
    @Override
    public void ChargeWay() {
        System.out.println("using TypeC to charge");
    }
}

public class test2 {
    public static void func(IChargeLine iChargeLine) {
        iChargeLine.ChargeWay();
    }
    public static void main(String[] args) {
        func(new TypeC());
        func(new USB());
    }

}
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

运行结果：

10、接口当中的静态、实例代码块和构造方法

在接口当中是不能有静态代码块、实例代码块和构造方法的。

会发生编译错误。

11、不想重写方法怎么办

在实现一个接口之后不想重写方法，可以用抽象类来实现，但是下一个类继承这个抽象类之后要重写所有的方法。

出来混总是要还的。

interface IChargeLine {
    void ChargeWay();
}
abstract class b implements IChargeLine {
    abstract public void func2();
}
class c extends b {
    @Override
    public void ChargeWay() {
        
    }

    @Override
    public void func2() {
        
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17