Java中多态中父类指向子类对象后怎么调用父类中的方法

在 Java 中，如果一个父类的引用指向了一个子类的对象，你可以通过这个引用来调用父类中的方法。

例如：

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

class Dog extends Animal {
  public void move() {
    System.out.println("狗可以跑和走");
  }
  public void bark() {
    System.out.println("狗可以叫");
  }
}

public class Test {
  public static void main(String[] args) {
    Animal a = new Dog();
    a.move(); // 输出 "狗可以跑和走"
  }
}

在这个例子中，我们创建了一个 `Dog` 类，它继承了 `Animal` 类，并重写了 `move` 方法。我们创建了一个 `Dog` 类的实例，并将它赋值给一个 `Animal` 类的引用。当我们调用 `a.move()` 时，Java 会去调用子类中重写的 `move` 方法，输出 "狗可以跑和走"。

注意：如果你想调用父类中没有被子类重写的方法，你可以使用 `super` 关键字来调用父类中的方法。例如，你可以在子类中使用 `super.move()` 来调用父类中的 `move` 方法。

相关问题

多态为什么要有父类引用指向子类对象

### Java 多态机制解析

在Java中，父类引用指向子类对象的现象体现了多态的核心概念。这种设计模式不仅增强了代码的灵活性和可扩展性，还简化了复杂系统的维护工作。

#### 实现原理

为了实现这一功能，需满足以下几个条件：

- **继承关系**：必须有一个类（子类）继承自另一个类（父类），这是构建层次结构的基础[^1]。

- **方法重写**：子类能够重新定义来自父类的方法行为，这为不同类型的对象提供了特定的行为方式[^3]。

- **向上转型**：通过将子类实例赋给父类类型变量完成自动转换过程，在此过程中虽然只保留了共同接口部分的功能访问权限，但却不影响内部实际执行逻辑的选择依据——即运行时刻的对象真实身份决定具体调用哪个版本的方法实现[^2]。

#### 动态绑定机制

Java采用动态方法分派技术来支持上述特性。这意味着即使是在编译阶段确定下来的静态类型信息指示应调用某个类别的成员函数，但在真正发生调用时会根据当前实例所属的确切类别去寻找最合适的那个覆写的版本并加以执行[^4]。

class Animal {
    public void makeSound() {
        System.out.println("Some generic animal sound");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Bark!");
    }

    // 特有方法
    public void fetchStick(){
        System.out.println("Fetching stick...");
    }
}

当创建`Dog`对象并通过其父类`Animal`类型的引用来操作时：

public class Main {
    public static void main(String[] args) {
        Animal myPet = new Dog();
        myPet.makeSound();  // 输出 "Bark!"
        
        ((Dog)myPet).fetchStick(); // 需要强制类型转换才能调用特有方法
    }
}

注意，如果尝试直接经由`Animal`类型的引用调用仅存在于`Dog`中的额外方法，则会导致编译错误，因为这些方法不属于该引用所声明的数据类型的一部分[^5]。

java父类指针指向子类对象

### Java 中父类引用指向子类对象的用法和原理

#### 用法与原理说明

当使用父类类型的引用指向子类的对象时，实际上是在利用Java中的多态特性。在这种情况下，虽然通过父类引用访问方法，但如果这些方法在子类中有相应的覆盖版本，则会调用子类的方法而非父类的方法[^1]。

然而需要注意的是，对于静态方法而言，即使存在同名的情况也不会发生类似的动态绑定过程——即不会表现出多态的行为模式。因为静态方法属于类本身而不是实例的一部分，所以即便子类定义了相同签名的静态方法也只是简单地遮蔽掉了来自超类的那个版本而已。

为了更好地理解这一点，下面给出一段简单的代码示例：

class Animal {
    public void sound() {
        System.out.println("Animal makes a sound");
    }
    
    public static void staticMethod(){
        System.out.println("Static method from Animal class.");
    }
}

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

    // 静态方法不是重载而是隐藏
    public static void staticMethod(){
        System.out.println("Static method overridden in Dog class.");
    }
}

接着可以通过如下方式测试上述逻辑:

public class TestPolymorphism {

    public static void main(String[] args){
        
        // 创建不同类型的引用并赋值给相应对象
        Animal myPet = new Dog();
        Animal anotherPet = new Animal();

        // 调用非静态方法展示多态效果
        myPet.sound();          // 输出 "Dog barks!"
        anotherPet.sound();     // 输出 "Animal makes a sound"

        // 测试静态方法的表现形式
        myPet.staticMethod();   // 输出 "Static method from Animal class."
                                // 尽管myPet实际上是Dog类型,
                                // 但由于staticMethod是静态方法，
                                // 所以其行为取决于声明类型(这里是Animal),
                                // 并不体现多态特征。
    }
}

这段例子清晰展示了如何运用父类引用来操作具体的子类实体，并且解释了为什么某些情形下（比如涉及静态成员）无法观察到预期之外的变化。

#### 使用场景分析

此类机制广泛应用于框架设计以及任何需要延迟决策的应用场合之中。例如，在图形界面库中可能有一个`Shape`基类及其多个派生出来的具体形状如圆形(`Circle`)、矩形(`Rectangle`)等；又或者是游戏开发里角色的动作处理等等都可以借助于这样的结构来简化编码流程的同时增强灵活性。

#### 注意事项提示

- **编译期 vs 运行期**: 编译器只关心变量声明的数据类型而忽略了实际所指代的具体类别。因此只有那些被标记为virtual或者override的关键字修饰过的成员函数才会参与后期绑定的过程。

- **构造函数不可覆写**: 构造函数并不支持继承或覆盖的概念，这意味着即使是子类也不能改变其直接上级所提供的初始化逻辑。

- **final关键字的影响**: 如果某个类或者方法被指定成最终(final)，则不允许其他地方对其进行进一步拓展或是重新定义，这自然也就排除在外谈不上所谓的“多态”。