用例子在Java中向上转型

继承是OOP（面向对象编程）的重要支柱。它是Java中允许一个类继承另一个类的特性（字段和方法）的机制。

有两种方法可以在继承父类和子类的属性的同时初始化对象。他们是：

Child c = new Child()：此初始化的用途是访问父类和子类中存在的所有成员，因为我们正在继承属性。
Parent p = new Child()：这种类型的初始化仅用于访问父类中存在的成员以及在子类中被覆盖的方法。这是因为父类向上转换为子类。

什么是上调？
向上转换是将子对象类型转换为父对象。向上转型可以隐式完成。 Upcasting 使我们可以灵活地访问父类成员，但不可能使用此功能访问所有子类成员。我们可以访问子类的一些指定成员，而不是所有成员。例如，我们可以访问被覆盖的方法。

示例：假设有一个动物类。可以有许多不同类别的动物。一类是Fish 。所以，让我们假设fish 类扩展了 Animal 类。因此，在这种情况下，两种继承方式实现为：

让我们了解以下代码以找出区别：

// Java program to demonstrate
// the concept of upcasting
  
// Animal Class
class Animal {
  
    String name;
  
    // A method to print the
    // nature of the class
    void nature()
    {
        System.out.println("Animal");
    }
}
  
// A Fish class which extends the
// animal class
class Fish extends Animal {
  
    String color;
  
    // Overriding the method to
    // print the nature of the class
    @Override
    void nature()
    {
        System.out.println("Aquatic Animal");
    }
}
  
// Demo class to understand
// the concept of upcasting
public class GFG {
  
    // Driver code
    public static void main(String[] args)
    {
        // Creating an object to represent
        // Parent p = new Child();
        Animal a = new Fish();
  
        // The object 'a' has access to
        // only the parent's properties.
        // That is, the colour property
        // cannot be accessed from 'a'
        a.name = "GoldFish";
  
        // This statement throws
        // a compile-time error
        // a.color = "Orange";
  
        // Creating an object to represent
        // Child c = new Child();
        Fish f = new Fish();
  
        // The object 'f' has access to
        // all the parent's properties
        // along with the child's properties.
        // That is, the colour property can
        // also be accessed from 'f'
        f.name = "Whale";
        f.color = "Blue";
  
        // Printing the 'a' properties
        System.out.println("Object a");
        System.out.println("Name: " + a.name);
  
        // This statement will not work
        // System.out.println("Fish1 Color" +a.color);
  
        // Access to child class - overriden method
        // using parent reference
        a.nature();
  
        // Printing the 'f' properties
        System.out.println("Object f");
        System.out.println("Name: " + f.name);
        System.out.println("Color: " + f.color);
        f.nature();
    }
}

输出：

Object a
Name: GoldFish
Aquatic Animal
Object f
Name: Whale
Color: Blue
Aquatic Animal

程序示意图：

从上面的例子可以清楚地看出，我们不能使用父类引用访问子类成员，即使它是子类型。那是：
```
// This statement throws
// a compile-time error
a.color = "Orange";
```
从上面的例子中，我们还可以观察到，我们可以使用同一个父类引用对象来访问父类成员和子类的重写方法。那是：
```
// Access to child class
// overridden method 
a.nature();
```
因此，我们可以得出结论，使用这两种不同语法的主要目的是在访问类中的各个成员时获得变化。