java多态概念 举例说明

多态是指同一个方法调用，由于对象不同可能会产生不同的行为。举一个简单的例子，比如有一个Animal类，有一个speak()方法，而Dog和Cat是Animal的子类，它们分别重写了speak()方法，当我们调用speak()方法时，具体执行哪个方法取决于当前的对象类型：

Animal a = new Animal();
a.speak(); // 执行Animal类中的speak()方法

Animal b = new Dog();
b.speak(); // 执行Dog类中重写过的speak()方法

Animal c = new Cat();
c.speak(); // 执行Cat类中重写过的speak()方法

由于Dog和Cat都是Animal的子类，它们也都继承了Animal类中的speak()方法，但是它们分别重写了speak()方法，因此当我们以Animal类型声明的对象调用speak()方法时，执行哪个方法将根据当前对象的实际类型来确定，这就是多态。

相关问题

什么是多态？请举例说明

多态是面向对象编程中的一个重要概念，指同一种行为具有多种不同表现形式或形态的能力。简单来说，就是同一个方法调用可以有不同的执行结果。

举个例子，我们可以定义一个“动物”类，其中有一个“叫声”方法。然后再定义不同的子类，如“狗”、“猫”、“鸟”等，它们都继承了“动物”类，并对“叫声”方法进行了不同的实现。接着我们可以创建一个“动物”类型的变量，通过不同的赋值来调用不同的子类实现的“叫声”方法，这就是多态的体现。

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

class Animal {
    public void makeSound() {
        System.out.println("动物发出叫声");
    }
}

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

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

public class PolymorphismDemo {
    public static void main(String[] args) {
        Animal animal1 = new Dog();
        Animal animal2 = new Cat();
        animal1.makeSound(); // 输出：汪汪汪
        animal2.makeSound(); // 输出：喵喵喵
    }
}

在上面的代码中，我们先定义了一个“动物”类，其中有一个“叫声”方法。然后又定义了“狗”和“猫”两个子类，它们都重写了“叫声”方法。最后在主方法中，我们创建了两个“动物”类型的变量，分别赋值为“狗”和“猫”类的实例。当调用它们的“叫声”方法时，实际执行的是各自重写的方法，而不是“动物”类中定义的方法。这就是多态的体现。

举例说明多态的用法

多态是面向对象编程中的一个重要概念，它允许不同的对象对同一消息做出不同的响应。在Java中，多态有多种实现方式，其中最常见的是方法重载和方法覆盖。

方法重载是指在同一个类中定义多个同名的方法，但是它们的参数列表不同。这样做的好处是可以根据不同的参数类型和个数来调用不同的方法。下面是一个方法重载的例子：

public class Demo {
    public int add(int a, int b) {
        return a + b;
    }
    public double add(double a, double b) {
        return a + b;
    }
    public static void main(String[] args) {
        Demo demo = new Demo();
        int result1 = demo.add(1, 2);
        double result2 = demo.add(1.0, 2.0);
        System.out.println(result1);    // 输出3
        System.out.println(result2);    // 输出3.0
    }
}

方法覆盖是指子类覆盖了父类中的同名方法，但是方法的参数列表和返回值类型必须相同。这样做的好处是可以根据对象的实际类型来调用相应的方法。下面是一个方法覆盖的例子：

public class Animal {
    public void sound() {
        System.out.println("Animal makes sound");
    }
}
public class Dog extends Animal {
    public void sound() {
        System.out.println("Dog barks");
    }
}
public class Cat extends Animal {
    public void sound() {
        System.out.println("Cat meows");
    }
}
public class Demo {
    public static void main(String[] args) {
        Animal animal1 = new Dog();
        Animal animal2 = new Cat();
        animal1.sound();    // 输出Dog barks
        animal2.sound();    // 输出Cat meows
    }
}

在这个例子中，Animal类有一个sound()方法，它被子类Dog和Cat覆盖了。在main()方法中，分别创建了一个Dog对象和一个Cat对象，并将它们赋值给Animal类型的变量。由于animal1的实际类型是Dog，调用它的sound()方法时会执行Dog类中的sound()方法；同理，animal2的实际类型是Cat，调用它的sound()方法时会执行Cat类中的sound()方法。

这就是多态的用法，它可以让我们编写出更加灵活和可扩展的代码。