子类继承父类后实例化子类后 父类的构造函数是否也执行了 举例
时间: 2023-09-30 09:01:47 浏览: 42
当子类继承父类后,如果子类没有显式地定义构造函数,则会默认继承父类的构造函数。因此,在实例化子类时,父类的构造函数也会被执行。下面是一个简单的 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
```
相关问题
子类继承父类后实例化子类后 父类的构造函数是否也执行了 C++举例
在 C++ 中,当一个子类继承了父类后,实例化子类时,父类的构造函数会被自动调用。可以通过在子类构造函数中显式地调用父类构造函数来传递参数或执行额外的初始化操作。下面是一个简单的示例代码:
```
#include <iostream>
using namespace std;
class Parent {
public:
Parent() {
cout << "Parent constructor called." << endl;
}
};
class Child : public Parent {
public:
Child() {
cout << "Child constructor called." << endl;
}
};
int main() {
Child c;
return 0;
}
```
输出结果为:
```
Parent constructor called.
Child constructor called.
```
可以看到,当实例化 Child 类时,先调用了父类 Parent 的构造函数,再调用了子类 Child 的构造函数。
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"。
```java
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父类:
```java
public class Animal {
public void move() {
System.out.println("动物可以移动");
}
}
```
然后,我们定义两个子类Cat和Dog,分别继承自Animal:
```java
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,并调用它们各自独有的方法:
```java
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的对象,并调用了它们各自特有的方法。这就是使用父类实例化子类的一个典型例子。