面向对象【interface接口、抽象类与抽象方法】

interface接口

接口是一种抽象的数据类型，它定义了一组方法，但没有提供方法的具体实现。在
Java中，接口是一种与类类似的结构，但它只包含常量和抽象方法的定义。类可以实现一个或多个接口，从而获得接口定义的方法。

定义接口

使用interface关键字来定义接口，接口中的方法默认为抽象方法，可以包含常量和默认方法（在Java 8及以后版本）。

public interface MyInterface {
    // 抽象方法
    void myMethod();

    // 常量
    int MAX_VALUE = 100;

    // 默认方法（Java 8及以后版本）
    default void defaultMethod() {
        System.out.println("This is a default method.");
    }
}

接口的格式与举例

接口的格式如下：

public interface InterfaceName {
    // 常量

    // 抽象方法

    // 默认方法（Java 8及以后版本）

    // 静态方法（Java 8及以后版本）

    // 私有方法（Java 9及以后版本）
}

接口的举例：

// 定义接口
public interface Teacher {
    // 抽象方法
    void teach();

    // 默认方法
    default void greet() {
        System.out.println("Hello, I'm a teacher.");
    }

    // 常量
    int MAX_STUDENTS = 30;
}

// 实现接口
public class MathTeacher implements Teacher {
    @Override
    public void teach() {
        System.out.println("Teaching Math.");
    }
}

// 使用接口
public class InterfaceExample {
    public static void main(String[] args) {
        // 创建实现接口的对象
        MathTeacher mathTeacher = new MathTeacher();
        
        // 调用抽象方法
        mathTeacher.teach();
        
        // 调用默认方法
        mathTeacher.greet();
        
        // 访问常量
        System.out.println("Maximum students: " + Teacher.MAX_STUDENTS);
    }
}

静态方法

Java 8及以后版本允许在接口中定义静态方法。静态方法可以通过接口名直接调用，不需要实例化接口。

public interface MyInterface {
    // 静态方法
    static void staticMethod() {
        System.out.println("This is a static method.");
    }
}

私有方法

Java 9及以后版本允许在接口中定义私有方法，用于在接口内部复用代码。私有方法只能在接口内部调用，不能在实现接口的类中使用。

public interface MyInterface {
    // 默认方法
    default void defaultMethod() {
        // 调用私有方法
        System.out.println("Result: " + privateMethod());
    }

    // 私有方法
    private int privateMethod() {
        return 42;
    }
}

接口的多继承

一个类可以实现多个接口，从而具有多个接口的方法。这使得Java支持了一种接近多继承的机制。

public interface Teacher {
    void teach();
}

public interface Singer {
    void sing();
}

public class Musician implements Teacher, Singer {
    @Override
    public void teach() {
        System.out.println("Teaching music.");
    }

    @Override
    public void sing() {
        System.out.println("Singing a song.");
    }
}

接口的默认方法冲突解决

public interface A {
    default void myMethod() {
        System.out.println("Method in interface A");
    }
}

public interface B {
    default void myMethod() {
        System.out.println("Method in interface B");
    }
}

public class MyClass implements A, B {
    // 手动解决冲突
    @Override
    public void myMethod() {
        A.super.myMethod(); // 或者 B.super.myMethod();
    }
}

接口与抽象类之间的对比

抽象类与抽象方法

抽象类

随着继承层次中一个个新子类的定义，类变得越来越具体，而父类则更一般，更通用。类的设计应该保证父类和子类能够共享特征。有时将一个父类设计得非常抽象，以至于它没有具体的实例，这样的类叫做抽象类。

抽象类的定义

抽象类是用abstract关键字声明的类，它可以包含抽象方法和具体方法。抽象类不能被实例化，通常用作其他类的基类。

public abstract class Shape {
    // 抽象方法
    public abstract double calculateArea();

    // 具体方法
    public void display() {
        System.out.println("This is a shape.");
    }
}

抽象方法

抽象方法是用abstract关键字声明的方法，它没有方法体，只有方法签名。抽象方法必须在抽象类中声明，由子类提供具体实现。

public abstract class Animal {
    // 抽象方法
    public abstract void makeSound();

    // 具体方法
    public void sleep() {
        System.out.println("The animal is sleeping.");
    }
}

使用抽象类

使用抽象类时，通常需要创建其子类并实现其中的抽象方法。

// 抽象类 - 人员
public abstract class Person {
    private String name;
    private int age;

    // 构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 抽象方法 - 获取角色
    public abstract String getRole();

    // 具体方法 - 显示基本信息
    public void displayInfo() {
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
        System.out.println("Role: " + getRole());
    }
}

// 子类 - 老师
public class Teacher extends Person {
    private String subject;

    // 构造方法
    public Teacher(String name, int age, String subject) {
        super(name, age);
        this.subject = subject;
    }

    // 实现抽象方法
    @Override
    public String getRole() {
        return "Teacher";
    }

    // 具体方法 - 显示老师信息
    public void teach() {
        System.out.println("Teaching " + subject);
    }
}

// 子类 - 学生
public class Student extends Person {
    private String grade;

    // 构造方法
    public Student(String name, int age, String grade) {
        super(name, age);
        this.grade = grade;
    }

    // 实现抽象方法
    @Override
    public String getRole() {
        return "Student";
    }

    // 具体方法 - 学习
    public void study() {
        System.out.println("Studying in grade " + grade);
    }
}

// 使用抽象类的例子
public class SchoolExample {
    public static void main(String[] args) {
        // 创建老师对象
        Teacher teacher = new Teacher("Mr. Smith", 35, "Mathematics");
        teacher.displayInfo();
        teacher.teach();

        System.out.println();

        // 创建学生对象
        Student student = new Student("Alice", 15, "10th");
        student.displayInfo();
        student.study();
    }
}

Person是一个抽象类，定义了人员的基本属性和方法，其中包括一个抽象方法getRole()。Teacher和Student分别是Person的子类，实现了getRole()方法，并分别添加了特定的方法（teach()和study()）。通过使用抽象类，我们可以将共有的行为和属性提取到父类中，实现了代码的重用和更好的组织结构。

参考链接

[1] w3cschool
[2] oracle