顾名思义：对象的类型转换

• 对象的类型转换限制于子类父类之间的转换。
  例如：人这一父类与学生这一子类的相互转换
  但是要明白，不同转型方式会伴随不同的问题产生。
• 先介绍转型类型

向上转型

形式：父类 obj = new 子类() ;
理解为将实例化的子类对象赋值于父类类型变量obj
这就是向上转型操作。
举例：
学生和人，将学生转型为人，这没问题，学生是人

向下转型

形式：子类 obj = new 父类() ;
理解为将实例化的父类对象赋值于子类类型变量obj
但是将人转型为学生，所有人人都是学生。这个说法肯定有问题的。
结论：可实例化的类，父类总是比子类抽象，

但是可以强制类型转换将父类对象转换为子类对象。

两种转型实验分析

完整代码，向下转型

package com.test;
class Person{
	Person(){
		System.out.println("父类构造" + Person.class.hashCode());
		}
	void m(){
		System.out.println("父类m方法执行");
	}
}
class Students extends Person {
	Students(){
			System.out.println("子类构造" + Students.class.hashCode());
	}
	void n(){
		System.out.println("子类n方法执行");
	}
}
public class Test {
	public static void main(String[] args) {										
//		-------------分割-------------- 
		//实例化子类，父类指向
		Person p_2 = new Person();
		//实例化父类，子类指向
		try {
			Students s_2 = (Students)p_2;
			s_2.n();			//强制类型转换了之后再调用子类方法
			s_2.m();			//父类方法调用
		}catch(Exception c){
			c.printStackTrace();
		}					
	}
}

运行结果

部分代码，向上转型：

public class Test {
	public static void main(String[] args) {										
//		-------------分割-------------- 
		//实例化子类，父类指向
		Person p_2 = new Students();
		//实例化父类，子类指向
		Students s_2 = (Students)p_2;
		s_2.n();
		s_2.m();
	}
}

结果

结果分析：

1. 出现了ClassCastException即类强制类型转换异常
   父类虽然强制转换成为了子类，但是在父类与子类的属性、方法体中存在的差异用强制转换是始终解决不了的。由此Java给出了instanceof操作符（见下文）先来判断父子类的对象。
2. 只执行了父类的构造方法，强制类型转换了之后再调用子类方法无效。
3. 向下转型需要谨慎使用
4. 向上转型没出问题，验证子类转型父类（将一个具体的类变得抽象起来，因此这也使得这样的一个类型转换更安全）

Java的多态为何可以由子类实例化父类？: https://www.zhihu.com/tardis/landing/360/ans/573791530?query=Java%E7%9A%84%E5%A4%9A%E6%80%81%E4%B8%BA%E4%BD%95%E5%8F%AF%E4%BB%A5%E7%94%B1&mid=799cee2b148c5e899263e45acac3326e&guid=C17C0F57B580A06F6D196A2D3DFF34FC.1581235349790.

instanceof操作符判断对象类型，为向上转型服务或作单纯判断

用途：判断父类是否为子类对象的实例

语法格式：

某类对象的引用 instanceof 某个类
upobject instanceof ExampleClass
实例：

package com.test;
class Person{
}
class Students extends Person {
}
public class Test {
	public static void main(String[] args){
		Person p_1 = new Person();
		Students s_1 = new Students();
		System.out.println(p_1 instanceof Students);
		System.out.println(s_1 instanceof Person);
	}
}

结果：

Java对象类型转换

对象类型转换，是指存在继承关系的对象，不是任意类型的对象，分别是向上转型（upcasting）和向下 转型（downcasting）。
（1）向上转型：父类引用指向子类对象为向上转型。
1.语法格式如下： fatherClass obj = new sonClass();
·fatherClass 是父类名称或接口名称，obj 是创建的对象，sonClass 是子类名称。
·向上转型就是把子类对象直接赋给父类引用，不用强制转换。
2.使用向上转型可以调用父类类型中的所有成员，不能调用子类类型中特有 成员，最终运行效果看子类的具体实现。
（2）向下转型：与向上转型相反，子类对象指向父类引用为向下转型。
1.语法格式如下：sonClass obj = (sonClass) fatherClass;
fatherClass 是父类名称，obj 是创建的对象，sonClass 是子类名称。
2.向下转型可以调用子类类型中所有的成员，
3.不过需要注意的是如果父类引用对象指向的是子类对象，那么在向下转型 的过程中是安全的也就是编译是不会出错误。
4.但是如果父类引用对象是父类本身，那么在向下转型的过程中是不安全 的，编译不会出错，但是运行时会出现我们开始提到的 Java 强制类型转 换异常，一般使用 instanceof 运算符来避免出此类错误。

例子1:

Father f1 = new Son(); // 这就叫 upcasting （向上转型) 
// 现在f1引用指向一个Son对象 
Son s1 = (Son)f1; // 这就叫 downcasting (向下转型) 
// 现在f1还是指向Son对象 

例子2：

Father f2 = new Father(); 
Son s2 = (Son)f2; // 出错，子类引用不能指向父类对象 

因为f1指向一个子类对象，Father f1 = new Son();
子类s1引用当然可以指向子类对象了。
而f2 被传给了一个Father对象，Father f2 = new Father（）；
子类s1引用不能指向父类对象。

在日常开发时，经常需要将对象从一种类型转换为另一种类型。CLR允许将对象转换为它的（实际）类型或者它的任何基类型。

C#不要求任何特殊语法即可将对象转换为它的任何基类型，因为向基类型的转换被认为是一种安全的隐式转换。然而，将对象转换为它的某个派生类型时，C#要求开发人员只能进行显式转换，因为这种转换可能在运行时失败。可以理解为：父类强制转换成子类,子类隐式转换成父类

    internal class Employee
    {
    }

    class Program
    {
        static void Main(string[] args)
        {
        // 子类隐式转换成父类，不需要转换
        // 因为new返回一个Employee对象，而Object是Employee的基类
        Object o = new Employee();
        // 子类可以自动转父类 可以这么理解把子类的实例em的地址赋值给了o1, o1的地址就是em的地址
        // 这时就可以调用Employee 类的方法，点出Employee 类的属性
        Employee em = new Employee();
        Object o1 = em;

            // 父类强制转换成子类, 需要转换
            // 因为Employee派生自Object
            Employee e = (Employee)o;
        }
    }

在运行时，CLR会检查转型操作，确定总是转换为对象得实际类型或者它的任意类型。下面的代码虽然能通过编译，但会在运行时抛出InvalidCastException异常：

    internal class People
    {
    }

    internal class Employee : People
    {
    }

    internal class Manager : Employee
    {
    }

    class Program
    {
        static void Main(string[] args)
        {
            // 创建实例的时候没有将父类引用到子类对象,是无法转换的
            // PromoteEmployee不能运行成功
            People p = new People();
            PromoteEmployee(p);

            // 创建实例的时候将父类引用到子类对象,是可以转换的
            // PromoteEmployee能运行成功
            People p1 = new Employee();
            PromoteEmployee(p1);

            // Manager"属于"(IS-A)Employee对象
            // PromoteEmployee能运行成功
            Manager m = new Manager();
            PromoteEmployee(m);

            // DateTime不是从Employee派生的
            // PromoteEmployee不能运行成功
            DateTime newYears = new DateTime(2011, 10, 1);
            PromoteEmployee(newYears);
        }

        static void PromoteEmployee(Object o)
        {
            // 编译器在编译时无法准确地获知对象0引用的是什么类型，因此允许代码通过编译
            // 但在运行时，CLR知道了o引用的是什么类型（在每次执行转型的时候）
            // 所以它会核实对象的类型是不是Employee或者从Employee派生的任何类型
            Employee e = (Employee)o;
        }
    }

使用C#的is和as操作符来转型
在C#语言中进行转换的另一种方式是使用is操作符。is检查对象是否兼容于指定类型，返回Boolean值true或false。注意，is操作符永远不抛出异常，例如以下代码：

        static void Main(string[] args)
        {
            Object o = new Object();
            Boolean b1 = (o is Object);    //True
            Boolean b2 = (o is Employee);  //False
            Boolean b3 = (o is Nullable);  //False
        }

is操作符通常像下面这样使用：

        static void Main(string[] args)
        {
            Object o = new Employee();
            if( o is Employee )
            {
                Employee e = (Employee)o;
            }
        }

在上诉代码中，CLR实际检查两次对象类型。is操作符首先核实o是否兼容于Employee类型。如果是，在if语句内部转型时，CLR再次核实o是否引用一个Employee。CLR的类型检查增强了安全性，但无疑会对性能造成一定的影响。这是因为CLR首先必须判断变量(o)引用的对象的实际类型。然后CLR必须遍历继承层次结构，用每个基类型去核对指定的类型（Employee）。由于这是一个相当常用的编程模式，所以C#专门提供了as操作符，目的就是简化这种代码的写法，同时提升其性能。

        static void Main(string[] args)
        {
            Object o = new Employee();
            Employee e = o as Employee;
            if(e != null)
            {

            }
        }

在这段代码中，CLR核实o是否兼容于Employee类型；如果是，as放回对同一个对象的非null引用。如果o不兼容于Employee类型，as返回null。as操作符永远不抛出异常。注意，as操作符造成CLR只校验一次对象类型。if语句只检查e是否为NULL；这个检查的速度不校验对象的类型快得多。

测试代码：

namespace ConsoleApplicationTest
{
    internal class B{}

    internal class D : B{}

    class Program
    {
        static void Main(string[] args)
        {
            Object o1 = new Object(); //OK
            Object o2 = new B(); //OK
            Object o3 = new D(); //OK
            Object o4 = o3; //OK
            B b1 = new B(); //OK
            B b2 = new D(); //OK
            D d1 = new D(); //OK

            B b3 = new Object(); //编译时错误，正确：Object b3 = new B();
            D d2 = new Object(); //编译时错误，正确：Object b3 = new D();

            B b4 = d1; //OK，子类可以自动转父类
            D d3 = b2; //编译时错误，正确：D d3 = (D)b2;
            D d4 = (D)d1; //OK
            D d5 = (D)b2; //OK

            D d6 = (D)b1; //运行时错误，创建实例的时候没有将父类引用到子类对象
            B b5 = (B)o1; //运行时错误，创建实例的时候没有将父类引用到子类对象
            B b6 = (D)b2; //OK，创建实例的时候将父类引用到子类对象
        }
    }
}