多态性 polymorphism

多态性, polymorphism, /pɑlɪˈmɔrfɪzm/

什么是多态多态的概念：多态（Polymorphism）这个概念最早来自于生物学，表示的是同一物种在同一种群中存在两种或多种明显不同的表型。比如：在南美种群中存在两种颜色的美洲虎：浅黄色的和黑色的。

而在面向对象编程思想中，这个概念表达的是具有共性的类型，在执行相同的行为时，会体现出不同的实现方式。我们可以简称为：相同的行为，不同的实现。比如：同样看到对面过来一个美女，男人和女人的想法是不一样的。

https://hyktech.gitee.io/javatech/2017/09/01/%E5%A4%9A%E6%80%81/

多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。

从广义上说，多态性是指一段程序能够处理多种类型对象的能力。在 c++ 语言中，这种多态性可以通过强制多态、重载多态、类型参数化多态、包含多态4种形式来实现。

类型参数化多态和包含多态统称为一般多态性，用来系统地刻画语义上相关的一组类型。重载多态和强制多态统称为特殊多态性，用来刻画语义上无关联的类型间的关系。

包含多态是指通过子类型化，1个程序段既能处理类型t的对象，也能够处理类型t的子类型s的对象，该程序段称为多态程序段。公有继承能够实现子类型。在包含多态中，1个对象可以被看作属于不同的类，其间包含关系的存在意味着公共结构的存在。包含多态在不少语言中存在，如整数类型中的子集构成1个子类型。每一个子类型中的对象可以被用在高一级的类型中，高一级类型中的所有操作可用于下一级的对象。在c++中公有继承关系是一种包含多态，每一个类可以直接公有继承父类或多个父类，

类型参数化多态是指当1个函数(类)统一地对若干类型参数操作时，这些类型表现出某些公共的语义特性，而该函数(类)就是用来描述该特性的。在类型参数化多态中，1个多态函数(类)必须至少带有1个类型参数，该类型参数确定函数(类)在每次执行时操作数的类型。这种函数(类)也称类属函数(类)。类型参数化多态的应用较广泛，被称为最纯的多态。

重载是指用同一个名字命名不同的函数或操作符。函数重载是c++对一般程序设计语言中操作符重载机制的扩充，它可使具有相同或相近含义的函数

用相同的名字，只要其参数的个数、次序或类型不一样即可

java 多态:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

class A {
   
public String show(D obj) {
   
return "A and D";
   
}

public String show(A obj) {
   
return "A and A";
   
}
  
}

class B extends A {
   
public String show(B obj) {
   
return "B and B";
   
}

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

class C extends B {
  
}

class D extends B {
  
}
  
public class Test {
   
public static void main(String[] args) {
   
A a1 = new A();
   
A a2 = new B();
   
B b = new B();
   
C c = new C();
   
D d = new D();
   
System.out.println(a1.show(b));
   
System.out.println(a1.show(c));
   
System.out.println(a1.show(d));
   
System.out.println(a2.show(b));
   
System.out.println(a2.show(c));
   
System.out.println(a2.show(d));
   
System.out.println(b.show(b));
   
System.out.println(b.show(c));
   
System.out.println(b.show(d));
   
}
  
}

问题: 以下输出结果是什么？

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
A a1 = new A();
A a2 = new B();
B b = new B();
C c = new C();
D d = new D();
System.out.println(a1.show(b));   ①
System.out.println(a1.show(c));   ②
System.out.println(a1.show(d));   ③
System.out.println(a2.show(b));   ④
System.out.println(a2.show(c));   ⑤
System.out.println(a2.show(d));   ⑥
System.out.println(b.show(b));     ⑦
System.out.println(b.show(c));     ⑧
System.out.println(b.show(d));     ⑨

答案

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
①   A and A
  
②   A and A
  
③   A and D
  
④   B and A
  
⑤   B and A
  
⑥   A and D
  
⑦   B and B
  
⑧   B and B
  
⑨   A and D

分析

①②③比较好理解，一般不会出错。④⑤就有点糊涂了，为什么输出的不是"B and B"呢？！！先来回顾一下多态性。

运行时多态性是面向对象程序设计代码重用的一个最强大机制，动态性的概念也可以被说成"一个接口，多个方法”。Java实现运行时多态性的基础是动态方法调度，它是一种在运行时而不是在编译期调用重载方法的机制。

方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写(Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被"屏蔽"了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型。

当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。 (但是如果强制把超类转换成子类的话，就可以调用子类中新添加而超类没有的方法了。)

好了，先温习到这里，言归正传！实际上这里涉及方法调用的优先问题，优先级由高到低依次为: this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。让我们来看看它是怎么工作的。

比如④，a2.show(b)，a2是一个引用变量，类型为A，则this为a2，b是B的一个实例，于是它到类A里面找show(B obj)方法，没有找到，于是到A的super(超类)找，而A没有超类，因此转到第三优先级this.show((super)O)，this仍然是a2，这里O为B，(super)O即(super)B即A，因此它到类A里面找show(A obj)的方法，类A有这个方法，但是由于a2引用的是类B的一个对象，B覆盖了A的show(A obj)方法，因此最终锁定到类B的show(A obj)，输出为"B and A”。

再比如⑧，b.show(c)，b是一个引用变量，类型为B，则this为b，c是C的一个实例，于是它到类B找show(C obj)方法，没有找到，转而到B的超类A里面找，A里面也没有，因此也转到第三优先级this.show((super)O)，this为b，O为C，(super)O即(super)C即B，因此它到B里面找show(B obj)方法，找到了，由于b引用的是类B的一个对象，因此直接锁定到类B的show(B obj)，输出为"B and B”。

按照上面的方法，可以正确得到其他的结果。

问题还要继续，现在我们再来看上面的分析过程是怎么体现出蓝色字体那句话的内涵的。它说: 当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。还是拿a2.show(b)来说吧。

a2是一个引用变量，类型为A，它引用的是B的一个对象，因此这句话的意思是由B来决定调用的是哪个方法。因此应该调用B的show(B obj)从而输出"B and B"才对。但是为什么跟前面的分析得到的结果不相符呢？！问题在于我们不要忽略了蓝色字体的后半部分，那里特别指明: 这个被调用的方法必须是在超类中定义过的，也就是被子类覆盖的方法。B里面的show(B obj)在超类A中有定义吗？没有！那就更谈不上被覆盖了。实际上这句话隐藏了一条信息: 它仍然是按照方法调用的优先级来确定的。它在类A中找到了show(A obj)，如果子类B没有覆盖show(A obj)方法，那么它就调用A的show(A obj) (由于B继承A，虽然没有覆盖这个方法，但从超类A那里继承了这个方法，从某种意义上说，还是由B确定调用的方法，只是方法是在A中实现而已) ；现在子类B覆盖了show(A obj)，因此它最终锁定到B的show(A obj)。这就是那句话的意义所在。

http://blog.csdn.net/thinkghoster/article/details/2307001

Go 多态

https://zhuanlan.zhihu.com/p/59749625

多态

多态是指代码可以根据类型的具体实现采取不同行为的能力。

因为任何用户定义的类型都可以实现任何接口，所以通过不同实体类型对接口值方法的调用就是多态。

/* 多态行为的例子 */ package main

import “fmt”

type notifer interface { notify() }

type user struct { name string email string }

type admin struct { name string age int }

type ad struct { name string age int }

//使用指针接收者实现了notofy接口,方法会共享接收者所指向的值user func (u *user) notify() { fmt.Println(“sendNotify to user”, u.name) }

//使用值接收者实现了notofy接口,方法使用u值的副本,对u的修改不会影响原值 func (u admin) notify(){ fmt.Println(“sendNotify to admin:", u.name) }

//接收一个notifer接口类型的值，如果一个实体类型实现了该接口， //sendNotify函数会根据实体类型的值类执行notifer接口的notify行为，这个函数具有多态的能力。 func sendNotify(n notifer){ n.notify() }

func main() { user1 := user{“张三”, “qq@qq.com”} sendNotify(&user1)

user2 := admin{“李四”, 25} sendNotify(user2)

var n notifer n = &user1 n.notify() } 继承

通过将struct的字段里面声明为匿名字段（所有内置类型和自定义类型），能够实现对字段以及字段类型实现的方法的继承。

package main import “fmt”

type person struct { name string age int }

//如果一个struct嵌入另一个匿名结构体，就可以直接访问匿名结构体的字段或方法，从而实现继承 type student struct { person //匿名字段 number string }

//如果一个struct嵌套了另一个【有名】的结构体，叫做组合 type teacher struct { p person //有名字段 mobile string }

func (p *person) run(){ fmt.Println(p.name, " person run”) }

func (s *student) reading(){ fmt.Println(s.name, " student reading”) }

func main(){

s := student{person{“lisi”, 20}, “000”} fmt.Println(s.name) //访问结构体的【匿名】字段，student对象没有name字段，访问的是从person继承过来的name字段 s.run() //访问结构体的【匿名】字段实现的方法，虽然student对象没有实现run方法，但student继承了person，person类型实现的方法能被直接访问

t := teacher{person{“wangwu”, 25}, “111”} fmt.Println(t.p.name) //访问【有名】结构体的字段。不是继承，不能被直接访问，需要指定结构体 t.p.run() }

Contents