接口（上）

什么是接口

接口是一种公共的规范标准，只要符合规范，大家都可以使用，类似于家庭中的插座，在国内的标准统一；

接口的四类用法

1. 接口定义抽象方法
2. 接口定义默认方法
3. 接口定义静态方法
4. 接口定义私有方法

1·接口定义抽象方法

在任何版本的java中，接口都能够定义抽象方法。
格式：
    [public]  [abstract]  返回值类型  方法名称（参数列表）；

注意事项

• 接口当中的抽象方法，修饰符必须是两个固定的关键字，第一个：public；第二个abstract；
• 这两个关键字修饰符，可以选择性的省略

public interface MyInterfaceAbstract {
    //这是一个抽象方法
    public abstract void methodAbs1();
    
    //这也是一个抽象方法
    abstract void methodAbs2();
    
    //这也是一个抽象方法
    public void methodAbs3();
    
    //这也是抽象方法
    void methodAbs4();

• 方法的三要素可以随意定义

接口使用抽象方法的步骤

1. 接口不能直接使用，必须有一个“实现类”来实现该接口。

   格式：
   public class 实现类名称 implements 接口名称{
   //···
   }

2. 接口的实现类必须覆盖重写（实现）接口中所有的抽象方法。 （覆盖重写）实现，去掉abstract关键字，加上方法体大括号。
3. 创建实现类的对象，进行使用

注意

如果实现类并没有覆盖重写接口中所有的抽象方法，那么这个实现类自己就必须是抽象类。

public class MyInterfaceAbstractImpl implements MyInterfaceAbstract{
@Override
    public void methodAbs1(){
    System.out.println("这是重写了的第一个方法");
    }
    
 @Override
    public void methodAbs2(){
    System.out.println("这是重写了的第二个方法");
    }
    
@Override
    public void methodAbs3(){
    System.out.println("这是重写了的第三个方法");
    }
    
@Override
    public void methodAbs4(){
    System.out.println("这是重写了的第四个方法");
    }
}

定义一个测试类，用来对以上两个代码进行输出：

public stastic void main(String[] args){
   MyInterfaceAbstractImpl impl = new MyInterfaceAbstractImpl();
   impl.methodAbs1();//这是重写了的第一个方法
   impl.methodAbs2();//这是重写了的第二个方法
   impl.methodAbs3();//这是重写了的第三个方法
}

2·接口定义默认方法

接口当中的默认方法，可以解决接口升级的问题

从java8开始，接口里允许定义默认方法。
格式: Public default 返回值类型 方法名称（参数列表）{
方法体
}

接口使用默认方法

1. 可以通过接口实现类对象，直接调用；
2. 也可以被接口实现类进行覆盖重写

   public interface MyInterfaceDefault {

    //抽象方法
    public abstract void methodsAbs();

    //新添加一个抽象方法
    //public abstract void methodAbs2();

    //    新添加的方法，改成默认方法
    public default void methodDefault(){
        System.out.println("这是新添加的默认方法");
    }
}
 

实现接口A

    public class MyInterfaceDefaultA implements MyInterfaceDefault{


    @Override
    public void methodsAbs() {
        System.out.println("实现了抽象方法，AAA");
    }
}

实现接口B

   public class MyInterfaceDefaultB implements MyInterfaceDefault{

    @Override
    public void methodsAbs() {
        System.out.println("实现了抽象方法BBB");
    }
}
 

进行测试

    public class Test {
    public static void main(String[] args) {
//        创建了实现类对象
        MyInterfaceDefaultA a = new MyInterfaceDefaultA();

        a.methodsAbs();//调用抽象方法，实际运行的是右侧实现类
//      调用默认方法，如果实现类当中没有，会向上找接口
        a.methodDefault();


        System.out.println("=========>");

        MyInterfaceDefaultB b = new MyInterfaceDefaultB();
        b.methodsAbs();
        b.methodDefault();

    }
}