正文

面向工具编程有三大特征：封装、继续、多态。

封装隐藏了类的内部实现机制，可以在不影响使用的情况下改变类的内部结构，同时也珍爱了数据。对外界而已它的内部细节是隐藏的，露出给外界的只是它的接见方式。

继续是为了重用父类代码。两个类若存在IS-A的关系就可以使用继续。同时继续也为实现多态做了铺垫。那么什么是多态呢？多态的实现机制又是什么？请看我逐一为你揭开。

多态

所谓多态就是指程序中界说的引用变量所指向的详细类型和通过该引用变量发出的方式挪用在编程时并不确定，而是在程序运行时代才确定，即一个引用变量倒底会指向哪个类的实例工具，该引用变量发出的方式挪用到底是哪个类中实现的方式，必须在由程序运行时代才气决议。由于在程序运行时才确定详细的类，这样，不用修改源程序代码，就可以让引用变量绑定到种种差别的类实现上，从而导致该引用挪用的详细方式随之改变，即不修改程序代码就可以改变程序运行时所绑定的详细代码，让程序可以选择多个运行状态，这就是多态性。

好比你是一个酒神，对酒情有独钟。某日回家发现桌上有几个杯子内里都装了白酒，从外面看我们是不可能知道这是些什么酒，只有喝了之后才气够猜出来是何种酒。你一喝，这是剑南春、再喝这是五粮液、再喝这是酒鬼酒….在这里我们可以形貌成如下：

酒 a = 剑南春

酒 b = 五粮液

酒 c = 酒鬼酒

…

这里所显示的的就是多态。剑南春、五粮液、酒鬼酒都是酒的子类，我们只是通过酒这一个父类就能够引用差别的子类，这就是多态——我们只有在运行的时刻才会知道引用变量所指向的详细实例工具。

诚然，要明了多态我们就必须要明了什么是“向上转型”。在继续中我们简朴先容了向上转型，这里就在烦琐下：在上面的喝酒例子中，酒(Win)是父类，剑南春(JNC)、五粮液(WLY)、酒鬼酒(JGJ)是子类。我们界说如下代码：

JNC a = new JNC();

对于这个代码我们异常容易明了无非就是实例化了一个剑南春的工具嘛！然则这样呢？

Wine a = new JNC();

在这里我们这样明了，这里界说了一个Wine 类型的a，它指向JNC工具实例。由于JNC是继续与Wine，以是JNC可以自动向上转型为Wine，以是a是可以指向JNC实例工具的。这样做存在一个异常大的利益，在继续中我们知道子类是父类的扩展，它可以提供比父类加倍壮大的功效，若是我们界说了一个指向子类的父类引用类型，那么它除了能够引用父类的共性外，还可以使用子类壮大的功效。

然则向上转型存在一些缺憾，那就是它必定会导致一些方式和属性的丢失，而导致我们不能够获取它们。以是父类类型的引用可以挪用父类中界说的所有属性和方式，对于只存在与子类中的方式和属性它就瞠乎其后了—1。

1 public class Wine {

2 public void fun1(){

3 System.out.println("Wine 的Fun.....");

4 fun2();

5 }

6

7 public void fun2(){

8 System.out.println("Wine 的Fun2...");

9 }

10 }

11

12 public class JNC extends Wine{

13 /**

14 * @desc 子类重写父类方式

15 * 父类中不存在该方式，向上转型后，父类是不能引用该方式的

16 * @param a

17 * @return void

18 */

19 public void fun1(String a){

20 System.out.println("JNC 的 Fun1...");

21 fun2();

22 }

23

24 /**

25 * 子类重写父类方式

26 * 指向子类的父类引用挪用fun2时，必定是挪用该方式

27 */

28 public void fun2(){

29 System.out.println("JNC 的Fun2...");

30 }

31 }

32

33 public class Test {

34 public static void main(String[] args) {

35 Wine a = new JNC();

36 a.fun1();

37 }

38 }

39 -------------------------------------------------

40 Output:

41 Wine 的Fun.....

42 JNC 的Fun2...

从程序的运行效果中我们发现，a.fun1()首先是运行父类Wine中的fun1().然后再运行子类JNC中的fun2()。

剖析：在这个程序中子类JNC重载了父类Wine的方式fun1()，重写fun2()，而且重载后的fun1(String a)与 fun1()不是统一个方式，由于父类中没有该方式，向上转型后会丢失该方式，以是执行JNC的Wine类型引用是不能引用fun1(String a)方式。而子类JNC重写了fun2() ，那么指向JNC的Wine引用会挪用JNC中fun2()方式。

以是对于多态我们可以总结如下：

指向子类的父类引用由于向上转型了，它只能接见父类中拥有的方式和属性，而对于子类中存在而父类中不存在的方式，该引用是不能使用的，只管是重载该方式。若子类重写了父类中的某些方式，在挪用该些方式的时刻，必定是使用子类中界说的这些方式(动态毗邻、动态挪用)。

多态的实现

实现条件

在刚刚开始就提到了继续在为多态的实现做了准备。子类Child继续父类Father，我们可以编写一个指向子类的父类类型引用，该引用既可以处置父类Father工具，也可以处置子类Child工具，当相同的新闻发送给子类或者父类工具时，该工具就会凭据自己所属的引用而执行差别的行为，这就是多态。即多态性就是相同的新闻使得差别的类做出差别的响应。

Java实现多态有三个必要条件：继续、重写、向上转型。

继续：在多态中必须存在有继续关系的子类和父类。

重写：子类对父类中某些方式举行重新界说，在挪用这些方式时就会挪用子类的方式。

向上转型：在多态中需要将子类的引用赋给父类工具，只有这样该引用才气够具备技术挪用父类的方式和子类的方式。

只有知足了上述三个条件，我们才气够在统一个继续结构中使用统一的逻辑实现代码处置差别的工具，从而到达执行差别的行为。

对于Java而言，它多态的实现机制遵照一个原则：当超类工具引用变量引用子类工具时，被引用工具的类型而不是引用变量的类型决议了挪用谁的成员方式，然则这个被挪用的方式必须是在超类中界说过的，也就是说被子类笼罩的方式。

实现形式

在Java中有两种形式可以实现多态。继续和接口。

基于继续实现的多态

基于继续的实现机制主要显示在父类和继续该父类的一个或多个子类对某些方式的重写，多个子类对统一方式的重写可以显示出差别的行为。

1 public class Wine {

2 private String name;

3

4 public String getName() {

5 return name;

6 }

7

8 public void setName(String name) {

9 this.name = name;

10 }

11

12 public Wine(){

13 }

14

15 public String drink(){

16 return "喝的是 " + getName();

17 }

18

19 /**

20 * 重写toString()

21 */

22 public String toString(){

23 return null;

24 }

25 }

26

27 public class JNC extends Wine{

28 public JNC(){

29 setName("JNC");

30 }

31

32 /**

33 * 重写父类方式，实现多态

34 */

35 public String drink(){

36 return "喝的是 " + getName();

37 }

38

39 /**

40 * 重写toString()

41 */

42 public String toString(){

43 return "Wine : " + getName();

44 }

45 }

46

47 public class JGJ extends Wine{

48 public JGJ(){

49 setName("JGJ");

50 }

51

52 /**

53 * 重写父类方式，实现多态

54 */

55 public String drink(){

56 return "喝的是 " + getName();

57 }

58

59 /**

60 * 重写toString()

61 */

62 public String toString(){

63 return "Wine : " + getName();

64 }

65 }

66

67 public class Test {

68 public static void main(String[] args) {

69 //界说父类数组

70 Wine[] wines = new Wine[2];

71 //界说两个子类

72 JNC jnc = new JNC();

73 JGJ jgj = new JGJ();

74

75 //父类引用子类工具

76 wines[0] = jnc;

77 wines[1] = jgj;

78

79 for(int i = 0 ; i < 2 ; i++){

80 System.out.println(wines[i].toString() + "--" + wines[i].drink());

81 }

82 System.out.println("-------------------------------");

83

84 }

85 }

86 OUTPUT:

87 Wine : JNC--喝的是 JNC

88 Wine : JGJ--喝的是 JGJ

89 -------------------------------

在上面的代码中JNC、JGJ继续Wine，而且重写了drink()、toString()方式，程序运行效果是挪用子类中方式，输出JNC、JGJ的名称，这就是多态的显示。差别的工具可以执行相同的行为，然则他们都需要通过自己的实现方式来执行，这就要得益于向上转型了。

以是基于继续实现的多态可以总结如下：对于引用子类的父类类型，在处置该引用时，它适用于继续该父类的所有子类，子类工具的差别，对方式的实现也就差别，执行相同动作发生的行为也就差别。

若是父类是抽象类，那么子类必须要实现父类中所有的抽象方式，这样该父类所有的子类一定存在统一的对外接口，但其内部的详细实现可以各异。这样我们就可以使用顶层类提供的统一接口来处置该条理的方式。

基于接口实现的多态

继续是通过重写父类的统一方式的几个差别子类来体现的，那么就可就是通过实现接口并笼罩接口中统一方式的几差别的类体现的。

在接口的多态中，指向接口的引用必须是指定这实现了该接口的一个类的实例程序，在运行时，凭据工具引用的现实类型来执行对应的方式。

继续都是单继续，只能为一组相关的类提供一致的服务接口。然则接口可以是多继续多实现，它能够行使一组相关或者不相关的接口举行组合与扩充，能够对外提供一致的服务接口。以是它相对于继续来说有更好的灵活性。

如 Map map =new HashMap ; List list=new ArraryList 都是基于接口实现的多态。

经典实例

public classA {publicString show(D obj) {return ("A and D");

}publicString show(A obj) {return ("A and A");

}

}public class B extendsA{publicString show(B obj){return ("B and B");

}publicString show(A obj){return ("B and A");

}

}public class C extendsB{

}public class D extendsB{

}public classTest {public static voidmain(String[] args) {

A a1= newA();

A a2= newB();

B b= newB();

C c= newC();

D d= newD();

System.out.println("1--" +a1.show(b));

System.out.println("2--" +a1.show(c));

System.out.println("3--" +a1.show(d));

System.out.println("4--" +a2.show(b));

System.out.println("5--" +a2.show(c));

System.out.println("6--" +a2.show(d));

System.out.println("7--" +b.show(b));

System.out.println("8--" +b.show(c));

System.out.println("9--" +b.show(d));

}

}

运行效果：

1--A and A2--A and A3--A and D4--B and A5--B and A6--A and D7--B and B8--B and B9--A and D

原文链接：https://www.cnblogs.com/alimayun/p/12910739.html

本站声明:网站内容来源于网络,若有侵权,请联系我们,我们将及时处置。