java基础学习（接口和抽象类的区别）

1.接口和抽象类的区别

它们都无法直接实例化

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

java 复制代码

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

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

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

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

java 复制代码

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

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

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

java 复制代码

// 接口实现
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");
    }
}

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

java 复制代码

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

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

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

    abstract void eat();
}

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

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，并实现了它们的方法；

java 复制代码

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 方法；

java 复制代码

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 常量 | 可以有实例变量，可变 |
| 构造器 | 不能有构造器 | 可以有构造器 |
| 继承方式 | 支持多继承，一个类可以实现多个接口 | 不支持多继承，一个类只能继承一个抽象类 |
| 使用场景 | 用于定义一组不相关类的共同行为 | 用于为相关类提供共有的功能和代码重用 |