接口-Java

命名规则

  • 接口是一种公共的规范标准，是一种引用数据类型。

  • 定义规则

    public interface 接口名称 { }

  • 接口内容可以包括：常量、抽象方法、默认方法、静态方法、私有方法等

  • 接口中的抽象方法，修饰符必须是public abstract，也可选择性的忽略

  • 接口没有静态代码块和构造方法

使用规则

  • 接口不能直接使用，必须有一个实现类来实现该接口。

  • 实现类必须覆盖重写接口的所有的抽象方法，如果没有全部实现，那么这个实现类必须是抽象类

    public class 实现类名称 implements 父类

1
2
3
4
5
6
7
8
9
10
11
12
13
public interface MyinterfaceAbs {
    public abstract void method();
}
public class Demo3Interface implements MyinterfaceAbs{
    @Override
    public void method() {
   		//。。。。。
    }
}
public static void main(String[] args) {
        Demo3Interface demo3Interface = new Demo3Interface();
        demo3Interface.method();
    }

默认方法

  • 当接口中新添加一个抽象方法时，会影响其他实现类。接口当中的默认方法可以解决接口升级的问题，默认方法会被实现类继承，也可被覆盖重写

    public default 返回值类型 方法名称（参数名称）{ 方法体 }

1
2
3
public default void methoddefault(){
        System.out.println("这是一个默认方法");
    }

静态方法

  • 不能通过接口实现类的对象来调用接口当中的静态方法，而是通过接口名称直接调用：接口名称.静态方法
  • public static 返回值类型 方法名称（参数名称）{ 方法体 }

私有方法

  • 当需要抽取一个公有方法，用来解决两个默认方法之间的重复代码的问题。但是这个代码不应该让实现类使用，应该是私有化的

  • 普通私有方法：解决多个默认方法之间重复代码问题

    private 返回值类型 方法名称（参数名称）{ 方法体 }

  • 静态私有方法：解决多个静态方法之间重复代码问题

    private static 返回值类型 方法名称（参数名称）{ 方法体 }

常量

  • 接口当中也可以定义“成员变量”，必须使用public static final来修饰，其实就是接口中的常量，一旦赋值不可修改。
  • 常量名称大写

继承父类实现多个接口

  • 一个类的直接父类是唯一的，但是一个类可以同时实现过个接口

    public interface 接口名称1，接口名称2…. { }

  • 若多个接口中同时定义了相同的抽象方法，那么实现类中覆盖重写一次即可

  • 若多个接口中同时定义了相同的默认方法，那么实现类中必须覆盖重写一次

  • 一个类，如果直接父类当中的方法和所实现接口当中的默认方法产生了冲突，优先使用父类当中的方法

接口和接口之间多继承

  • 多个父接口的抽象方法重复不影响
  • 多个接口的默认方法重复，那么子接口必须进行默认方法的覆盖重写，必须带default
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
public interface MyinterfaceA {
    public abstract void methodA();
    public abstract  void methodCommon();
}
public interface MyinterfaceB {
    public abstract void methodB();
    public abstract  void methodCommon();
}
public interface Myinterface extends MyinterfaceA,MyinterfaceB{
    public abstract void method();
}
public class DemoMyinterface implements Myinterface{//实现四个抽象方法
    @Override
    public void methodA() {
    }
    @Override
    public void methodCommon() {
    }
    @Override
    public void methodB() {
    }
    @Override
    public void method() {
    }
}

接口 对象 = new 实现类 和 实现类 对象 = new 实现类的区别

  • 前提：接口A 类B是接口A的实现类

    A a = new B();

    B b = new B();

  • 区别

    a对象只能调用接口A中的方法，不能调用B中特有的方法；B可以调用接口和实现类中的特有方法

    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
    public interface SaleComputer {
        public void show();
    }
    public class Lenovo implements SaleComputer{
        @Override
        public void show() {
            System.out.println("展示电脑....");
        }
        public void myshow(){
            System.out.println("展示实现类的特有方法");
        }
    }
    public class ProxyTest {
        public static void main(String[] args) {
            //接口 = new 接口实现类
            SaleComputer temp = new Lenovo();
            temp.show();
            //实现类 对象 = new 实现类
            Lenovo lenovo = new Lenovo();
            lenovo.show();
            //调用实现类特有方法
            lenovo.myshow();      
        }
    }