1.向上转型
 
向上转型是指父类引用子类对象，就是子类对象能转换成父类对象。
 
假设有父类Person类对象p和子类Student对象s，则
 
Person p;
p=new Student();	//父类Person对象p引用子类Student新创建的对象
Student s=new Student();
p=s;				//父类Person对象p引用子类Student对象s
也可以直接写成：
Person p=new Student();//父类Person对象p引用子类Student新创建的对象
 
当子类对象s赋给父类对象p时，是隐式转换，不用进行强制类型转换。对于上述例子，父类引用子类对象后只能引用父类中的成员变量和方法，而不能访问子类自己定义的成员变量和成员方法。
 
所以综上所述向上转型的特点如下：
 
（1）向上转型对象不能操作子类新增的成员变量（失掉了这部分属性），不能使用子类新增的方法（失掉了一些功能）。
 
（2）向上转型对象可以操作子类继承或重写的成员变量，也可以使用子类继承的或重写的方法。
 
（3）如果子类重写了父类的某个方法后，当对象的向上转型对象调用这个方法时一定是调用了这个重写的方法，因为程序在运行时知道，这个向上转型对象的实体是子类创建的，只不过损失了一些功能而已。
 
（4）对象的向上转型对象再强制转换到该子类的一个对象，这时又具备了子类所有的属性和功能。
 
2.向下转型
 
向下转型是指子类引用父类对象，就是将父类对象能转换成子类对象，这时需要满足两个条件：一是必须执行强制类型转换；二是必须确保父类对象是子类的一个实例，否则抛出异常。
 
假设有父类Person类对象p和子类Student对象s
 
由于Student是Person的子类，下列语句是正确的：
 
Person p=new Student();//父类Person对象p引用子类Student的对象
Student s=(Student)p;	//父类对象p赋给子类对象s，当前p是子类Student的引用
 
但是，下列语句有错误：
 
Person p=new Person();//父类对象p引用父类Person的对象
Student s=(Student)p;	//父类对象p不能赋给子类对象s，因为当前p不是子类的引用
 
上述代码尽管能通过编译，但运行时将抛出ClassCastException异常，强制转换无法实现。
 
所以综上所述向下转型的特点如下：
 
（1）向下转型对象可以操作父类及子类成员变量和成员方法。
 
（2）向下转型对象访问重写父类的方法时，操作的是子类的方法。
 
（3）向下转型必须进行强制类型转换。
 
（4）向下转型必须保证父类对象引用的是该子类的对象，如果引用的是父类的其他子类对象，会抛出类型不匹配异常。
 
3.instanceof运算符
 
父类对象能转换成子类对象的条件是父类对象原本就是子类的实例。为了确保向下转型时，父类对象引用的是子类的对象，引入instanceof运算，该运算符用来判断该引用变量是否属于该类或该类的子类。
 
instanceof运算的格式为：
 
引用变量名 instanceof 类名
 
如果该引用变量引用的是这个类的对象，或这个类的子类的对象，则运算结果为true；否则为false。
 
 

在日常开发时，经常需要将对象从一种类型转换为另一种类型。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，创建实例的时候将父类引用到子类对象
        }
    }
}

Java 语言允许某个类型的引用变量引用子类的实例，而且可以对这个引用变量进行类型转换。如果把引用类型转换为子类类型，则称为向下转型；如果把引用类型转换为父类类型，则称为向上转型。
 例如，Creature 类表示生物类，Animal 类表示动物类，该类对应的子类有 Dog 类，使用对象类型表示如下：
 
 
 
Animal animal=new Dog();
Dogdog=(Dog)animal;    //向下转型，把Animal类型转换为Dog类型
Creature creature=animal;    //向上转型，把Animal类型转换为Creature类型
 
 
例 1
 
下面通过具体的示例演示对象类型的转换。例如，父类 Animal 和子类 Cat 中都定义了实例变量 name、静态变量 staticName、实例方法 eat() 和静态方法 staticEat()。此外，子类 Cat 中还定义了实例变量 str 和实例方法 dogMethod()。
 父类 Animal 的代码如下：
 
 
 
public class Animal
{
    public String name="Animal：动物";
    public static String staticName="Animal：可爱的动物";
    public void eat()
    {
        System.out.println("Animal：吃饭");
    }
    public static void staticEat()
    {
        System.out.println("Animal：动物在吃饭");
    }
}
 
 

 子类 Cat 的代码如下：
 
 
 
public class Cat extends Animal
{
    public String name="Cat：猫";
    public String str="Cat：可爱的小猫";
    public static String staticName="Dog：我是喵星人";
    public void eat()
    {
        System.out.println("Cat：吃饭");
    }
    public static void staticEat()
    {
        System.out.println("Cat：猫在吃饭");
    }
    public void eatMethod()
    {
        System.out.println("Cat：猫喜欢吃鱼");
    }
    public static void main(String[] args)
    {
        Animal animal=new Cat();
        Cat cat=(Cat)animal;    //向下转型
        System.out.println(animal.name);    //输出Animal类的name变量
        System.out.println(animal.staticName);    // 输出Animal类的staticName变量
        animal.eat();    //输出Cat类的eat()方法
        animal.staticEat();    //输出Animal类的staticEat()方法
        System.out.println(cat.str);    //调用Cat类的str变量
        cat.eatMethod();    //调用Cat类的eatMethod()方法
    }
}
 
 
通过引用类型变量来访问所引用对象的属性和方法时，Java 虚拟机将采用以下绑定规则：
 
实例方法与引用变量实际引用的对象的方法进行绑定，这种绑定属于动态绑定，因为是在运行时由 Java 虚拟机动态决定的。例如，animal.eat() 是将 eat() 方法与 Cat 类绑定。
静态方法与引用变量所声明的类型的方法绑定，这种绑定属于静态绑定，因为是在编译阶段已经做了绑定。例如，animal.staticEat() 是将 staticEat() 方法与 Animal 类进行绑定。
成员变量（包括静态变量和实例变量）与引用变量所声明的类型的成员变量绑定，这种绑定属于静态绑定，因为在编译阶段已经做了绑定。例如， animal.name 和 animal.staticName 都是与 Animal 类进行绑定。
对于 Cat 类，运行时将会输出如下结果：
 
 
 
Animal：动物
Animal：可爱的动物
Cat：吃饭
Animal：动物在吃饭
Cat：可爱的小猫
Cat：猫喜欢吃鱼
 
 
强制对象类型转换
 
Java 编译器允许在具有直接或间接继承关系的类之间进行类型转换。对于向下转型，必须进行强制类型转换；对于向上转型，不必使用强制类型转换。
 
例如，对于一个引用类型的变量，Java 编译器按照它声明的类型来处理。如果使用 animal 调用 str 和 eatMethod() 方法将会出错，如下：
 
 
animal.str=""; //编译出错，提示Animal类中没有str属性
 
 
animal.eatMethod(); //编译出错，提示Animal类中没有eatMethod()方法
 
 
 
 
如果要访问 Cat 类的成员，必须通过强制类型转换，如下：
 
 
((Cat)animal).str=""; //编译成功
 
 
((Cat)animal).eatMethod(); //编译成功
 
 
 
 
把 Animal 对象类型强制转换为 Cat 对象类型，这时上面两句编译成功。对于如下语句，由于使用了强制类型转换，所以也会编译成功，例如：
 
 
Cat cat=(Cat)animal; //编译成功，将Animal对象类型强制转换为Cat对象类型
 
 
 
 
子类的对象可以转换成父类类型，而父类的对象实际上无法转换为子类类型。因为通俗地讲，父类拥有的成员子类肯定也有，而子类拥有的成员，父类不一定有。因此，对于向上转型，不必使用强制类型转换。例如：
 
 
Cat cat=new Cat();
 
 
Animal animal=cat; //向上转型，不必使用强制类型转换
 
 
 
 
如果两种类型之间没有继承关系，那么将不允许进行类型转换。例如：
 
 
Dog dog=new Dog();
 
 
Cat cat=(Cat)dog; //编译出错，不允许把Dog对象类型转换为Cat对象类型
 
 
 
 

关于对象类型转换为数组类型的问题。下面的代码一致想不通。
 

 
 

<?php 
/**
2016年10月7日11:12:20
对象类型转化成数组类型
匪夷所思
**/

class A{
	private $A = 'a';
}


class B extends A{
	private $A = 'b';
	public $AA = 'c';
}


$b = new B();
print_r((array)$b);
/*
	Array
	(
	    [BA] => b
	    [AA] => c
	    [AA] => a
	)
*/