黑马程序员---Java中的多态

                                 关于Java中的多态

                 --------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------

多态：面向对象特征之一，函数本身就具备多态性，某一种事物有不同的

体现：父类引用或者接口的引用指向了字节的子类对象。

多态的好处：提高了程序的扩展性。

多特的弊端:当父类引用指向子类对象时，虽然提高了扩展性，但是只能访问父类中具备的方法，不可以访问子类中特有的方法。（前器不能使用后期产生的功能，即访问的局限性）

 

多态的前提：

1.必须要有关系： 比如继承，或者实现

2.统称会有覆盖操作

多态的出现思想上也做着变化，以前创建对象并指挥对象做事情。有了多特以后，我们可以找到对象的共性类型，直接操作共性类型做事情即可。这样就可以指挥一批对象做事情，既可以通过父类或者接口实现

/*

  演示孔子和孔子爹的故事

  定义两个事物，一个是孔子，孔子爹 ，年龄，和讲课，孔子自己，具备游戏

*/

//定义孔子爹类

class KongDie{

   int age = 70;

   public void teacher(){

      System.out.println("讲的是经商");

   }

}

//定义孔子类

class KongZi extends KongDie{

   int age = 40;

   public void teacher(){

    System.out.println("讲的是论语");

   }

   

   public void playGame(){

      System.out.println("打游戏");

   }

}

/*class KongZi2 extends KongDie{

   public void teacher(){

       System.out.println("讲的程序的");

   }

}*/

class DuoTaiDemo{

   public static void main(String[] args){

       //开始找人上课，找的是孔子爹，实际是孔子，化妆成他的父亲

   

// 父类或者接口的引用，指向自己的子类对象

    KongDie die = new KongZi();//化妆成自己的父亲，出去讲课

    die.teacher();//讲论语

    System.out.println(die.age);//父亲的年龄，70岁

    //调用子类的特有方法，打游戏，必须将已经提升为父类类型的对象，转成子类类型

    //孔子要卸妆，变回他自己

    //目标类型 变量 = （目标类型）被转的变量

     KongZi zi = (KongZi)die;

     zi.playGame();

     System.out.println(zi.age);

   }

}

//==============================================================================

如何判断对象是那个具体子类类型

instanceof;//判断对象是否实现了指定的接口货继承了指定的类

格式 对象 instanceof 类型

多态的总结

  好处：可以无限的扩展子类

 

  A. 父类或者接口指向自己的子类对象

     Fu f = new Zi(); NO ~~ Zi zi = new Fu();

  B. 调用方法的时候，运行的是子类重写后的方法

  C. 调用成员变量的时候，运行的是父类的成员变量

  D. 在多态中，只能调用子类父类共有方法，不能调用子类的特有方法！！多态的弊端

  E. 调用子类特有方法，必须进行类型的强制转换，将提升为父类类型的子类对象，转回子类的类型，手动！！

  F. 保证程序的安全性，避免发生类型转换异常ClassCastException，采用instancof运算符，进行健壮性判断

     变量 instanceof 类名 如果是返回真 类 instanceof 变量--语法错误

 

多态中的实现的细节，很重要很重要

  多态中的成员变量：

      编译时期，如果父类中定义了这个成员变量，编译成功，否则编译失败

   运行时期，运行父类中定义的成员变量

   

  多态中的静态成员变量：

      编译时期，如果父类中定义了这个成员变量，编译成功，否则编译失败

   运行时期，运行父类中定义的成员变量

   

  多态中的非静态成员方法：

      编译时期，如果父类中定义了这个成员方法，编译成功，否则编译失败

   运行时期，运行子类重写后的方法

   

  多态中的静态成员方法：

      编译时期，如果父类中定义了这个成员方法，编译成功，否则编译失败

   运行时期，运行父类中定义的成员方法

 

  小规律：

    除了非静态的成员方法以外，编译运行都看父类

 只有非静态的成员方法，编译看父类，运行看子类

 

 非静态的成员方法，编译看左边，运行看右边

 其他情况，编译运行全看左边

/*

   通过养宠物的案例，展示多态

*/

//每个动物的共性抽取

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();

   }

      }

   

   

}

//===========================================

多态在子父类中的成员上的体现的特点：

1，成员变量：在多态中，子父类成员变量同名。

在编译时期：参考的是引用型变量所属的类中是否有调用的成员。（编译时不产生对象，只检查语法错误）

运行时期：也是参考引用型变量所属的类中是否有调用的成员。

简单一句话：无论编译和运行，成员变量参考的都是引用变量所属的类中的成员变量。

再说的更容易记忆一些：成员变量 --- 编译运行都看 = 左边。

2，成员函数。

编译时期：参考引用型变量所属的类中是否有调用的方法。

运行事情：参考的是对象所属的类中是否有调用的方法。

为什么是这样的呢？因为在子父类中，对于一模一样的成员函数，有一个特性：覆盖。

简单一句：成员函数，编译看引用型变量所属的类，运行看对象所属的类。

更简单：成员函数 --- 编译看 = 左边，运行看 = 右边。

3，静态函数。 

编译时期：参考的是引用型变量所属的类中是否有调用的成员。

运行时期：也是参考引用型变量所属的类中是否有调用的成员。

为什么是这样的呢？因为静态方法，其实不所属于对象，而是所属于该方法所在的类。

调用静态的方法引用是哪个类的引用调用的就是哪个类中的静态方法。

简单说：静态函数 --- 编译运行都看 = 左边。

/*

   多态中的细节

*/

class Fu{

    int x = 10;

    public void show(){

    System.out.println("父类中的show");

  }

}

class Zi extends Fu{

    int x = 20;

    public void show(){

    System.out.println("子类中的show");

  }

}

class DuoTaiDemo4{

  public static void main(String[] args){

     

      Fu f = new Zi();

   f.show();

   //System.out.println(f.x);

  }

}

                   --------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------