举一个用父类实例化子类的例子

假设有一个 `Animal`（动物）的父类，里面有一个 `speak`（说话）的方法。现在有一个 `Dog`（狗）的子类，继承自 `Animal` 父类，并且增加了一个 `bark`（叫）的方法。

可以通过实例化 `Dog` 子类来调用 `speak` 方法，因为 `Dog` 子类继承了 `Animal` 父类的所有方法和属性。

以下是一个用父类实例化子类的例子：

class Animal:
    def speak(self):
        print("Animal is speaking.")

class Dog(Animal):
    def bark(self):
        print("Dog is barking.")

my_dog = Dog()
my_dog.speak()  # 调用父类方法
my_dog.bark()   # 调用子类方法

输出结果：

Animal is speaking.
Dog is barking.

相关问题

Java语言举一个用父类实例化子类的例子

### 回答1：
假设有一个父类Animal和两个子类Dog和Cat，可以通过以下代码示例使用父类实例化子类：

Animal animal1 = new Dog(); // 使用父类Animal实例化子类Dog
Animal animal2 = new Cat(); // 使用父类Animal实例化子类Cat

在上述代码中，我们使用Animal类来实例化Dog和Cat子类。由于Dog和Cat都是Animal的子类，因此可以使用Animal类型的变量来引用这些子类的实例。这种方式称为多态。

### 回答2：
一个Java语言中用父类实例化子类的例子可以是：

假设有一个动物类Animal，有两个子类Cat和Dog，都继承自Animal类。在Animal类中定义了一个名为"animalSound()"的方法，该方法用于输出动物的叫声。在Cat类中重写了"animalSound()"方法，输出的是猫咪的叫声"Meow"，而在Dog类中也重写了该方法，输出的是狗狗的叫声"Woof"。

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

class Cat extends Animal {
  @Override
  public void animalSound() {
    System.out.println("猫咪发出叫声：Meow");
  }
}

class Dog extends Animal {
  @Override
  public void animalSound() {
    System.out.println("狗狗发出叫声：Woof");
  }
}

public class Main {
  public static void main(String[] args) {
    Animal animal1 = new Cat(); // 父类实例化子类
    Animal animal2 = new Dog(); // 父类实例化子类

    animal1.animalSound(); // 输出：猫咪发出叫声：Meow
    animal2.animalSound(); // 输出：狗狗发出叫声：Woof
  }
}

在这个例子中，通过Animal类来创建了一个Cat对象和一个Dog对象。尽管使用了父类Animal的类型来声明这两个对象，但实际上它们都是子类的实例。当调用animalSound()方法时，实际上会根据对象的实际类型来执行相应的方法。因此，animal1.animalSound()输出的是猫咪的叫声"Meow"，而animal2.animalSound()输出的是狗狗的叫声"Woof"。这体现了多态性的概念，即可以使用父类的类型来引用子类的对象，实现了代码的灵活性和可扩展性。

### 回答3：
Java语言中，通过使用父类实例化子类是一个多态性的例子。多态性是面向对象编程中的一种特性，使得一个变量可以以不同的方式引用不同的对象，实现了代码的灵活性和可扩展性。

比如，假设有一个父类Animal和它的两个子类Cat和Dog，它们都拥有独特的行为和特征。我们可以通过使用父类实例化子类的方式来体现多态性。

首先，我们定义一个Animal父类：

public class Animal {
    public void move() {
        System.out.println("动物可以移动");
    }
}

然后，我们定义两个子类Cat和Dog，分别继承自Animal：

public class Cat extends Animal {
    @Override
    public void move() {
        System.out.println("猫可以走和跳");
    }
    
    public void purr() {
        System.out.println("猫可以发出呜咪呜咪的声音");
    }
}

public class Dog extends Animal {
    @Override
    public void move() {
        System.out.println("狗可以行走和奔跑");
    }
    
    public void bark() {
        System.out.println("狗可以发出汪汪的声音");
    }
}

最后，我们可以通过父类Animal来实例化子类Cat和Dog，并调用它们各自独有的方法：

public class Main {
    public static void main(String[] args) {
        Animal animal1 = new Cat();
        Animal animal2 = new Dog();
        
        animal1.move();  // 输出结果：猫可以走和跳
        ((Cat) animal1).purr();  // 输出结果：猫可以发出呜咪呜咪的声音
        
        animal2.move();  // 输出结果：狗可以行走和奔跑
        ((Dog) animal2).bark();  // 输出结果：狗可以发出汪汪的声音
    }
}

以上示例中，我们利用父类Animal实例化了子类Cat和Dog的对象，并调用了它们各自特有的方法。这就是使用父类实例化子类的一个典型例子。

子类继承父类后实例化子类后 父类的构造函数是否也执行了 举例

当子类继承父类后，如果子类没有显式地定义构造函数，则会默认继承父类的构造函数。因此，在实例化子类时，父类的构造函数也会被执行。下面是一个简单的 Python 代码示例：

class Parent:
    def __init__(self):
        print("Parent's constructor")

class Child(Parent):
    def __init__(self):
        print("Child's constructor")
        super().__init__()

c = Child()

在这个例子中，`Child` 类继承自 `Parent` 类，它定义了一个自己的构造函数并在其中调用了 `super().__init__()` 方法来显式调用父类的构造函数。当我们实例化 `Child` 类时，会先执行 `Child` 类的构造函数，然后再执行 `Parent` 类的构造函数，输出结果为：

Child's constructor
Parent's constructor