向上转型和向下转型

向上转型和向下转型的利弊

一、向上转型
好处：隐藏了子类型，提高了代码的扩展性。
坏处：只能使用父类的功能，不能使用子类特有功能，功能被限定。
使用场景：不需要面对子类型，通过提高扩展性，或者使用父类的功能即可完成操作，就是使用向上转型。
二、向下转型
好处:可以使用子类型的特有功能
坏处:面对具体的子类型，向下转型具有风险。即容易发生ClassCastException，只要转换类型和对象不匹配就会发生。解决方法：使用关键字instanceof。

C#篇

向上转型&&向下转型

• 向上转型：子类对象赋给父类，转型成功
• 向下转型：父类对象赋给子类，要注意类型匹不匹配的问题，容易出错，转化失败对象值为null

using System;
using System.CodeDom;
using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Linq;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Threading.Tasks;
 
namespace _TBD_2020814Test
{
    class Animal { }
    class Cat : Animal{}
    class Dog : Animal { }
    class Hashiqi : Dog { }
    class Program
    {
        static void Main(string[] args)
        {
            //向上转型（子类->父类）转型成功
            //狗是动物，
            Animal a = new Dog();
            Dog d0 = a as Dog;
            Console.WriteLine(d0);//dog
 
            //进来一只狗，不认识说他是一只动物，属于向上转型
            //然后再对它说它是一只狗
            //因为本来就是一只狗，所以没问题
 
            //向下转型（父类->子类）转型失败输出null
            // Dog d1 = (Dog)new Animal();
            // Console.WriteLine(d1);异常
            Dog d2 = new Animal() as Dog;//动物被叫做狗
            Console.WriteLine(d2);//null
           //向下转型要注意类型匹不匹配的问题
           //一只猫也是一只动物，硬性被说是狗，就会发生错误
 
        }
    }
}

示范代码：

using System;
using System.CodeDom;
using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Linq;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Threading.Tasks;
 
namespace _TBD_2020814Test
{
    class Animal { }
    class Cat : Animal { }
    class Dog : Animal { }
    class Hashiqi : Dog { }
    class Program
    {
        static void Main(string[] args)
        {
            //向下转型（父类->子类）转型失败输出null
            //错误示范
            Animal a = new Animal();
            Dog d2 =a as Dog;
            Console.WriteLine(d2 is Dog);//false
            Console.WriteLine(d2==null);//true
 
 
            //正确示范
            Animal a1 = new Dog();
            Dog d = a1 as Dog;
            Console.WriteLine(d is Dog);//True
            Console.WriteLine(d == null);//False
        }
    }
}

注意：
向上转型后，子类不能使用原来子类中特有的字段，

向下转型后，父类可以使用子类中特有的字段，注意有没有异常，可以用is判断

关键字as+is

• as强制类型转换
• is判断数据类型

代码示例：

using System;
using System.CodeDom;
using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Linq;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Threading.Tasks;
 
namespace _TBD_2020814Test
{
    class Animal {
        public string name;
        public int age;
    }
    class Dog : Animal {
        public char gender;
    }
    class Hashiqi : Dog {
        public string kind;
    }
    class Monkey : Animal{ }
    class Lion : Animal { }
    class Tiger : Animal { }
 
    class Program
    {
        static void Main(string[] args)
        {
            //实例化一个Dog对象
            Dog d = new Dog();
            d.name = "";
            d.age = 3;
            d.gender = 'f';
 
            //向上转型(狗赋值给动物)
            Animal a = d;
            a.name = "";
            a.age = 1;
            //a.gender = 'f';狗的gender字段不能使用
 
            
            Dog dd = a as Dog;//a本来就是狗，所以狗的gender可以使用
            dd.gender = 'f';
 
            //向下转型（把狗赋值给哈士奇）
            /*
             Hashiqi h = a as Hashiqi;//null
            h.kind = "";//异常
             */
            RecordAnimal(new Hashiqi());
 
        }
        public static void RecordAnimal(Animal a) { 
        //如果是哈士奇，打印
        if(a is Hashiqi)//is关键字
            {
                Console.WriteLine("本园不收哈士奇！！！");
            }
        }
    }
}

基础知识

Java中的继承机制使得一个类可以继承另一个类，继承的类称为子类，被继承的类称为父类。在一个子类被创建的时候，首先会在内存中创建一个父类对象，然后在父类对象外部放上子类独有的属性，两者合起来形成一个子类的对象，所以子类可以继承父类中所有的属性和方法，包括private修饰的属性和方法，但是子类只是拥有父类private修饰的属性和方法，却不能直接使用它，也就是无法直接访问到它（子类可以通过调用父类的public声明的get方法来获取父类的private属性，但无法访问父类的private方法）。同时子类可以对继承的方法进行重写（@Override），并且新建自己独有的方法。

Java篇

1.向上转型：

假设有一个Fruit类，Fruit类中有一个show（）方法，代码如下：

class Fruit{
	public void show() {
		System.out.println("this is a fruit");
	}
}

有一个Apple类继承自Fruit类，该类有自己的方法test（），并且重写了父类的show（）方法，代码如下：

class Apple extends Fruit{
    @Override
    public void show() {
	System.out.println("this is a apple");
    }
    public void test() {
	System.out.println("i am a apple");
    }
}

实例化Apple类，并新建一个Fruit类的引用变量引用该实例，调用实例的show（）方法：

Fruit fruit = new Apple();
fruit.show();

结果为：

调用实例的test（）方法：

fruit.test();

结果报错：

分析：

这里用到了向上转型，换言之，就是用父类的引用变量去引用子类的实例，这是允许的。当向上转型之后，父类引用变量可以访问子类中属于父类的属性和方法，但是不能访问子类独有的属性和方法。例子中由于子类重写了父类的show（）方法，所以调用的show（）方法是子类的show（）方法，输出结果为：“this is a apple”,而调用子类的test（）方法则会报错。
2.向下转型

并不是所有的对象都可以向下转型，只有当这个对象原本就是子类对象通过向上转型得到的时候才能够成功转型。

实例化Apple类，并新建一个Fruit类的引用变量“fruit”引用该实例，然后新建一个Apple类的引用变量，引用向下转型的“fruit”变量，代码如下：

Fruit fruit = new Apple();
Apple apple = (Apple) fruit;

上述代码是允许的，因为fruit引用的对象原本就是Apple对象向上转型得到的，在对fruit向下转型后得到的还是Apple类的对象，能够被Apple类的引用变量引用。

假设有一个Orange类继承自Fruit类，代码如下：

class Orange extends Fruit{
    @Override
    public void show() {
	System.out.println("this is a Orange");
    }
    public void test() {
	System.out.println("i am a Orange");
    }
}

实例化Apple类，并新建一个Fruit类的引用变量“fruit”引用该实例，然后新建一个Orange类的引用变量，引用向下转型的“fruit”变量，代码如下：

Fruit fruit = new Apple();
Orange orange = (Orange) fruit;

上述代码虽然能够编译成功，但是在运行的时候会报错，因为fruit对象是由Apple对象向上转型得到的，只能够向下转型成Apple对象，不能够向下转型成Orange对象。

3.转型的好处

通过向上向下转型肯定是有好处的，比如可以减少编程代码。

假设在主类中定义了一个run（）方法，该方法传入一个Fruit参数，并调用了Fruit对象的show（）方法，代码如下：

public static void run(Fruit fruit) {
	fruit.show();
   }

在main（）方法中的代码如下：

public static void main(String[] args) {
    run(new Fruit());
    run(new Apple());
    run(new Orange());
    }

上述代码中，调用run（）方法时的参数不仅是Fruit对象，也可以是Apple对象和Orange对象，当传入的是Apple对象和Orange对象时，就会向上转型成Fruit对象，但是调用的show（）方法还是Apple对象和Orange对象的show（）方法。这样就不需要在主类中同时重载三个run（）方法，减少了代码量。

源自

C#学习-多态(向上转型&&向下转型&&as关键字&&is关键字)

Java对象类型向上转型和向下转型