package package0717;

public class ManyChildStateTest {
public static void main(String[] args) {
        ManyState ms = new ManyChildState();//:向上转型
        ms.eating();
        ms.sleeping();
       
   }
public void  getManyState(ManyState manyState ){
        ManyChildState mcd = (ManyChildState) manyState  ;//:向下转型
        //:父类:manyState
        //:子类:ManyChildState
        //:测试类:ManyChildStateTest
       
        }

}
谁能帮解释下向下转型     这个代码理解起来有点费劲  

主函数创建的是父类引用子类的对象
需要调用子类特有方法时就需要将这个引用对象强制转换成子类对象
但是只能强制转换成原来被引用的子类

David.L 发表于 2014-7-17 20:04
主函数创建的是父类引用子类的对象
需要调用子类特有方法时就需要将这个引用对象强制转换成子类对象
但是只 ...

我能理解强转,  但是我不了解那个强转的格式,   好像把对象当做参数往里边传   那个不太理解

liwenbin0912 发表于 2014-7-17 21:11
我能理解强转,  但是我不了解那个强转的格式,   好像把对象当做参数往里边传   那个不太理解 ...

实际传的是对象地址吧
注意：
ManyState是类名
但manyState其实就像是变量名，你换成其他也可以，传对象的地址变量而已，不是传对象

换成public void  getManyState(int x){  这样你就理解了吧，int也是一个类吧，x是变量，只不过这里的类是ManyState
个人理解哈

多看几遍吧 我们说来说去也不急视频中老师说的好

格式不需要理解

子类向父类转换，进行隐式转换；父类转子类，需要显式转换。

1. class father {
   
2.         public int x;
   
3.         public int y;
   
4. 
   
5.         public void sayHello() {
   
6.                 System.out.println("Hello:father");
   
7.         }
   
8. 
   
9.         public void testfather() {
   
10.                 System.out.println("testfather");
    
11.         }
    
12. 
    
13. }
    
14. 
    
15. class child extends father {
    
16.         public int z;
    
17. 
    
18.         @Override
    
19.         public void sayHello() {
    
20.                 // TODO Auto-generated method stub
    
21.                 System.out.println("Hello:child");
    
22.         }
    
23. 
    
24.         public void testchild() {
    
25.                 System.out.println("testchild");
    
26.         }
    
27. }
    
28. 
    
29. public class fathertochild {
    
30. 
    
31.         public static void main(String[] args) {
    
32.                 father fat = new father();
    
33.                 child chi = new child();
    
34.                 // 子类传递给父类，实现多态
    
35.                 fat = chi;
    
36.                 // fat是指向father的引用，虽然我把chi的引用传给了fat，但fat本质上还是指向father类的
    
37.                 // 因此fat无法获得chi的新内容
    
38.                 // 这句编译报错
    
39.                 // fat.z = 2;
    
40.                 // 这就是fat在运行时候的多态，fat是指向father的引用，但在运行时候却指向了chi的方法
    
41.                 // 这句输出Hello：child
    
42.                 fat.sayHello();
    
43. 
    
44.                 father fat1 = new father();
    
45.                 child chi1 = new child();
    
46.                 // 父类传递给子类，强制类型转换
    
47.                 // 隐式转换报错
    
48.                 // chi = fat1;
    
49.                 // 下面这种强制转换的形式就相当于将一个指向child类的引用chi，强制的指向了被强制转换成child类的father类，chi里面有继承了father的
    
50.                 // 方法，也有自己实现了的方法，而fat里面并没有实现继承的方法。
    
51.                 // 强制转换编译器不报错，但是运行时会抛出异常
    
52.                 // com.itheima.father cannot be cast to com.itheima.child，呵呵说的多明白
    
53.                 chi1 = (child) fat1;
    
54.                 // fat1并没有z这个变量，但编译器认为chi是child类，肯定有z，但是运行时找不到z，抛出异常
    
55.                 // 看看下面这几句代码，把编译器骗的好惨，但实际上根本不可能运行的
    
56.                 // chi.z = 2;
    
57.                 // System.out.println(chi.z);
    
58. 
    
59.                 // chi.sayHello();
    
60.                 // chi.testchild();
    
61.                 // chi.testfather();
    
62.                 // 实际写代码的时候经常看到有人将Object这个父类变来变去,但要知道，Object是所有类的父类，
    
63.                 // 所以说任何类型都可以赋值给Object
    
64.                 Object obj = new child();
    
65.                 father fat3 = (father) obj;
    
66.                 // 依然输出Hello：chilid
    
67.                 fat3.sayHello();
    
68.                 // 下面这段代码依然会抛出类型无法转换异常
    
69.                 // com.itheima.father cannot be cast to com.itheima.child
    
70.                 Object obj1 = new father();
    
71.                 child chi2 = (child) obj1;
    
72.                 chi2.sayHello();
    
73.                 // 所以说不要尝试将父类强制转换成子类，也就是所谓的向下转型，这样是不安全的。编译时可以通过，但运行时会发生类型转换错误。
    
74.                 // 谁也不想在代码变得庞大和复杂以后去找这种小bug吧，呵呵。
    
75.         }
    
76. 
    
77. }
    

复制代码