看了毕老师多态的视频后，对于转型这一块内容概念很模糊，不知道如何去理解转型。希望会的同学可以指点一下我
什么是向上转型，如何去理解
什么是向下转型，如何理解?

向上转型：父类引用指向子类对象
向下转型：子类引用指向父类对象
而其中向下转型需要注意，父类引用的对象原本就是子类对象的话，那么在向下转型的过程中是安全的。也就是编译是不会出错误的。如果父类引用的对象是父类本身，那么在向下转型的过程中是不安全的，编译不会出错，但是运行时会出现错误

假定父类为 动物，子类为狗，父类有一个方法发声（），狗继承并覆盖了一个发声方法。在子类重写该方法
则（以下过程c#实现）：动物 a=new 狗（）；//这就为向上转型a.发声（）；
在调用 a.发声（）；时调用的是狗的发声（）也可调动物类其他方法 但不能调用狗类方法
若修改为动物 a=new 狗（）；
狗b=（狗）a；//这里向下转型
这时b可调用动物类未被重写的方法和狗类所有方法（包括重写动物类的方法）
向上转型都会成功，是安全的。 就像说狗是动物没问题。
接上面
动物 a=new 动物（）；
a.发声（）；//调动物类方法
狗 b=（狗）a；//这也是向下转型 但下面通过b若调用 动物 或 狗类中任意方法都报异常
也就是说向下转型可能会出错 不能说动物是狗
JAVA中的一种调用方式
class A{
void f(){}
void g(){}
}
class B extends A{
void g(){}
void i(){}
}
public class C{
public static void main(String[] args){
A a=new B(); //B自动向上转型为A的对象
}
}
向上转型并非是将B自动向上转型为A的对象，相反它是从另一种角度去理解向上两字的：它是对A的对象的方法的扩充，即A的对象可访问B从A中继承来的和B复写A的方法。其它的方法都不能访问。即使是A 中的私有成员方法。

向上转型示例：

1. 
   
2. class A {  
   
3.       
   
4.     public void repeat(){  
   
5.         System.out.println("---A---");  
   
6.     }  
   
7. }  
   
8. class B extends A{  
   
9.       
   
10.     public void repeat(){  
    
11.         System.out.println("---B---");  
    
12.     }  
    
13.       
    
14.     public void only(){  
    
15.          
    
16.         System.out.println("---only---");  
    
17.     }  
    
18. }  
    
19. class Temp11_11_02{  
    
20.       
    
21.     public static void main(String[] args) {  
    
22.          
    
23.         A b=new B(); //向上转型  
    
24.         b.repeat();   
    
25.       //b.only(); Error: b虽指向子类对象，但此时丢失only()方法
    
26.     }
    
27.   }

复制代码

向下转型示例：

1. class Fu {  
   
2.     public void smile(){  
   
3.         System.out.println("父类");  
   
4.     }  
   
5. }  
   
6. class son extends Fu{  
   
7.         
   
8.     public void smile() {            
   
9.         System.out.println("子类");  
   
10.     }  
    
11.     public void c(){  
    
12.         System.out.println("子类c方法");  
    
13.     }  
    
14. }  
    
15. class Temp11_11_02{        
    
16.     public static void main(String[] args) {
    
17.         Fu f= new son(); //向上转型  
    
18.         f.smile();
    
19.          
    
20.         son s=(son)f; //向下转型,编译和运行皆不会出错  
    
21.         s.smile();  
    
22.         s.c();            
    
23.          
    
24.         Fu f2=new Fu();  
    
25. //      son s1=(son)f2; //不安全的向下转型,编译无错但会运行会出错  
    
26. //      s1.smile();  
    
27. //      s1.c();           
    
28.     }  
    
29. }  

复制代码

你读一读代码。再运行一下。应该能理解个七七八八了。其他的，暂时不用深入。先打基础为主。