polymorphism 多态

一看见有polymorphism 动态的地方：表示涉及类型转换。

      找对应的三个对象（使用者，绑定者，被绑定者（多个））即可。

       动态绑定（类型转换）：表示把使用者类型变成被绑定者类型。

主要分两种：1》一种有三个对象，（使用者，绑定者，被绑定者（多个））

                             绑定者是我们自己写的类，由它去转换。

                      2》绑定者就是jvm：直接把使用者类型变成被绑定者类型。

意思：1、表示多（多多，多种形式，多种形状）的意思等等

           2、动态绑定.(三个对象，使用者，绑定者，被绑定者(表示多多多的意思))。只要抓住这一点即可，就表示多态。

                 当需要时，绑定者把使用者和被绑定者连接起来。             

                 也叫类型转换，绑定者把自己的类型转换成被绑定者的类型。              

         3、多态有一个特点，认为父类和子类是同一类型。

一、例子

        例如：一个大公司来我们班招聘，直接找班主任，说需要找会做（java后台开发，网页）的一些优秀学生。

          1、需求分析：

               1》找三个对象（使用者，绑定者，被绑定者（多个））

                   使用者：公司

                   绑定者：班主任

                   被绑定者：学生

                  2》找动态绑定：当学生正准备去公司时，班主任把公司需要的人才和学生绑在一起。

          2、代码分析

          (1)使用者：CompanyRecruit 类 

                        使用者和绑定者联系在一起  Getdeveloper(Teacher t)

          (2)绑定者：Teacher类 developer（）：绑定者和被绑定者联系在一起。

         Teacher  teacher1=new  JaveStudent();
         Teacher  teacher2=new  WebStudent();

          (3)被绑定者(多个)：JaveStudent，WebStudent这里是两个，都有developer（）方法。   

          (4)动态绑定：  程序开始运行时，班主任把用人单位所需要的人才和对应的学生连接起来。

                                  或者是把自己的类型转成JaveStudent的类型，只有运行时才有真正的学生地址。

              

          3、当程序开始执行时，首先main()线程里面的指令

                1》 在堆中，建立两个对象（JaveStudent，WebStudent），

                2》调用方法CompanyRecruit.Getdeveloper(teacher1)，//teacher1就是指向JaveStudent的地址。

                     在这里班主任把用人单位需要的人才（CompanyRecruit）和JaveStudent,WebStudent的学生相绑在在一起

                     public static void Getdeveloper(Teacher t)：

              这个对象变量地址=存放学生对象的地址，当在方法调动时才是动态绑定，

               （即班主任把用人单位需要的人才和会JaveStudent,WebStudent的学生相绑在在一起）

                           

4、代码

ckage polymorphism; import static net.mindview.util.Print.print; class Teacher{    public void developer(){print("developer"); }; } class JaveStudent extends Teacher{    public void developer(){print("JaveStudent");} }  class WebStudent extends Teacher{   public void act(){print("JaveStudent");}   }    public class CompanyRecruit {  public static void Getdeveloper(Teacher t)  { t.developer();   }   public static void main(String[] args)   {    Teacher  teacher1=new  JaveStudent();  Teacher  teacher2=new  WebStudent();  CompanyRecruit.Getdeveloper(teacher1);   CompanyRecruit.Getdeveloper(teacher2);   }  }

二、绑定者就是jvm：直接把使用者类型变成被绑定者类型。

      多态方法overload，一样的东西，输入不同，输出不同，（Ad hoc polymorphism，known as function overloading

     方法名一样，参数类型不同-----实现功能不同。

     磨粉小电动机，输入黄豆------出黄豆粉

                            输入大米------出大米粉

      1》找三个对象（使用者，绑定者，被绑定者（多个））

        使用者：PrimitiveOverloading       

                使用者和绑定者联系在一起  

        绑定者：jvm

        被绑定者：  f1(char x), f1(int x) 

      2》找动态绑定：绑定者把自己类型转换成被绑定者类型。

          在运行时，绑定者要把5变成int,然后调用对应的方法。

import static net.mindview.util.Print.*; public class PrimitiveOverloading {   void f1(char x) {printnb("f1(char) ");} void f1(int x) {printnb("f1(int) ");} public static void main(String[] args) { PrimitiveOverloading p = new PrimitiveOverloading();             p.f1(5);    p.f1('c');    } }

三、绑定者是我们自己写的类，由它去转换。

    overrite(重写) 也是多态：父和子有同样的方法，当调用父类方法时，存在类型转换，即父类方法转成子类方法。

      使用者：son1.a（）：和绑定者联系

       绑定者：fath.a()：和被绑定者联系、

       被绑定者：son1.a(),so2.a()

        动态绑定：需要把绑定者的类型转换成被绑定者类型。即类型转换。                  

     （即不同子对象调用同一方法，出现不同的结果）

      当父类有一个方法，许多子类都觉得不够用，哪么问题来了，怎么办？重写一个

      有几个子类都重写了这样的方法，哪么（父类.方法）,几个子类对象分别传到父类对象，执行了子类的方法、           

四、绑定者就是jvm：直接把使用者类型变成被绑定者类型

     Parametric polymorphism：主要是Generics 通用

   The concept of parametric polymorphism applies to both data types and functions

    1》方法参数通用：<T> ：可以是任何类型。

           public <T> T[] toArray(T[] a)    

    2》类参数通用<E> 就是类里面的很多地方用具体类型代替。                            

          class LinkedList<E>

      使用者：son1 LinkedList<String>（）：和绑定者联系

       绑定者：jvm：和被绑定者联系、

       被绑定者：son1 LinkedList<String>,son2 LinkedList<Integer>

        动态绑定：需要把使用者的类型转换成被绑定者类型。即类型转换。 

五、final(private),static 方法都不能作为多态，因为他们不能动态绑定方法，在编译时已经确定。       

六、一个父接口和2个子接口，是多态吗？

        找  1》使用者，绑定者，被绑定者（多个）三个对象。2》动态绑定。

        1、绑定者：父接口，被绑定者：Set，List，使用者：这里没有做实验。

         2、动态绑定，未做实验

      具有同样的方法size()

    public interface Collection<E> extends Iterable<E> {}

        int size();    

    public interface Set<E> extends Collection<E> {}

               int size();

      public interface List<E> extends Collection<E> {

              int size();

       绑定者（父类）：Collection

       被绑定者（子类）：Set

       被绑定者（子类）：List

       使用者，动态绑定：未做实验