java中的接口

1、接口的概念与格式

概念：接口就是一种公共的规范标准，在java编程语言中是一个抽象类型，是抽象方法的集合

格式：

public interface Example{
     //.....
}

注意：
1. 接口就是多个类的公共规范
2. 接口是一种引用数据类型，最重要的内容是其中的抽象方法
3. 接口包含的内容：
  
  java 7 ：常量，抽象方法
  
  java 8：默认方法、静态方法
  
  java 9 ：私有方法
4. 接口不能new对象，它的实现类才可以new，这是实现类一定不是抽象类
5. 如果一个实现类，并没有覆盖所有的抽象方法，那么该实现类一定是抽象类，
6. 含有抽象方法的类，一定是抽象类，但是抽象类不一定含有抽象方法

案例：

package Interface;

// 接口
public interface Example {

    
    public abstract void methodAbs1();

    public abstract void methodAbs2();

    public void methodAbs3();

    void methodAbs4();


}

package Interface;

//实现类
public class MyInterfaceAbstractImpl implements Example {
    @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("这是第四个方法");
    }
}

package Interface;

//测试类
public class Demo1Interface {

    public static void main(String[] args) {

        //错误写法，接口不能直接new
//        Example example = new Example();

        //创建实现类的对象来使用     
        MyInterfaceAbstractImpl imp = new MyInterfaceAbstractImpl();
        imp.methodAbs1();
        imp.methodAbs2();

    }
}

2、接口中的默认方法

理解：

接口中的默认方法可以再实现类不需要被重写，这就方便了很多，因为，要是在接口中增加一个抽象方法，在实现类中必须要重写，现在有了默认方法，可以重写，也可以不重写，实现类的对象可以直接调用这个默认方法，如果在实现类中重写了该默认方法，那实现类的对象先用的是你重写的方法，

package Interface;

//接口
public interface Example {

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

    //默认方法
    public default void methodAbs2(){
        System.out.println("接口的默认！！");
    }
}

package Interface;


public class MyInterfaceAbstractImpl implements Example {

    @Override
    //接口的抽象方法被重写
    public void methodAbs() {
        System.out.println("抽象方法重写");
    }
}

package Interface;


public class MyInterfaceAbstractImplB implements Example {

    @Override
    //接口的抽象方法被重写
    public void methodAbs() {
        System.out.println("抽象方法B");
    }

    @Override
    //默认方法被重写
    public void methodAbs2() {
        System.out.println("接口的默认方法重写");
    }
}

package Interface;

public class Demo1Interface {

    public static void main(String[] args) {

        //创建实现类的对象来使用
        MyInterfaceAbstractImpl imp = new MyInterfaceAbstractImpl();
        MyInterfaceAbstractImplB impB = new MyInterfaceAbstractImplB();

        imp.methodAbs();     //抽象方法被重写
        imp.methodAbs2();    //接口的默认方法被调用！！

        System.out.println("$$$$$$$$$$$$$$$$$$$$");

        impB.methodAbs();    //抽象方法被重写B
        impB.methodAbs2();   //接口的默认方法被重写
    }
}

抽象方法重写
接口的默认！！
$$$$$$$$$$$$$$$$$$$$
抽象方法B
接口的默认方法重写

3、静态方法

理解：静态方法，与对象没有关系，直接与类有关，

接口中的静态方法：

在接口中为啥要用静态方法：
- 继承的多个接口都存在相同的默认方法，那就会产生冲突问题，
接口中静态方法的注意：
- 静态方法不可以被接口实现类重写，
- 接口的静态方法直接用过接口名来调用，
接口中不能有静态代码块，不能有构造方法

案例：

package Interface.demo2;


public interface Example {

    //静态方法
    public static void method(){
        System.out.println("接口的静态方法");
    }
}

package Interface.demo2;

//实现接口
public class MyInterfaceAbstractImpl implements Example {

}

package Interface.demo2;

public class Demo2Interface {

    public static void main(String[] args) {

        //实例化实现接口的对象
        MyInterfaceAbstractImpl impl = new MyInterfaceAbstractImpl();
        //错误写法
//        impl.method();
        //正确写法，接口中的静态方法，直接通过接口名来调用，因为
        //静态方法与类相关与对象无关
        //通过接口名来直接调用静态方法
        Example.method();
    }
}

接口的静态方法

4、稀有方法

为啥要有静态中的稀有方法，因为在接口中，如何默认方法中有重复的代码，那将使用接口中的稀有方法来解决这一问题，稀有方法，只可以在本类中调用，将默认方法中重复的代码写到稀有方法中，别的类访问不到，但是这个默认方法就可以访文到，这就很好的解决了这个问题
静态稀有方法，解决多个静态方法直接重复代码的问题
普通稀有方法，解决多个默认方法直接重复代码的问题

package Interface.demo3;

public interface MyInterfacePrivateA {

    public default void methodDefault1(){
        System.out.println("默认方法1");
//        System.out.println("AAAAA");
//        System.out.println("BBBBB");
//        System.out.println("CCCCC");
        methodSame();
    }

    public default void methodDefault2(){
        System.out.println("默认方法2");
//        System.out.println("AAAAA");
//        System.out.println("BBBBB");
//        System.out.println("CCCCC");
        methodSame();
    }

    private void methodSame(){
        System.out.println("AAAAA");
        System.out.println("BBBBB");
        System.out.println("CCCCC");
    }

}

5、接口中的常量

接口当中也可以定义“成员变量”，但是必须使用public static final来修饰。

从效果上看，这其实就是接口中常量

格式：public static final 数据类型常量名称 = 数据值；

一旦使用final来修饰，说明不可变，

注意：

借口中的常量，可以省略public static final，注意不写也照样可以
接口中的常量必须进行赋值，
这个常量的名称使用完全大写，并且使用下划线分割如：NUM_OF_PI

6、接口中注意的问题

接口中没有静态代码块和构造方法
一个类的直接父类只能有一个，但是一个类可以同时实现多个接口
如果实现类没有覆盖重写所有的抽象方法，那么这个实现类一定是抽象类
如果实现类实现的多个接口当中，存在重复的默认方法，那么实现类一定要对重复的默认方法进行覆盖重写，
一个类如果直接父类当中的方法和接口当中的默认方法发生了冲突，那么优先使用父类中的方法

7、接口之间的多继承

类与类之间是单继承，直接父类只有一个，
类与接口直接是多实现，一个类可以实现多个接口。
接口与接口之间是多继承。
多个父类当中的方法如果重复，没关系
多个父类当中的默认方法重复那么子接口必须进行默认方法的重写

package Interface.demo4;

public interface MyInterfaceA {

    public abstract void MyInterfaceA();

    public abstract void Common();

    public default void Mydafault(){
        System.out.println("AAA");
    }
}

package Interface.demo4;

public interface MyInterfaceB {

    public abstract void MyInterfaceB();

    public abstract void Common();

    public default void Mydafault(){
        System.out.println("BBB");
    }
}

package Interface.demo4;

public interface MyInterface extends MyInterfaceA,MyInterfaceB {
    @Override
    default void Mydafault() {
        System.out.println("实现的默认方法");
    }
}

package Interface.demo4;

public class MyInterfaceImp implements MyInterface {
    @Override
    public void MyInterfaceA() {

    }

    @Override
    public void Common() {

    }

    @Override
    public void MyInterfaceB() {

    }
}

java中的接口

Java相关栏目本月热门文章