java接口相关概念

1.接口的定义

接口使用 interface 关键字定义，它可以包含方法声明、常量及默认方法和静态方法。

• 在接口中，我们一般只需声明方法，不能写函数体（除了默认方法和静态方法可以外，其他的都不可以，默认方法是用 default 关键字修饰的方法，静态方法是用 static 关键字修饰的方法）。
• 还需要注意的是在接口中的方法默认是用 public 修饰的，如果用 private 修饰，编译器会报错，这是为什么呢？ 因为有类去实现了接口的话，那它必须要实现接口中的所有方法，而用private 修饰的方法只能在内部调用，在外部是调用不了的，所以在类中无法去实现这个方法，这就违背了接口本身的性质。（除了用 private 修饰，其他的都行）
• 而在接口中要声明一个变量，则必须要是常量，不然会报错，这个你们可以自己去试一试，看看会报什么错。

public interface MyInterface1 {
    // 方法声明
    void method1();
    
    // 常量
    int CONSTANT = 10;
    
    // 默认方法
    default void defaultMethod1() {
        // 实现
    }

    // 静态方法
    static void staticMethod1() {
        // 实现
    }
}

 

2.接口的实现

类通过关键字 implements 来实现接口，需注意的是必须要实现接口中所有的方法（除了默认方法和静态方法外）。

• 类可以实现一个或者多个的接口。
• 接口可以被多个类实现。

实现一个接口： 

public class MyClass implements MyInterface1 {
    // 必须提供接口中定义的方法实现
    @Override
    public void method1() {
        // 实现
    }
}

实现多个接口：

public class MyClass implements MyInterface1， MyInterface2， MyInterface3 {
    // 必须提供接口中定义的方法实现
    @Override
    public void method1() {
        // 实现
    }
    public void method2() {
        // 实现
    }
    public void method3() {
        // 实现
    }
}

3.多态性

通过接口可以实现多态性，即一个对象可以被当做接口类型来引用，而实际上是其实现类的对象。这使得程序更加灵活，能够在运行时动态地改变对象的行为。类似于父类引用子类的对象。

interface IAbility{
    void showInfo();  //输出动物信息
    void cry();    //动物发出叫声
}

abstract class Animal{
    private String name;  //名字
    private int age;   //年龄

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

class Dog extends Animal implements IAbility {
    public Dog( String name, int age) {
        super( name, age);
    }

    @Override
    public void showInfo() {
        System.out.println("我是一只狗,我的名字是" + getName() + ",今年" + getAge() + "岁");
    }

    @Override
    public void cry() {
        System.out.println("旺旺");
    }
}

class Cat extends Animal implements IAbility {

    public Cat( String name, int age) {
        super( name, age);
    }

    @Override
    public void showInfo() {
        System.out.println("我是一只猫,我的名字是" + getName() + ",今年" + getAge() + "岁");
    }

    @Override
    public void cry() {
        System.out.println("喵喵");
    }
}

class Simulator {
    public void playSound(IAbility animal) {
        animal.showInfo();
        animal.cry();
        try {
            Cat a = (Cat)animal;
            System.out.println(a.getName());
            System.out.println(a.getAge());
        }
        catch (Exception e) {
            Dog a = (Dog)animal;
            System.out.println(a.getName());
            System.out.println(a.getAge());
        }
    }
}

如在以上代码中的 Simulator类中的 playSound() 方法中我们的参数是一个接口对象，实际就是一个实际的Dog或者Cat对象。我们在 try-catch 块中去判断这个实际对象到底是Dog还是Cat。

4.接口的继承

接口可以继承其他接口，使用 extends 关键字。这个就非常类似于父子类继承了。

不能实现父接口的方法，但是能够在父接口的基础上添加新方法。

public interface MySubInterface extends MyInterface {
    // 添加新的方法声明
    void method2();
}

5.抽象类和接口的区别

抽象类和接口都可以用于实现抽象数据类型，但它们之间有几个重要的区别。

• 抽象类中可以有零个或多个抽象方法，且可以包含成员变量和非抽象方法的实现。
• 接口中只能包含常量和方法声明。
• 类只能继承一个父类。
• 类可以实现多个接口。

总结一下就是，接口对子类的要求更加的严格。