面向对象非常非常重要的一个特性“多态”的学习笔记

最新推荐文章于 2024-07-27 17:56:15 发布

蓝色的天空下

最新推荐文章于 2024-07-27 17:56:15 发布

阅读量742

点赞数

文章标签： java 编译器 string null 2010 sun

本文链接：https://blog.csdn.net/duliming1987/article/details/6523492

版权

今天上软件工程课程，今天讲滴是“面向对象方法学”。讲到面向对象的三大特性：继承、封装、多态。哎！同学，这个是已经耳熟能详的概念了，都成顺口溜了。老师让我们解释一下什么是多态，要求用现实生活中的例子举例一下。我首先想到了JAVA中的重载机制。嘿嘿，但是呢。回答并没得到老师的肯定哦。也不是说不对。

回来赶紧找资料。关于面向对象多态性的讲解。翻了不少，似乎算是明白一点点啦。先把这些记录下来，以后再有更多体会往上加。

看完多态特性以后，写了一个例子：

Code:

package polymorphic;
abstract class People{
public String name;
public String sex;
public abstract void eat();
public abstract void run();
public abstract void sleep();
}
class Student extends People{
@Override
public void eat() {
// TODO Auto-generated method stub
System.out.println("学生在学生食堂吃饭！");
}
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("学生在操场跑步！");
}
@Override
public void sleep() {
// TODO Auto-generated method stub
System.out.println("学生在学生宿舍睡觉中。。。");
}}
class Teacher extends People{
@Override
public void eat() {
// TODO Auto-generated method stub
System.out.println("教师在教工食堂吃饭！");
}
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("教师在跑步，赶校车回家中。。。");
}
@Override
public void sleep() {
// TODO Auto-generated method stub
System.out.println("教师今天在家里休息！");
}}
public class PeopleAndPolymorphic {
public static void main(String[] args){
People p = null;
Student student = new Student();
Teacher teacher = new Teacher();
p = student;
p.run();
p.sleep();
p = teacher;
p.run();
p.sleep();
p = student;
p.eat();
p = teacher;
p.eat();
}
}

运行结果如下所示：

Code:

学生在操场跑步！
学生在学生宿舍睡觉中。。。
教师在跑步，赶校车回家中。。。
教师今天在家里休息！
学生在学生食堂吃饭！
教师在教工食堂吃饭！

把这段代码再改一下。用接口来实现也能达到同样的效果。

Code:

package polymorphic;
interface People{
public abstract void eat();
public abstract void run();
public abstract void sleep();
}
class Student implements People{
public void eat() {
// TODO Auto-generated method stub
System.out.println("学生在学生食堂吃饭！");
}
public void run() {
// TODO Auto-generated method stub
System.out.println("学生在操场跑步！");
}
public void sleep() {
// TODO Auto-generated method stub
System.out.println("学生在学生宿舍睡觉中。。。");
}}
class Teacher implements People{
public void eat() {
// TODO Auto-generated method stub
System.out.println("教师在教工食堂吃饭！");
}
public void run() {
// TODO Auto-generated method stub
System.out.println("教师在跑步，赶校车回家中。。。");
}
public void sleep() {
// TODO Auto-generated method stub
System.out.println("教师今天在家里休息！");
}}
public class PeopleAndPolymorphic {
public static void main(String[] args){
People p = null;
Student student = new Student();
Teacher teacher = new Teacher();
p = student;
p.run();
p.sleep();
p = teacher;
p.run();
p.sleep();
p = student;
p.eat();
p = teacher;
p.eat();
}
}

运行结果如下所示：

Code:

学生在操场跑步！
学生在学生宿舍睡觉中。。。
教师在跑步，赶校车回家中。。。
教师今天在家里休息！
学生在学生食堂吃饭！
教师在教工食堂吃饭！

再看一个例子：

Code:

package polymorphic;
class Student{
String stuName = null;
public Student(){}
public Student(String name){
this.stuName = name;
}
public void eat() {
// TODO Auto-generated method stub
System.out.println("学生在学生食堂吃饭！");
}
public void eat(String name) {
// TODO Auto-generated method stub
System.out.println("学生 "+ name + "在学生食堂吃饭！");
}
public void run() {
// TODO Auto-generated method stub
System.out.println("学生在操场跑步！");
}
public void run(String name) {
// TODO Auto-generated method stub
System.out.println("学生" + name + "在操场跑步！");
}
public void sleep() {
// TODO Auto-generated method stub
System.out.println("学生在学生宿舍睡觉中。。。");
}
public void sleep(String name) {
// TODO Auto-generated method stub
System.out.println("学生" + name + "在学生宿舍睡觉中。。。");
}
}
public class PeopleAndPolymorphic {
public static void main(String[] args){
Student student = new Student();
student.eat();
student.eat("李明");
student.run();
student.run("李明");
student.sleep();
student.sleep("李明");
}
}

运行结果如下所示：

Code:

学生在学生食堂吃饭！
学生李明在学生食堂吃饭！
学生在操场跑步！
学生李明在操场跑步！
学生在学生宿舍睡觉中。。。
学生李明在学生宿舍睡觉中。。。

这三个例子都是演示多态性的。

第一个和第二个例子可以说成是：

1.、通过继承中超类对象引用变量引用子类对象的实现来体现多态。

2、通过接口类型变量引用实现接口的类的对象的实现来体现多态。

通过第一和第二个例子可以用

http://www.bdqndl.net/html/news/it/20100515121339.html这篇文章中的一句话来总结多态性的概念：

1个行为,不同的对象,他们具体体现出来的方式不一样。 （这句话我觉的是我目前理解的面向对象多态性的一个概括和总结。）

面向对象的三大特性是继承，封装，多态。而多态就是继承的表现。 （恩好好理解这句话！）

第三个例子是做什么的呢？它属于多态性的体现吗？最初我也为的回答感到疑惑，但是是确定的，是多态性的一方面。

那么对面向对象做一个总结吧：

面向对象可以分为静态多态性和动态多态性。

1.静态多态性：是指定义在一个类或者一个函数中的同名函数，它们可以参数表（类型和个数）来区别语义。（C++中通过静态编联实现，java中呢？当然是重载啦！）也可以说成：“编译时的多态性”。

2.动态多态性：是指定义在一个类层次中不同类的重载函数，它们一般具有相同的参数表，因而要根据指针指向的对象所在的类来区别语义。（C++中通过动态编联实现，java中呢？当然是重写啦！）也可以说成：“运行时多态性”。

（有必要解释一下编联、静态编联、动态编联。把函数调用与适当的函数相对应的的动作称为编联。分为静态编联和动态编联，静态编联指在编译阶段决定执行那个同名的被调用函数。动态编联是指在编译阶段不能决定那个同名的函数可以被调用，只有在执行阶段才根据要处理的对象类型来决定来处理那个对象的成员函数。）

JAVA中实现运行时多态的基础是动态方法调度，是一种在运行时而不是在编译时调用重载方法的机制。

http://developer.51cto.com/art/200909/153887.htm这篇文章对多态做的讲解比较清晰点了。

对于更加深入的多态性讲解，我认为在这篇文章里讲的比较具体了。

http://developer.51cto.com/art/201009/225990.htm

这篇文章中说到：

通用多态涉及的是有相同类型的大量对象，且他们有着共同的特性，（比如所有的学生，他们都属于学生类型，有着学生所有的共同的特征，比如“上课”）。特定的多态涉及的是只有小部分没有相同特征的对象（比如学生、老师他们都是人，而又有一些小小的不同）。

那么：什么是强制的、重载的、参数的、包含的多态哩？

强制的：一种隐式做类型转换的方法。

重载的：将一个标志符用作多个意义。

参数的：为不同类型的参数提供相同的操作。

包含的：类包含关系的抽象操作。

强制的多态

强制多态隐式的将参数按某种方法，转换成编译器认为正确的类型以避免错误。在以下的表达式中，编译器必须决定二元运算符‘+’所应做的工作：

2.0 + 2.0

2.0 + 2

2.0 + "2"

第一个表达式将两个double的操作数相加；Java中特别声明了这种用法。

第二个表达式将double型和int相加。Java中没有明确定义这种运算。不过，编译器隐式的将第二个操作数转换为double型，并作double型的加法。做对程序员来说十分方便，否则将会抛出一个编译错误，或者强制程序员显式的将 int转换为double。

第三个表达式将double与一个String相加。Java中同样没有定义这样的操作。所以，编译器将 double转换成String类型，并将他们做串联。

强制多态也会发生在方法调用中。假设类Derived继承了类Base，类C 有一个方法，原型为m(Base)，在下面的代码中，编译器隐式的将Derived类的对象derived转化为Base类的对象。这种隐式的转换使 m(Base)方法使用所有能转换成Base类的所有参数。

1 C c = new C();

3 Derived derived = new Derived();

5 c.m( derived );

并且，隐式的强制转换，可以避免类型转换的麻烦，减少编译错误。当然，编译器仍然会优先验证符合定义的对象类型。

这种强制多态在JAVA编程中是非常非常常见的，今天才明白原来这就叫强制多态哇。

重载的多态

重载允许用相同的运算符或方法，去表示截然不同的意义。‘+’在上面的程序中有两个意思：两个double型的数相加；两个串相连。另外还有整型相加，长整型，等等。这些运算符的重载，依赖于编译器根据上下文做出的选择。以往的编译器会把操作数隐式转换为完全符合操作符的类型。虽然Java明确支持重载，但不支持用户定义的操作符重载。

Java支持用户定义的函数重载。一个类中可以有相同名字的方法，这些方法可以有不同的意义。这些重载的方法中，必须满足参数数目不同，相同位置上的参数类型不同。这些不同可以帮助编译器区分不同版本的方法。

编译器以这种唯一表示的特征来表示不同的方法，比用名字表示更为有效。据此，所有的多态行为都能编译通过。

强制和重载的多态都被分类为特定的多态，因为这些多态都是在特定的意义上的。这些被划入多态的特性给程序员带来了很大的方便。强制多态排除了麻烦的类型和编译错误。重载多态像一块糖，允许程序员用相同的名字表示不同的方法，很方便。

不就是前面说的编译时的多态嘛或者说就是静态多态嘛。呵呵！

资料：http://developer.51cto.com/art/200909/153887.htm（java运行时多态的实现：继承和多态实现java运行时多态）

http://developer.51cto.com/art/200907/136506.htm（通过实例来讨论java多态的实现）

http://developer.51cto.com/art/201009/225990_1.htm（深入java核心 java多态的实现机制）

http://www.cnblogs.com/KiloNet/archive/2009/11/03/1595486.html（面向对象之多态性的一个很有意思的例子）

参数的多态

参数多态允许把许多类型抽象成单一的表示。例如，List 抽象类中，描述了一组具有同样特征的对象，提供了一个通用的模板。你可以通过指定一种类型以重用这个抽象类。这些参数可以是任何用户定义的类型，大量的用户可以使用这个抽象类，因此参数多态毫无疑问的成为最强大的多态。

乍一看，上面抽象类好像是java.util.List的功能。然而，Java实际上并不支持真正的安全类型风格的参数多态，这也是java.util.List和java.util的其他集合类是用原始的 java.lang.Object写的原因（参考我的文章"A Primordial Interface?" 以获得更多细节）。Java的单根继承方式解决了部分问题，但没有发挥出参数多态的全部功能。Eric Allen有一篇精彩的文章“Behold the Power of Parametric Polymorphism”，描述了Java通用类型的需求，并建议给Sun的Java规格需求#000014号文档"Add Generic Types to the Java Programming Language."（参考资源链接）

包含的多态

包含多态通过值的类型和集合的包含关系实现了多态的行为.在包括Java在内的众多面向对象语言中，包含关系是子类型的。所以，Java的包含多态是子类型的多态。

在早期，Java开发者们所提及的多态就特指子类型的多态。通过一种面向类型的观点，我们可以看到子类型多态的强大功能。以下的文章中我们将仔细探讨这个问题。为简明起见，下文中的多态均指包含多态。

蓝色的天空下

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
面向对象非常非常重要的一个特性“多态”的学习笔记

今天上软件工程课程，今天讲滴是“面向对象方法学”。讲到面向对象的三大特性：继承、封装、多态。哎！同学，这个是已经耳熟能详的概念了，都成顺口溜了。老师让我们解释一下什么是多态，要求用现实生活中的例子举例一下。我首先想到了JAVA中的重载机制。嘿嘿，但是呢。回答并没得到老师的肯定哦。也不是说不对。回来赶紧找资料。关于面向对象多态性的讲解。翻了不少，似乎算是明白一点点啦。先把这些记录下来，以后再有更
复制链接

扫一扫