面向对象抽象类和接口的例题

假设我们要设计一个动物园的程序，其中有多种动物，每种动物都有自己的特性和行为。这时候，我们可以使用面向对象的设计思想来实现这个程序。

首先，我们可以定义一个抽象类 Animal，它包含动物的基本属性和行为，例如：

public abstract class Animal {
    protected String name;
    protected int age;
    
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public abstract void eat();
    public abstract void sleep();
    public abstract void makeSound();
}

在这个抽象类中，我们定义了动物的基本属性 name 和 age，以及三个抽象方法 eat、sleep 和 makeSound，表示动物的基本行为。由于每种动物的具体实现不同，因此这些方法只是声明而不实现，留给子类去具体实现。

接下来，我们可以定义几个具体的动物子类，例如：

public class Lion extends Animal {
    public Lion(String name, int age) {
        super(name, age);
    }
    
    @Override
    public void eat() {
        System.out.println("Lion is eating meat.");
    }
    
    @Override
    public void sleep() {
        System.out.println("Lion is sleeping.");
    }
    
    @Override
    public void makeSound() {
        System.out.println("Roar!");
    }
}

public class Elephant extends Animal {
    public Elephant(String name, int age) {
        super(name, age);
    }
    
    @Override
    public void eat() {
        System.out.println("Elephant is eating grass.");
    }
    
    @Override
    public void sleep() {
        System.out.println("Elephant is sleeping.");
    }
    
    @Override
    public void makeSound() {
        System.out.println("Trumpet!");
    }
}

在这些子类中，我们重写了父类中的抽象方法，并实现了具体的行为。例如，Lion 类中的 eat 方法表示狮子吃肉，而 Elephant 类中的 eat 方法表示大象吃草。

最后，我们可以在主程序中创建一个动物园对象，添加各种不同的动物，例如：

public class Zoo {
    private List<Animal> animals;
    
    public Zoo() {
        animals = new ArrayList<>();
    }
    
    public void addAnimal(Animal animal) {
        animals.add(animal);
    }
    
    public void showAnimals() {
        for (Animal animal : animals) {
            System.out.println(animal.name + " is " + animal.age + " years old.");
            animal.eat();
            animal.sleep();
            animal.makeSound();
            System.out.println();
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Zoo zoo = new Zoo();
        zoo.addAnimal(new Lion("Simba", 3));
        zoo.addAnimal(new Elephant("Dumbo", 5));
        zoo.showAnimals();
    }
}

在主程序中，我们创建了一个动物园对象 zoo，添加了一只狮子和一头大象，然后展示了它们的基本信息和行为。运行程序，可以看到如下输出：

Simba is 3 years old.
Lion is eating meat.
Lion is sleeping.
Roar!

Dumbo is 5 years old.
Elephant is eating grass.
Elephant is sleeping.
Trumpet!

通过这个例子，我们可以看到抽象类和接口的使用。Animal 类作为抽象类，定义了动物的基本属性和行为，并声明了一些抽象方法，留给子类去实现。而 Lion 和 Elephant 类作为具体的子类，继承了 Animal 类，并实现了它的抽象方法，以便具体实现狮子和大象的行为。最后，在 Zoo 类中，我们使用 Animal 类的对象来表示动物，从而可以添加不同种类的动物并展示它们的基本信息和行为。