设计鸟类BIrd、鱼类Fish，都继承自抽象的动物类Animal，实现其抽象方法info（），输出各自的信息。

这是一个关于面向对象设计的基本示例，运用了"继承"和"抽象方法"的概念。首先，我们创建一个名为`Animal`的抽象类，它包含一个抽象方法`info()`，这个方法需要由具体的子类来实现。然后，我们有两个具体类，`Bird`和`Fish`，它们都继承自`Animal`。

// 抽象Animal类
public abstract class Animal {
    // 抽象方法info()
    public abstract void info();
}

// 鸟类Bird
public class Bird extends Animal {
    @Override
    public void info() {
        System.out.println("我是鸟，会飞。");
    }
}

// 鱼类Fish
public class Fish extends Animal {
    @Override
    public void info() {
        System.out.println("我是鱼，会游泳。");
    }
}

当你实例化`Bird`或`Fish`并调用它们的`info()`方法时，会分别打印出对应物种的信息。这展示了多态性，即虽然引用的是`Animal`类型的变量，但实际上却调用了子类特有的行为。

相关问题

设计Brid (鸟) Fish(鱼)类，都继承自Aniaml(动物)类，实现其方法info()，输出信息

在面向对象编程中，我们可以创建一个抽象基类Animal，然后让两个具体的类Bird（鸟类）和Fish（鱼类）继承自它。这样的设计可以让它们共享一些通用的行为和属性，同时也可以各自提供特有的功能。下面是一个简单的示例，使用Python语言来说明：

class Animal:
    def info(self):
        raise NotImplementedError("子类需要实现这个方法")

class Bird(Animal):
    def __init__(self, name):
        self.name = name

    def info(self):
        return f"{self.name} is a bird."

class Fish(Animal):
    def __init__(self, species):
        self.species = species

    def info(self):
        return f"{self.species} is a fish."

# 使用示例
bird_instance = Bird("Sparrow")
print(bird_instance.info())  # 输出: Sparrow is a bird.

fish_instance = Fish("Goldfish")
print(fish_instance.info())  # 输出: Goldfish is a fish.

在这个例子中，`Animal`类有一个未实现的`info`方法，它的目的是强制子类覆盖这个方法。`Bird`和`Fish`分别实现了自己的`info`方法，每个实例调用时会返回相应的物种信息。

设计程序实现实现类、对象、继承、抽象类及接口应用

好的，以下是一个简单的示例程序，演示了类、对象、继承、抽象类和接口的应用：

# 定义一个动物类
class Animal:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def speak(self):
        pass

# 定义一个狗类，继承自动物类
class Dog(Animal):
    def __init__(self, name, age):
        super().__init__(name, age)
        
    def speak(self):
        return "汪汪！"

# 定义一个猫类，继承自动物类
class Cat(Animal):
    def __init__(self, name, age):
        super().__init__(name, age)
        
    def speak(self):
        return "喵喵！"

# 定义一个抽象类，表示可以飞的动物
from abc import ABC, abstractmethod

class FlyingAnimal(ABC):
    @abstractmethod
    def fly(self):
        pass

# 定义一个鸟类，继承自动物类和飞行动物类
class Bird(Animal, FlyingAnimal):
    def __init__(self, name, age):
        super().__init__(name, age)
        
    def speak(self):
        return "叽叽喳喳！"
    
    def fly(self):
        return "我正在飞行！"

# 定义一个接口，表示可以游泳的动物
class SwimmingAnimal:
    def swim(self):
        pass

# 定义一个鱼类，实现了游泳动物接口
class Fish(Animal, SwimmingAnimal):
    def __init__(self, name, age):
        super().__init__(name, age)
        
    def speak(self):
        return "没有声音！"
    
    def swim(self):
        return "我正在游泳！"

# 创建对象并调用方法
dog = Dog("小狗", 3)
print(dog.name, dog.age, dog.speak())

cat = Cat("小猫", 2)
print(cat.name, cat.age, cat.speak())

bird = Bird("小鸟", 1)
print(bird.name, bird.age, bird.speak(), bird.fly())

fish = Fish("小鱼", 1)
print(fish.name, fish.age, fish.speak(), fish.swim())

输出结果如下：

小狗 3 汪汪！
小猫 2 喵喵！
小鸟 1 叽叽喳喳！ 我正在飞行！
小鱼 1 没有声音！ 我正在游泳！

在这个示例程序中，我们定义了一个动物类，然后派生出狗类、猫类和鸟类，它们都继承了动物类，并重写了 speak 方法。同时，我们定义了一个抽象类 FlyingAnimal，表示可以飞的动物，然后定义了一个鸟类，继承了动物类和 FlyingAnimal 抽象类，并实现了 fly 方法。最后，我们定义了一个接口 SwimmingAnimal，表示可以游泳的动物，然后定义了一个鱼类，继承了动物类并实现了 SwimmingAnimal 接口的 swim 方法。在程序中，我们创建了各种对象，并调用了它们的方法来展示它们的特性。