类型转换

--》隐式转换不需要在代码中指定转换类型
例如：
int intNumber = 10;
double doubleNumber = intNumber;
intNumber 会被隐式转换成 double类型。
--》显式转换则相反，需要指定转换类型
例如：
double doubleNumber = 10.1;
int intNumber = (int)doubleNumber;
--》对于表示数值的基本数据类型来说，数值范围小的数据类型转换成数值范围大的数据类型可以进行隐式转换，而反过来则必须进行显示转换。
--》对于类类型来说，子类转换成父类（向上转型）可以进行隐式转换，而父类转换为子类（向下转型）则必须进行显式转换。（存在约束条件，因为显式转换可能会导致数据出错，或者转换失败，甚至无法编译成功。）
C# 隐式转换例子：

namespace TypeConvertion{   class Class1    {    }    class Class2 : Class1 //类Class2是类Class1的子类    {    }    class Program    {        static void Main(string[] args)        {            int inum = 100;            long lnum = inum; // 进行了隐式转换，将 int 型（数据范围小）数据转换为了 long 型（数据范围大）的数据            Class1 c1 = new Class2(); // 这里也是隐式转换，将一个新建的 Class2 实例转换为了其基类 Class1 类型的实例 C1        }    }}

子类转换成父类：可以。  
父类转换成子类：不可以。
但如果父类对象的引用指向的实际是一个子类的对象，那么父类对象的引用可以强制转化成子类对象的引用。如：   
  Parent   p=new   Son()   //向上转型
  Son   s=(Son)p;          //向下转型
--正确
  Parent   p=new   Parent()   
  Son   s=(Son)p;  --错误
 向上转型就是父类的引用指向子类的实例。
父类引用指向子类对象指的是：
例如父类Animal，子类Cat。其中Animal可以是类也可以是接口，Cat是继承或实现Animal的子类。
Animal animal = new Cat();
即声明的是父类，实际指向的是子类的一个对象

C# 向上转型 向下转型的介绍

向上转型：将子类对象转为父类对象。此处父类对象可以是接口。

向下转型：把父类对象转为子类对象。 

讨论两种继承：继承自抽象类、继承自非抽象类（这两种继承所对应的转型稍有不同）

继承自非抽象类

   父类：动物类Animal(有一个叫声方法“call()”)

[csharp] view plain copy

1. class Animal  
2. {  
3.     public void call() { Console.WriteLine("无声的叫唤"); }  
4. }  

   子类：狗类Dog(继承于“动物类”，覆盖父类“call()”方法,扩展嗅觉灵敏“ smell()”方法)

[csharp] view plain copy

1. class Dog : Animal  
2. {  
3.     // new的作用是隐藏父类的同名方法  
4.     public new void call() { Console.WriteLine("叫声：汪～汪～汪～"); }        
5.     public void smell() { Console.WriteLine("嗅觉相当不错！"); }  
6. }  

   向上转型：将子类对象转为父类对象。此处父类对象可以是接口。

    转化后的父类对象具有父类所有方法，若方法被子类重写override，那么实际调用时，调用的是重写后的实现。同时支持子类到父类的强转。特注：但不能调用子类扩展方法(父类不具有的方法)。

[csharp] view plain copy

1. Animal animal = new Dog();             //向上转型①  
2.   
3. animal.call();   //打印出“无声的叫唤”，调用的是父类本身的call方法。  
4.   
5. // animal.smell();        //出错，不存在此方法。  

    目前看来，感觉animal跟Dog一点关系也没有。但请继续往下看

   向下转型：把父类对象转为子类对象。

    经②转化后的子类对象，跟一般的继承子类对象一样。具有子类所有方法(包括重写方法)+父类所有方法(被重写的方法，按重写的算。)

    例：

[csharp] view plain copy

1. Dog dog = (Dog)animal;                      //向下转型②  
2. dog.call();                 //打印出“叫声：汪～汪～汪～”，即调用的是Dog类的call方法。  
3. dog.smell();                //打印出“嗅觉相当不错！”，即子类方法可用。  

     特注：若Animal animal = new Dog()改成Animal animal = new Animal()，那么Dog dog = (Dog)animal ③ 将不被支持，而出错。这是相当于用父类来替换子类，因为子类具有扩展，父类不能做到完全替代。

[csharp] view plain copy

1. // Dog dog2 = new Animal();        //编译都无法通过，报错“存在一个显示转换”  
2.   
3. // Dog dog3 =(Dog)new Animal();    //运行报错，报错“无法将Animal类型转化为Dog类型”<span style="font-size:18px;">s④</span>  

   ③与④类同。

    Animal animal = new Dog()好似给animal声明了一个大的空间(放置Dog的空间)，用的时候，允许有空隙；同等大小的内容(Dog对象)刚好容纳，很贴身；小一些的内容(Animal对象)放到里面，虽有空隙，但是没问题的。

继承自抽象类

   父类：动物类Animal_a(有一个叫声方法“call()”) 

[csharp] view plain copy

1. abstract class Animal_a  
2. {  
3.     public abstract void call();  
4. }  

   子类：狗类Dog_a(继承于“动物类”，实现父类“call()”方法,扩展嗅觉灵敏“ smell()”方法)

[csharp] view plain copy

1. class Dog_a : Animal_a  
2. {  
3.     public override void call() { Console.WriteLine("叫声：汪～汪～汪～"); }  
4.     public void smell() { Console.WriteLine( "嗅觉相当不错！"); }  
5. }  

这里是一般的继承知识：

[csharp] view plain copy

1. Animal_a animal_a = new Dog_a();               //向上转型  
2. animal_a.call();      //打印出“叫声：汪～汪～汪～”  
3. // animal_a.smell();  //不存在此方法  

子类实现抽象类，调用方法时，自动找到子类同名方法，执行子类同名方法。向上转型时，转型后的对象只具有父类方法和子类对父类重新（实现）的方法。

总结：

向上转型是自由的；向下转型是有约束条件的。

非抽象继承，子类对象、父类对象的方法都能调到(用子类对象能调到子类对象的方法，用父类对象能调用父类对象的方法)。