Java超详细介绍抽象类与接口的使用

在Java语言中，抽象类和接口是两种重要的语法结构，它们可以用来描述一类对象所共有的特性和行为。本文将从定义、特点、使用场景、实现方式等多个方面，超详细地介绍抽象类和接口在Java中的使用。

抽象类的定义和特点

抽象类是一种特殊的类，它不能直接被实例化，只能用来作为其他类的基类。抽象类中包含了多个方法的定义，这些方法可以是抽象方法（没有具体实现的方法）或非抽象方法（具有具体实现的方法）。抽象类的特点包括：

• 抽象类不能直接被实例化，只能用来作为其他类的基类。
• 抽象类可以包含普通的成员变量、成员方法、静态成员、静态方法等。
• 抽象类中可以包含抽象方法，但抽象方法不能有具体实现，只能在子类中实现。
• 如果一个类继承了抽象类，那么这个类必须实现所有的抽象方法，除非这个类也是抽象类。

public abstract class Animal {
    private String name;

    public Animal(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    // 抽象方法，子类必须实现
    public abstract void run();

    // 非抽象方法，子类可以直接调用
    public void eat() {
        System.out.println(getName() + " is eating.");
    }
}

接口的定义和特点

接口是一种抽象的类型，它定义了一组方法的签名，但没有具体的实现。接口可以被类实现，一个类可以实现多个接口，从而使得这个类具有接口所定义的所有方法。接口的特点包括：

• 接口中的所有方法都是抽象方法，没有具体的实现。
• 接口中不能包含成员变量，只能包含静态常量（使用final关键字修饰）。
• 一个类可以实现多个接口，但只能继承一个类。
• 如果一个类实现了某个接口，那么它必须实现接口中所有的方法。

public interface Runnable {
    public void run();
}

public interface Flyable {
    public void fly();
}

抽象类和接口的使用场景

抽象类和接口都是用来描述一类对象所共有的特性和行为，它们的使用场景有一些类似，但也有一些区别。

抽象类的使用场景

• 定义一类对象的通用特性和行为。
• 把子类的公共行为提取出来，避免重复代码。
• 在不同的子类中实现不同的特殊行为。

接口的使用场景

• 定义一组方法的规范，而不关心具体的实现。
• 多个类之间实现同样的接口，使得这些类可以互相替换。
• 提供多重继承的机制，使得一个类可以同时实现多个接口。

抽象类和接口的实现方式

在Java中，抽象类和接口的实现方式有些不同。抽象类通过继承来实现，而接口通过实现来实现。

抽象类的实现

public class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }

    @Override
    public void run() {
        System.out.println(getName() + " is running.");
    }
}

接口的实现

public class Cat implements Runnable {
    @Override
    public void run() {
        System.out.println("Cat is running.");
    }
}

示例说明

示例1：抽象类的使用

假设我们要定义一个动物园的类，这个类可以添加动物（包括狗、猫等），并且可以让这些动物跑起来。这时可以通过定义一个抽象类来实现：

public abstract class Animal {
    private String name;

    public Animal(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    // 抽象方法，子类必须实现
    public abstract void run();

    // 非抽象方法，子类可以直接调用
    public void eat() {
        System.out.println(getName() + " is eating.");
    }
}

public class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }

    @Override
    public void run() {
        System.out.println(getName() + " is running.");
    }
}

public class Cat extends Animal {
    public Cat(String name) {
        super(name);
    }

    @Override
    public void run() {
        System.out.println(getName() + " is running.");
    }
}

public class Zoo {
    private List<Animal> animals;

    public Zoo() {
        this.animals = new ArrayList<>();
    }

    public void addAnimal(Animal animal) {
        this.animals.add(animal);
    }

    public void letThemRun() {
        for (Animal animal : animals) {
            animal.run();
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Zoo zoo = new Zoo();

        Dog dog = new Dog("Wangcai");
        Cat cat = new Cat("Tommy");

        zoo.addAnimal(dog);
        zoo.addAnimal(cat);

        zoo.letThemRun();
    }
}

上面的示例中，我们定义了一个抽象类Animal，包含了共有的方法run()和eat()，其中run()是抽象方法，这说明所有的动物都应该会跑，但是狗的跑和猫的跑是不同的，因此我们在Dog和Cat类中对run()方法进行了实现。使用Zoo类来添加动物和让它们跑起来。

示例2：接口的使用

假设我们要定义一个任务接口，可以让某个任务在后台异步执行，同时可以在任务完成后回调。这时可以通过定义一个接口来实现：

public interface Task {
    void execute(Consumer<Void> finishCallback);
}

public class BackgroundTask implements Task {
    @Override
    public void execute(Consumer<Void> finishCallback) {
        // 后台执行任务
        new Thread(() -> {
            System.out.println("Background task is running...");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                // ignore
            }
            System.out.println("Background task is finished.");
            // 调用回调函数
            if (finishCallback != null) {
                finishCallback.accept(null);
            }
        }).start();
    }
}

public class Main {
    public static void main(String[] args) {
        Task task = new BackgroundTask();
        task.execute((result) -> {
            System.out.println("Task has been finished.");
        });
        System.out.println("Main thread is working...");
    }
}

上面的示例中，我们定义了一个接口Task，其中定义了一个方法execute()，这个方法接受一个回调函数作为参数，可以在任务完成后回调这个函数。使用BackgroundTask类来实现Task接口，后台执行一个任务。在Main类中使用BackgroundTask来执行一个任务，并在任务完成后输出信息。

理解接口与抽象类的区别

总结来说，抽象类更多地强调一类对象的通用特性和行为，而接口更多地强调一组方法的规范，而不关心具体的实现。在Java中，抽象类和接口都有重要的用途，需要根据具体的需求来选择使用哪一种。