java用继承的方式实现一个多态程序

public class Animal {
public void sound() {
System.out.println("Animal makes a sound");
}
}

public class Dog extends Animal {
@Override
public void sound() {
System.out.println("Dog barks");
}
}

public class Cat extends Animal {
@Override
public void sound() {
System.out.println("Cat meows");
}
}

public class PolymorphismExample {
public static void main(String[] args) {
Animal animal1 = new Dog();
Animal animal2 = new Cat();

animal1.sound();
animal2.sound();
}
}

// Output:
// Dog barks
// Cat meows

相关问题

Java用面向对象的思想实现一个多态程序

好的，我可以给您提供一个简单的示例程序，用Java面向对象的思想实现多态。

假设我们有一个动物类 Animal，它有一个方法 sound()，用于发出声音。我们还有两个子类 Cat 和 Dog，它们都继承自 Animal 类，并重写了 sound() 方法。

下面是示例代码：

class Animal{
    public void sound(){}
}

class Cat extends Animal{
    public void sound(){
        System.out.println("Meow");
    }
}

class Dog extends Animal{
    public void sound(){
        System.out.println("Woof");
    }
}

public class Main{
    public static void makeSound(Animal animal){
        animal.sound();
    }
    
    public static void main(String[] args){
        Cat cat = new Cat();
        Dog dog = new Dog();
        
        makeSound(cat); // 输出 Meow
        makeSound(dog); // 输出 Woof
    }
}

在这个示例程序中，我们定义了一个 makeSound() 函数，它接受一个 Animal 对象作为参数，并调用它的 sound() 方法。

当我们传递一个 Cat 对象给 makeSound() 函数时，它会调用 Cat 类中重写的 sound() 方法，输出 "Meow"；当我们传递一个 Dog 对象时，它会调用 Dog 类中的 sound() 方法，输出 "Woof"。

这就是多态的实现，不同的对象调用相同的方法，但会产生不同的行为。

java面向对象自动贩卖机程序包含多态接口继承

好的，下面我来介绍如何在Java面向对象自动贩卖机程序中应用多态、接口和继承。

首先，我们可以定义一个Drink类作为所有饮料的父类，其中包含以下属性：

- name：一个String类型的变量，表示饮料名称。
- price：一个double类型的变量，表示饮料价格。

然后，我们可以定义多个子类，分别代表不同的饮料种类，例如Coke、Sprite和MineralWater。这些子类继承自Drink类，并实现Drink提供的接口。

接口可以定义自动贩卖机的基本功能，例如showDrinks()、insertCoin(double coin)和buy(int index)。这些功能可以被VendingMachine类和Drink类的子类实现，以实现代码的复用和扩展。

下面是一个简单的示例代码：

public interface IVendingMachine {

    void showDrinks();

    void insertCoin(double coin);

    void buy(int index);
}

public class VendingMachine implements IVendingMachine {

    private Drink[] drinks;
    private double balance;

    public VendingMachine(Drink[] drinks) {
        this.drinks = drinks;
        this.balance = 0;
    }

    @Override
    public void showDrinks() {
        System.out.println("饮料种类\t价格");
        for (int i = 0; i < drinks.length; i++) {
            System.out.println((i + 1) + ". " + drinks[i].getName() + "\t" + drinks[i].getPrice());
        }
    }

    @Override
    public void insertCoin(double coin) {
        this.balance += coin;
        System.out.println("当前余额：" + this.balance);
    }

    @Override
    public void buy(int index) {
        Drink drink = drinks[index - 1];
        if (balance >= drink.getPrice()) {
            System.out.println("购买成功，" + drink.getName() + "，找零：" + (balance - drink.getPrice()));
            balance -= drink.getPrice();
        } else {
            System.out.println("余额不足，请继续投币");
        }
    }
}

public class Drink {

    private String name;
    private double price;

    public Drink(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public double getPrice() {
        return price;
    }
}

public class Coke extends Drink {

    public Coke() {
        super("可乐", 3.0);
    }
}

public class Sprite extends Drink {

    public Sprite() {
        super("雪碧", 2.5);
    }
}

public class MineralWater extends Drink {

    public MineralWater() {
        super("矿泉水", 1.5);
    }
}

在这个示例代码中，我们定义了一个IVendingMachine接口，它包含了所有自动贩卖机的基本功能。然后，我们让VendingMachine类实现了这个接口，以便实现自动贩卖机的功能。同时，Drink类和它的子类也实现了这个接口，以便在需要时扩展自动贩卖机的功能。

使用多态和接口的好处在于，我们可以在不修改原有代码的情况下，扩展自动贩卖机的功能。例如，我们可以定义一个新的子类，代表一种新的饮料种类，然后让它实现IVendingMachine接口，即可将这种新的饮料加入到自动贩卖机中。