多态中
父类引用指向自己的子类对象，
调用方法时，只能运行子类重写后的方法，不能调用子类特有的方法，常常遇到ClassCastException这样的提示，我想知道怎么能调用子类特有的方法

   1  在多态中，只能调用子类父类共有方法，不能调用子类的特有方法！！这就是多态的弊端
   2 调用子类特有方法，必须进行类型的强制转换，将提升为父类类型的子类对象，转回子类的类型，手动！！
   3 但是为了 保证程序的安全性，避免发生类型转换异常ClassCastException，采用instancof运算符，进行健壮性判断
     变量 instanceof 类名 如果是返回真  说明可以转回子类类型   4 利用         目标类型 变量 = （目标类型）被转的变量，转换为子类类型后就可以调用子类特有的方法。

如果是父类引用指向子类对象，调用子类特有方法的时候，必须将已经提升为父类类型的子类对象，强制转回子类的类型，类似数据类型的强制转换。

老师的视频中详细的讲过哦！！！！！！

1. abstract class Animal1{
   
2.         public abstract void eat();
   
3. }
   
4. 
   
5. class Cat1 extends Animal1{
   
6.          public  void eat(){
   
7.                  System.out.println("吃鱼");
   
8.          }
   
9.          public void catchMouse(){
   
10.                  System.out.println("抓老鼠");
    
11.          }
    
12. }
    
13. class Dog1 extends Animal1{
    
14.         public void eat(){
    
15.                 System.out.println("吃骨头");
    
16.         }
    
17.         public void KanJia(){
    
18.                 System.out.println("看家");
    
19.         }
    
20. }
    
21. class Pig1 extends  Animal1{
    
22.          public void eat(){
    
23.                  System.out.println("饲料");
    
24.          }
    
25.          public void gongDi(){
    
26.                  System.out.println("拱地");
    
27.          }
    
28. }
    
29. 
    
30. public class DuoTaiDemo1 {
    
31. 
    
32.        
    
33.         public static void main(String[] args) {
    
34.                
    
35.                
    
36. //                   Animal a = new Cat();//类型提升。向上转型。
    
37. //                   a.eat();
    
38. //1---------------------------------------------------------------------------------------                  
    
39.                 //如果想要调用猫的特有方法时，如何操作。
    
40. //                  强制将父类的引用。转成子类类型。向下转型。
    
41. //                   Cat c =(Cat)a;
    
42. //                   c.catchMouse();
    
43. //2--------------------------------------------------------------------------------------               
    
44.                    //千万不要出现这样的操作，就是将父类对象转成子类类型。
    
45.            //我们能转换的是父类引用指向了自己的子类对象时，该引用可以被提升，也可以被强制转换。
    
46.                    //多态自始至终都是子类对象在做着变化。
    
47. //                   Animal1 a = new Animal1();
    
48. //                   Cat c = (Cat)a;
    
49. //3---------------------------------------------------------------------------------------               
    
50.                 function(new Dog());
    
51.                 function(new Cat());
    
52.         }
    
53.         public static void function(Animal a){
    
54.                 a.eat();
    
55.                 if(a instanceof Cat){
    
56.                         Cat c = (Cat)a;
    
57.                         c.catchMouse();
    
58.                 }else if(a instanceof Dog){
    
59.                         Dog d = (Dog)a;
    
60.                         d.KanJia();
    
61.                 }
    
62.                        
    
63.                
    
64.         }
    
65. }

复制代码

看看1，2, 3，的部分 你就懂了！！！

强制转换成子类就可以调用了

孟祥钰 发表于 2014-5-27 21:34
如果是父类引用指向子类对象，调用子类特有方法的时候，必须将已经提升为父类类型的子类对象，强制转回子类 ...

:handshake:handshake

1. /*
   
2.    通过养宠物的案例，展示多态
   
3. */
   
4. //每个动物的共性抽取
   
5. class Animal{
   
6.   public void eat(){}
   
7. }
   
8. //养个鸟，吃的功能，飞翔
   
9. class Bird extends Animal{
   
10.   public void eat(){System.out.println("鸟吃虫子");}
    
11.   public void fly(){System.out.println("鸟在飞");}
    
12. }
    
13. //养狗，吃的功能，看家
    
14. class Dog extends Animal{
    
15.    public void eat(){System.out.println("狗吃狗粮");}
    
16.    public void lookHouse(){System.out.println("狗看家");}
    
17. }
    
18. 
    
19. //养猫，吃的功能，抓老鼠
    
20. class Cat extends Animal{
    
21.    public void eat(){System.out.println("猫吃猫粮");}
    
22.    public void catchMouse(){System.out.println("猫抓老鼠");}
    
23. }
    
24. 
    
25. class DuoTaiDemo3{
    
26.    public static void main(String[] args){
    
27.             Cat c = new Cat();
    
28.                         eat( c)        ;
    
29.                         eat(new Bird())        ;
    
30.    }
    
31.   
    
32.       public static void eat(Animal a){//eat(new Cat());  Animal a = new Cat(); 向上转，多态
    
33.             a.eat();
    
34.                         //进行类型转换的时候，判断一下，传递的对象是不是猫对象
    
35.                         //最后的一个比较运算符  instanceof 关键字，结果肯定真或者假
    
36.                         //判断一个引用，是不是由一个类创建的   ：格式 引用类型变量 instanceof 类
    
37.                         // a instanceof Cat==>true   a instanceof Dog==>false
    
38.                         if(a instanceof Cat){
    
39.                           Cat c = (Cat)a;
    
40.                           c.catchMouse();
    
41.                         }
    
42.                         
    
43.                         if(a instanceof Dog){
    
44.                           Dog d = (Dog)a;
    
45.                           d.lookHouse();
    
46.                         }
    
47.                         
    
48.                         if(a instanceof Bird){
    
49.                           Bird b = (Bird)a;
    
50.                           b.fly();
    
51.                         }
    
52.       }
    
53.    
    
54.    
    
55. }

复制代码

abstractclass Animal {
        public abstractvoid eat();
}
class Cat extends Animal  {   
        public void eat(){   
                System.out.println("吃鱼");   
        }   
        public void catchMouse()  {   
                System.out.println("抓老鼠");   
        }   
}   
class Dog extends Animal  {   
        public void eat()  {   
                System.out.println("吃骨头");   
        }   
        public void kanJia()  {   
                System.out.println("看家");   
        }   
}   
class Pig extends Animal  {   
        public void eat()  {   
                System.out.println("饲料");   
        }   
        public void gongDi()  {   
                System.out.println("拱地");   
        }   
}   
   
class DuoTaiTest   {   
        public static void main(String[] args)   {   
                Animal a = new Cat();
                //类型提升。 向上转型。 父类类型指向子类对象  
                a.eat();  //吃鱼
   
                //如果想要调用猫的特有方法时，如何操作？   
                //强制将父类的引用。转成子类类型。向下转型。   
                Cat c = (Cat)a;   
                c.catchMouse(); //抓老鼠
   
                //不要出现这样的操作，就是将父类对象转成子类类型。   
                //我们能转换的是父类应用指向了自己的子类对象时。
                //该应用可以被提升，也可以被强制转换。   
                //多态自始至终都是子类对象在做着变化。   
                //      Animal a = new Animal();   
                //      Cat c = (Cat)a;   
                  
   
                /*  
                父 x = new 子();  
  
                x.工作();  
  
                子 y = (子)x;  
  
  
                y.玩();  
                */   
                function(new Cat());
                function(new Dog());   
                function(new Pig());   
   
   
            }   
            public static void function(Animal a){//Animal a = new Cat();   
                if(!(a instanceof Animal)) {  
                    System.out.println("类型不匹配");  
                }  
                else{
                        a.eat();
                        if(a instanceof Cat)  {   
                                Cat c = (Cat)a;   
                                c.catchMouse();   
                        }
                        else if(a instanceof Dog)  {   
                                Dog c = (Dog)a;
                                c.kanJia();
                        }
                       else if (ainstanceof Pig()){
                                Pig p = (Pig)a;
                                a.gongDi();
                        }
                }
                //instanceof : 用于判断对象的类型。  
               //对象 intanceof 类型(类类型 接口类型)   
           }   
}   
中间的就是强转部分  格式

强制类型转化就可以了

正常情况一般都是  父类引用指向子类对象，  都应该复写子类特有方法，然后调用的。  也可以转换类型。 就是类型提升。

学习了学习了

四楼说的很明白

多态
  A. 父类或者接口指向自己的子类对象
     Fu f = new Zi();   NO ~~ Zi zi = new Fu();
  B. 调用方法的时候，运行的是子类重写后的方法
  C. 调用成员变量的时候，运行的是父类的成员变量
  D. 在多态中，只能调用子类父类共有方法，不能调用子类的特有方法！！多态的弊端
  E. 调用子类特有方法，必须进行类型的强制转换，将提升为父类类型的子类对象，转回子类的类型，手动！！
  F. 保证程序的安全性，避免发生类型转换异常ClassCastException，采用instancof运算符，进行健壮性判断
/*
   通过养宠物的案例，展示多态
*/
//每个动物的共性抽取
class Animal{
  public void eat(){}
}
//养个鸟，吃的功能，飞翔
class Bird extends Animal{
  public void eat(){System.out.println("鸟吃虫子");}
  public void fly(){System.out.println("鸟在飞");}
}
//养狗，吃的功能，看家
class Dog extends Animal{
   public void eat(){System.out.println("狗吃狗粮");}
   public void lookHouse(){System.out.println("狗看家");}
}

//养猫，吃的功能，抓老鼠
class Cat extends Animal{
   public void eat(){System.out.println("猫吃猫粮");}
   public void catchMouse(){System.out.println("猫抓老鼠");}
}

class DuoTaiDemo3{
   public static void main(String[] args){
            Cat c = new Cat();
                        eat( c)        ;
                        eat(new Bird())        ;
   }

      public static void eat(Animal a){//eat(new Cat());  Animal a = new Cat(); 向上转，多态
            a.eat();
                        //进行类型转换的时候，判断一下，传递的对象是不是猫对象
                        //最后的一个比较运算符  instanceof 关键字，结果肯定真或者假
                        //判断一个引用，是不是由一个类创建的   ：格式 引用类型变量 instanceof 类
                        // a instanceof Cat==>true   a instanceof Dog==>false
                        if(a instanceof Cat){
                          Cat c = (Cat)a;
                          c.catchMouse();
                        }
                       
                        if(a instanceof Dog){
                          Dog d = (Dog)a;
                          d.lookHouse();
                        }
                       
                        if(a instanceof Bird){
                          Bird b = (Bird)a;
                          b.fly();
                        }
      }


}

怎么感觉你么有看视屏呢！
如果父类初始化应用指向了子类的实例对象（多态）
这是如果想要调用子类特有的方法，必须将父类引用向下转型
eg:
Animal al=new Cat();Cat cat=(Cat)al;//抓老鼠是猫咪特有的功能，不是所有动物都有，因此向下转型
cat.catchMouse();

武维京 发表于 2014-5-27 21:49
老师的视频中详细的讲过哦！！！！！！

看看1，2, 3，的部分 你就懂了！！！

看你发的代码  我看懂了  也想明白了   谢谢啊

强制转换为子类啊 就可以使用了

如果想要使用的东西不会报classcastexcepiton的话,你后面学会使用了泛型之后,就可以考虑用泛型,这样就不会报错了,子类,如果你用多态,只哎哟是能转换过去,而且必须是子类有这个特定的方法,子类就可以使用,否则,转换过去了,还会报错

强转成子类方法

看完之后终于想明白了~~~~~:)