java中的接口(interface)_java interface 大些-CSDN博客

本文链接：https://blog.csdn.net/lebulang12/article/details/130588405

java的接口(interface)

要学习Java中的接口，我们首先要认识什么是接口.

1.接口是什么？

接口，是java的一种引用类型，接口的内部封装了抽象方法（JDK7及以前），在JDK8版本新增了默认方法和静态方法，在JDK9新增了私有方法。在定义接口时使用interface关键字。接口不能创建对象，但可以被实现（通过implements关键字来实现)，一个实现接口的类，需要实现接口全部的抽象类，创建该类的对象就可以调用方法了。接口中没有静态代码块。

2.接口的定义方式

（JDK7及之前）

public interface 类名 （后边可以跟继承）{
    //在类中可以定义抽象方法，在定义方法时，public abstract 可以省略（默认）
    public abstract void 方法名();
    //在类中还可以定义常量，不可以定义变量，默认被public static final修饰
    public static final 变量类型 变量名 初始化;
    
}

可以看到在接口中定义抽象方法，没有方法体，需要子类去实现。

（JDK8新增了默认方法和静态方法）

public interface 类名 （后边可以跟继承）{
    //静态方法
    public static void dog(){
        //执行语句
    }
    //默认方法
    public default void cat(){
        //执行语句
    }
}

（JDK9新增了私有方法）

public interface 类名 （后边可以跟继承）{
	//私有方法
    private void tiger(){
        //执行语句
    }
}

接口不能定义构造方法，哪怕这个类是抽象的，所以接口不能实例化

3.接口的实现

使用implement关键字来实现接口，实现接口的类称为接口的子类，一个类可以同时实现好几个接口，只要实现接口中的全部的抽象方法。

例如：定义一个Animal接口，编写具体的类来实现

/*
 *    定义一个Animal的抽象类
 *      定义两个抽象方法，eat()和sleep()
 * */
public interface Animal{
    // 定义一个抽象方法吃
    void eat();//public abstract 省略，依然为抽象方法
    // 定义一个抽象方法睡觉
    void sleep();
}
//定义一个dog类来实现Animal
class dog implements Animal{
    //需要实现Animal中的两个抽象方法
    @Override
    public void eat() {
        System.out.println("dog eat");
    }

    @Override
    public void sleep() {
        System.out.println("dog sleep");
    }
}

同时一个类可以实现多个接口，只要实现这些接口中的全部抽象方法

//定义一个dog类来实现Animal,Person
class dog implements Animal,Person{
    //需要实现Person中的抽象方法
    @Override
    public void smile() {
        System.out.println("person smile");
    }

    //需要实现Animal中的两个抽象方法
    @Override
    public void eat() {
        System.out.println("dog eat");
    }

    @Override
    public void sleep() {
        System.out.println("dog sleep");
    }
}

定义测试类

public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();
        dog.sleep();
        dog.smile();
    }
}

在接口中定义默认方法和静态方法

public class Class02 {
    public static void main(String[] args) {
        P p = new P();
        //通过子类对象来调用父类方法
        p.testDefault();
        //通过类名来调用静态方法
        Pizza.testStatic();
    }
}
//定义一个接口Pizza
interface Pizza{
    //定义一个静态方法
    public static void testStatic(){
        System.out.println("这是接口中的静态方法");
    }
    //定义一个默认方法
    public default void testDefault(){
        System.out.println("这是接口中的默认方法");
    }
}
//定义一个P类来实现Pizza接口
class P implements Pizza{
    //由于接口中并没有抽象方法，并不需要实现
}

可以看到在接口中定义的默认方法和静态方法，我们可以通过子类对象和接口类名来进行调用，这一点和继承一样，子类调用父类方法。所以也可以在子类中对父类方法进行重写。

在接口中定义私有方法：

public class Class03 {
    public static void main(String[] args) {
        A a = new A();
    }
}
//定义一个接口类
interface Lover{
    //定义一个私有方法
    private void f1(){
        System.out.println("这是一个接口中的私有方法");
    }
}
//定义一个实现类
class A implements Lover{
}