假设我们要设计一个动物园的程序，其中有多种动物，每种动物都有自己的特性和行为。这时候，我们可以使用
面向对象的设计思想来实现这个程序。
首先，我们可以定义一个
抽象类 Animal，它包含动物的基本属性和行为，例如：
```java
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，表示动物的基本行为。由于每种动物的具体实现不同，因此这些方法只是声明而不实现，留给子类去具体实现。
接下来，我们可以定义几个具体的动物子类，例如：
```java
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 方法表示大象吃草。
最后，我们可以在主程序中创建一个动物园
对象，添加各种不同的动物，例如：
```java
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 类的
对象来表示动物，从而可以添加不同种类的动物并展示它们的基本信息和行为。
410
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
