举例说明什么情况下会更倾向于使用抽象类而不是接口？

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

    // 具体方法
    void breathe() {
        System.out.println("Breathing...");
    }
}

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

class Cat extends Animal {
    @Override
    void makeSound() {
        System.out.println("Meow");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.makeSound(); // 输出: Bark
        dog.breathe();   // 输出: Breathing...

        Cat cat = new Cat();
        cat.makeSound(); // 输出: Meow
        cat.breathe();   // 输出: Breathing...
    }
}

abstract class Vehicle {
    protected String color;

    public Vehicle(String color) {
        this.color = color;
    }

    abstract void start();
}

class Car extends Vehicle {
    public Car(String color) {
        super(color);
    }

    @Override
    void start() {
        System.out.println("Car starting...");
    }
}

public class Main {
    public static void main(String[] args) {
        Car car = new Car("Red");
        car.start(); // 输出: Car starting...
        System.out.println(car.color); // 输出: Red
    }
}

abstract class User {
    protected String name;

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

    abstract void displayInfo();
}

class Admin extends User {
    public Admin(String name) {
        super(name);
    }

    @Override
    void displayInfo() {
        System.out.println("Admin: " + name);
    }
}

public class Main {
    public static void main(String[] args) {
        Admin admin = new Admin("Alice");
        admin.displayInfo(); // 输出: Admin: Alice
    }
}

abstract class BaseClass {
    abstract void baseMethod();
}

class AnotherClass {
    void anotherMethod() {
        System.out.println("Another method");
    }
}

class DerivedClass extends BaseClass {
    private AnotherClass anotherClass = new AnotherClass();

    @Override
    void baseMethod() {
        System.out.println("Base method");
    }

    void combinedMethod() {
        baseMethod();
        anotherClass.anotherMethod();
    }
}

public class Main {
    public static void main(String[] args) {
        DerivedClass derived = new DerivedClass();
        derived.combinedMethod();
        // 输出:
        // Base method
        // Another method
    }
}