1.接口和抽象类的区别

它们都无法直接实例化

• 接口：使用 interface 关键字定义，接口中的所有方法默认是 public abstract，即使不写修饰符。接口不包含任何实现代码。
• 抽象类：使用 abstract 关键字定义，可以包含抽象方法和已实现的方法。抽象方法没有方法体，已实现的方法有具体的代码。

// 接口定义
interface Animal {
    void eat();  // 默认是 public abstract
}

// 抽象类定义
abstract class Animal {
    abstract void eat();  // 抽象方法

    void sleep() {  // 已实现的方法
        System.out.println("Sleeping...");
    }
}

• 接口：接口中的变量默认是 public static final，即常量，因此无法修改。接口不可以有实例变量。
• 抽象类：抽象类可以有实例变量（非 static final），可以被子类继承和修改。

interface Animal {
    // 默认是 public static final
    int age = 5;
}

abstract class Animal {
    // 可以有实例变量
    int age = 5;
}

• 接口：一个类可以实现多个接口，支持多重继承（接口之间也可以继承）。
• 抽象类：一个类只能继承一个抽象类（单继承）。

// 接口实现
class Dog implements Animal, Mammal {
    public void eat() {
        System.out.println("Dog eats");
    }
}

// 抽象类继承
class Dog extends Animal {
    public void eat() {
        System.out.println("Dog eats");
    }
}

• 接口：接口不能有构造器。
• 抽象类：抽象类可以有构造器，子类可以调用父类的构造器。

// 接口不能有构造器
interface Animal {
    void eat();
}

// 抽象类可以有构造器
abstract class Animal {
    int age;

    public Animal(int age) {
        this.age = age;
    }

    abstract void eat();
}

• 接口：接口支持多重继承，一个类可以实现多个接口。
• 抽象类：Java不支持类的多重继承，因此一个类只能继承一个抽象类。

interface Animal {
    void eat();
}

interface Mammal {
    void breathe();
}

// 支持多重接口实现
class Dog implements Animal, Mammal {
    public void eat() {
        System.out.println("Dog eats");
    }

    public void breathe() {
        System.out.println("Dog breathes");
    }
}

接口与抽象类的实际应用：

接口代码：Bird 类实现了两个接口 Flyable 和 Eatable，并实现了它们的方法；

interface Flyable {
    void fly();
}

interface Eatable {
    void eat();
}

class Bird implements Flyable, Eatable {
    public void fly() {
        System.out.println("Bird can fly.");
    }

    public void eat() {
        System.out.println("Bird can eat.");
    }
}

public class Main {
    public static void main(String[] args) {
        Bird bird = new Bird();
        bird.fly();
        bird.eat();
    }
}

抽象类：Dog 类继承了 Animal 抽象类，并实现了 sound 方法，同时继承了 sleep 方法；

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

    void sleep() {  // 已实现方法
        System.out.println("Sleeping...");
    }
}

class Dog extends Animal {
    @Override
    void sound() {
        System.out.println("Bark");
    }
}

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

特性	接口 (interface)	抽象类 (abstract class)
方法	默认是 abstract，可以有默认方法、静态方法	可以有抽象方法，也可以有已实现的方法
变量	默认是 public static final 常量	可以有实例变量，可变
构造器	不能有构造器	可以有构造器
继承方式	支持多继承，一个类可以实现多个接口	不支持多继承，一个类只能继承一个抽象类
使用场景	用于定义一组不相关类的共同行为	用于为相关类提供共有的功能和代码重用