Java中向上转型和向下转型是什么意思？谁能够编写代码举例详细说明一下啊

向上转型和向下转型
                Animal a = new Dog();  //向上转型   Animal 是动物类  Dog狗类   这就相当于狗是动物
                //使用Dog中特有的方法
                Dog d = (Dog) a;  //向下转型  这个a相当于动物   而说成 动物是狗 不好没人这么说  所以就要强转

                //注意：不能转换成不同类型的
                Cat c = (Cat)a; 这里的a已经是狗类了 说以不能强转，就相当于一只狗你不能说他是猫类
               
                举例：
                孔子爹:教课(java)
                孔子:教课(论语)，玩游戏()

                //多态
                孔子爹 k爹 = new 孔子(); //孔子就穿上他爹的衣服，装爹 向上转型
                k爹.教课();  //论语
                //k爹.玩游戏();

                孔子 k = (孔子) k爹;  //脱下衣服，穿上自己衣服。向下转型
                k.玩游戏();

向上向下转型中的上和下是指继承树中的上层和下层，上层表示父类以及更上层，下层表示此类的子类或更下层。
向上转型：Animal animal = new Cat(),其中Cat类继承Animal类或者是实现Animal接口，我们现在的把新new出来的Cat对象赋值给一个Animal的引用就是向上转型，我们用animal变量只能得到Cat中的部分方法和Animal的全部方法。
向下转型：Cat cat = (Cat)animal，这里我们用强制类型转换到子类Cat类型。
在向上转型中我们无需加强制类型转换，但是在向下转型中我们必须加上强制类型转换，否则编译器编译不通过。（这是黑马其它的回答你可以看看）

向上转型:通俗地讲即是将子类对象转为父类对象。此处父类对象可以是接口
看下面代码：

1. public class Animal {
   
2.         public void eat(){
   
3.                 System.out.println("animal eatting...");
   
4.         }
   
5. }
   
6. class Bird extends Animal{
   
7.         public void eat(){
   
8.                 System.out.println("bird eatting...");
   
9.         }
   
10.         public void fly(){
    
11.                 System.out.println("bird flying...");
    
12.         }
    
13. }
    
14. class Main{
    
15.         public static void main(String[] args) {
    
16.                 Animal b=new Bird(); //向上转型
    
17.                 b.eat();
    
18.                 //! error: b.fly(); b虽指向子类对象，但此时丢失fly()方法
    
19.         }
    

复制代码

此处将调用子类的eat()方法。原因：b实际指向的是Bird子类，故调用时会调用子类本身的方法。
需要注意的是向上转型时b会遗失除与父类对象共有的其他方法。如本例中的fly方法不再为b所有。
向下转型:与向上转型相反，即是把父类对象转为子类对象。
看下面代码：

1. public class Girl {
   
2.         public void smile(){
   
3.                 System.out.println("girl smile()...");
   
4.         }
   
5. }
   
6. class MMGirl extends Girl{
   
7.        
   
8.         @Override
   
9.         public void smile() {
   
10.                 System.out.println("MMirl smile sounds sweet...");
    
11.         }
    
12.         public void c(){
    
13.                 System.out.println("MMirl c()...");
    
14.         }
    
15. }
    
16. class Main{
    
17.         public static void main(String[] args) {
    
18.                 Girl g1=new MMGirl(); //向上转型
    
19.                 g1.smile();
    
20.                 MMGirl mmg=(MMGirl)g1; //向下转型,编译和运行皆不会出错
    
21.                 mmg.smile();
    
22.                 mmg.c();
    
23.                 Girl g2=new Girl();
    
24. //                MMGirl mmg1=(MMGirl)g2; //不安全的向下转型,编译无错但会运行会出错
    
25. //                mmg1.smile();
    
26. //                mmg1.c();
    
27. /*output:
    
28. * CGirl smile sounds sweet...
    
29. * CGirl smile sounds sweet...
    
30. * CGirl c()...
    
31. * Exception in thread "main" java.lang.ClassCastException: com.wensefu.other1.Girl
    
32. * at com.wensefu.other1.Main.main(Girl.java:36)
    
33. */
    
34.                 if(g2 instanceof MMGirl){
    
35.                         MMGirl mmg1=(MMGirl)g2;
    
36.                         mmg1.smile();
    
37.                         mmg1.c();
    
38.                 }
    
39.         }
    
40. }
    

复制代码

Girl g1=new MMGirl(); //向上转型
g1.smile();
MMGirl mmg=(MMGirl)g1; //向下转型,编译和运行皆不会出错
这里的向下转型是安全的。因为g1指向的是子类对象。
而Girl g2=new Girl();
MMGirl mmg1=(MMGirl)g2; //不安全的向下转型,编译无错但会运行会出错
运行出错：
Exception in thread "main" java.lang.ClassCastException: com.wensefu.other1.Girl
    at com.wensefu.other1.Main.main(Girl.java:36)
如代码所示，可以通过instanceof来防止出现异常。

给你举个简单的例子，看代码注释

1. class  Demo
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 //这是多态父类引用指向子类对象也是向上转型，就是本来是猫Cat的实体对象想在使用的是动物
   
6.                 //Animal的引用，及Cat猫转为Animal动物
   
7.                 Animal a = new Cat();
   
8.                 //这里a所引用的对象实际上是猫对象，所以我们可以强制将动物的引用a转换为更明确的对象猫
   
9.                 //及动物转为猫，这就叫做向下转型
   
10.                 Cat c = (Cat)a;
    
11.         }
    
12. }
    
13. 
    
14. class Aniaml
    
15. {
    
16. }
    
17. 
    
18. class Cat extends Animal
    
19. {
    
20. }

复制代码

1.向上转型和向下转型是和多态紧密相关的。

2.java引用变量的两种类型
==>编译时类型，由声明该变量是使用的类型决定。
==>运行时类型，由实际赋给该变量的对象决定。
如果编译时类型和运行时类型不一致时，就会出现多态polymorphism。
BaseClass polymorphism = new SubClass();

3.当把子类对象赋给父类引用变量时，被称为向上转型upcasting。
因为子类其实是一种特殊的父类，因而java允许把一个子类对象直接赋给一个父类引用变量，无需任何类型转换，该转换由系统自动完成。

当把父类对象赋给子类引用变量时，被称为向下转型downcasting。进行向下转换需要进行强制类型转换，而且可能产生ClassCastException异常。

示例如下

1. class BaseClass{
   
2. }
   
3. 
   
4. class SubClass extends BaseClass{
   
5.         public static void main(String[] args){
   
6.                 //向上转型，子类对象赋给父类引用变量
   
7.                 BaseClass upcast = new SubClass();
   
8.                
   
9.                 //向下转型,强制类型转换
   
10.                 SubClass downcast = (SubClass)new BaseClass();
    
11.         }
    
12. }
    

复制代码

谢谢，问题已解决