一看见有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 方法都不能作为多态,因为他们不能动态绑定方法,在编译时已经确定。
找 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
使用者,动态绑定:未做实验