java的向上转型，可以让父类的实例可以调用子类已经覆写的方法。但是向下转型呢？
我怎么没发现有什么用啊。子类本来就是继承父类的方法的，不用向下转型也能调用啊，
请问到底有什么用呢？？？
class A{     // 定义类A
public void fun1(){  // 定义fun1()方法
  System.out.println("A --> public void fun1(){}") ;
}
public void fun2(){
  this.fun1() ;  // 调用fun1()方法
}
};
class B extends A{
public void fun1(){  // 此方法被子类覆写了
  System.out.println("B --> public void fun1(){}") ;
}
public void fun3(){
  System.out.println("B --> public void fun3(){}") ;
}

};
public class PolDemo01{
public static void main(String asrgs[]){
  A a=new B();
  B b=(B)a;

}
};
这里就是向下转型，本来通过B b=new B(); b就可以调用子类、父类方法，那向下转型的具体
意思是？？？？？？

因为子类中的方法并不是全部继承父类来的，会有自己独有的方法，如果你用父类的对象去调用子类中独有的方法，就会出现错误，这个时候才需要想下转型。我是这么理解的，也是新手！谢谢！！！

你的理解陷入误区了，A a=new B(); B b=(B)a;a本来就是指向的子类对象。
相当于自身向上转型一次在向下转型一次当然还是自身。这a和b只能获得子类的重载方法。
真正的向下转型为 A a=new A()；a指向的是自身方法，这时a无法获得子类的方法，你想要a获得子类的方法 B b=(B)a;这里b和a都指向同一个对象，这个对象可以分别利用a或者b调用父类或子类的重载方法。

前两天用迭代器iterator的时候经常要向下转型，不过看完泛型后就不用再转型了，

首先你这短代码应该是编译错误，因为
1在多态中成员非静态函数的特点：
在编译时期：残月引用型变量所属的类中是否有调用的方法。如果有，编译通过，没有则编译失败
在运行时期：参阅对象所属的类中是否有调用的方法

2.在多肽中成员变量和静态成员方法的特点：
无论是编译还是运行都参考引用型变量所属的类

所以JVM没有在A里面找到fuction3()方法，因此编译会出现错误

一般上转型都是实现接口编程的，减少两个类之间的偶合；
下转型一般是封装好的对象在解封而已。

1. bstract class Animal
   
2. {
   
3.         abstract void eat();
   
4. }
   
5. 
   
6. class Cat extends Animal
   
7. {
   
8.         public void eat()
   
9.         {
   
10.                 System.out.println("吃鱼");
    
11.         }
    
12.         public void catchMouse()
    
13.         {
    
14.                 System.out.println("抓老鼠");
    
15.         }
    
16. }
    
17. class DuoTai
    
18. {
    
19.         public static void main(String[] args)
    
20.         {
    
21.                 //a是父类引用，c是子类引用
    
22.                
    
23.                 Animal a = new Cat();//类型提升，向上转型
    
24.                 a.eat();
    
25.                
    
26.                 //如果想要调用猫的特有方法时，如何操作？
    
27.                 //强制将父类的引用，转为子类类型，向下转型
    
28.                 Cat c = (Cat)a;
    
29.                 c.catchMouse();//抓老鼠
    
30.                
    
31.         }
    
32. }
    
33. /*
    
34. 打印结果：
    
35. 吃鱼
    
36. 抓老鼠
    
37. */

复制代码

向上转型和向下转型中的，我的理解：“上”说白了就是父类的意思，“下”就是子类的意思。
向上转型：Animal a = new Cat();
就是将父类引用指向子类对象。相当于基本数据类型中的自动类型转换。
向下转型：Cat c = (Cat)a;
就是将父类的引用转换为子类，相当于基本数据类型中的强制类型转换。

这种多态现象大多出应用在，子类继承了一个抽象父类这种情况。
毕老师，Java初级第八天第三讲中有详细讲解...

1. /**对象的上转型对象:**
   
2. 
   
3. 比如：A是B的父类
   
4. A a;
   
5. a=new B（）；
   
6. 或者
   
7. A a;
   
8. B b=new B（）；
   
9. a=b;
   
10. 都称这个A类对象a是子类对象b的上转型对象。
    
11. 就是把子类创建的对象的引用赋给了父类声明的对象变量了。
    
12. 另注意：不可以将父类创建的对象的引用赋值给子类声明的对象。
    
13. 
    
14. 对象的上转型对象的实体是子类负责创建的，但上转型对象会失去原子类对象的一些属性和功能。
    
15. 上转型对象具有以下两个属性或功能：
    
16. (1)继承或隐藏的变量，(2)继承或重写的方法
    
17. 四个特点
    
18. a.上转型对象不能操作子类新增的成员变量（失去了这部分属性），不能使用子类新增的方法（失去了一些功能）。
    
19. b.上转型对象可以操作子类继承或隐藏的成员变量，也可以使用子类继承的或重写的方法。
    
20. c.上转型对象操作子类继承或重写的方法时，就是通知对应的子类对象去调用这些方法。因此，如果子类重写了父类的某个
    
21. 方法后，对象的上转型对象调用这个方法时，一定是调用了这个重写的方法。
    
22. d.可以将对象的上转型对象再强制转换到一个子类对象，这时，该子类对象又具备了子类的所有属性和功能。
    
23. 
    
24. * */
    
25. 
    
26. class Monkey
    
27. {
    
28. private int n=100;
    
29. void crySpeak(String s)
    
30. {
    
31. System.out.println(s);
    
32. }
    
33. }
    
34. class People extends Monkey
    
35. {
    
36. void computer(int a,int b)
    
37. {
    
38. int c=a*b;
    
39. System.out.println(c);
    
40. }
    
41. void crySpeak(String s)
    
42. {
    
43. System.out.println("**"+s+"**");
    
44. }
    
45. }
    
46. public class note4
    
47. {
    
48. public static void main(String args[])
    
49. {
    
50. Monkey mon=new People();//mon是People对象的上转型对象
    
51. mon.crySpeak("I LOVE THIS GAME");
    
52. People people=(People)mon;//把上转型对象强制转化为子类的对象
    
53. people.computer(10,10);
    
54. 
    
55. }
    
56. 
    
57. }
    
58. 
    
59. /*运行结果***
    
60. 
    
61. **I LOVE THIS GAME**
    
62. 100
    
63. 
    
64. * */
    

复制代码