「java强制多态」多态Java

本篇文章给大家谈谈java强制多态，以及多态Java对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

• 1、java中多态是什么意思？
• 2、java的多态怎么理解啊，多态有什么用途。
• 3、java 多态怎么回事，如何实现？

java中多态是什么意思？

多态（Polymorphism）按字面的意思就是“多种状态”。在面向对象语言中，接口的多种不同的实现方式即为多态。引用Charlie Calverts对多态的描述——多态性是允许你将父对象设置成为一个或更多的他的子对象相等的技术，赋值之后，

父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作（摘自“Delphi4 编程技术内幕”）。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。多态性在Object Pascal和C++中都是通过虚函数实现的。

多态指同一个实体同时具有多种形式。它是面向对象程序设计（OOP）的一个重要特征。如果一个语言只支持类而不支持多态，只能说明它是基于对象的，而不是面向对象的。C++中的多态性具体体现在运行和编译两个方面。

运行时多态是动态多态，其具体引用的对象在运行时才能确定。编译时多态是静态多态，在编译时就可以确定对象使用的形式。

多态：同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。在运行时，可以通过指向基类的指针，来调用实现派生类中的方法。

C++中，实现多态有以下方法：虚函数，抽象类，覆盖，模板（重载和多态无关）。

OC中的多态：不同对象对同一消息的不同响应.子类可以重写父类的方法

多态就是允许方法重名 参数或返回值可以是父类型传入或返回。

扩展资料：

把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，以适应需求的不断变化。

赋值之后，父类型的引用就可以根据当前赋值给它的子对象的特性以不同的方式运作。也就是说，父亲的行为像儿子，而不是儿子的行为像父亲。

比如从某个基类派生出多个子类，其基类有一个虚方法Tdoit，然后其子类也有这个方法，但行为不同，然后这些子类对象中的任何一个可以赋给其基类对象的引用，或者说将子对象地址赋给基类指针，这样其基类的对象就可以执行不同的操作了。

实际上你是在通过其基类的引用来访问其子类对象的，你要做的就是一个赋值操作。

使用继承性的结果就是当创建了一个类的家族，在认识这个类的家族时，就是把子类的对象当作基类的对象，这种认识又叫作upcasting（向上转型）。这样认识的重要性在于：我们可以只针对基类写出一段程序，但它可以适应于这个类的家族，

因为编译器会自动找出合适的对象来执行操作。这种现象又称为多态性。而实现多态性的手段又叫称动态绑定(dynamic binding)。

参考资料：百度百科-多态

java的多态怎么理解啊，多态有什么用途。

1. Java中除了static和final方法外，其他所有的方法都是运行时绑定的。private方法都被隐式指定为final的，因此final的方法不会在运行时绑定。当在派生类中重写基类中static、final、或private方法时，实质上是创建了一个新的方法。

2.在派生类中，对于基类中的private方法，最好采用不同的名字。

3.包含抽象方法的类叫做抽象类。注意定义里面包含这样的意思，只要类中包含一个抽象方法，该类就是抽象类。抽象类在派生中就是作为基类的角色，为不同的子类提供通用的接口。

4.对象清理的顺序和创建的顺序相反，当然前提是自己想手动清理对象，因为大家都知道Java垃圾回收器。

5.在基类的构造方法中小心调用基类中被重写的方法，这里涉及到对象初始化顺序。

6.构造方法是被隐式声明为static方法。

7.用继承表达行为间的差异，用字段表达状态上的变化。

在JAVA中有两种多态是指：运行时多态和编译时多态。

关于类的多态性简介如下：

多态(polymorphism)意为一个名字可具有多种语义.在程序设计语言中,多态性是指”一种定义,多种实现”.例如,运算符+有多种含义,究竟执行哪种运算取决于参加运算的操作数类型:

1+2 //加法运算符

“1” + “2” //字符串连接运算,操作数是字符串

多态性是面向对象的核心特征之一,类的多态性提供类中成员设计的灵活性和方法执行的多样性.

1、类多态性表现

(1)方法重载

重载表现为同一个类中方法的多态性.一个类生命多个重载方法就是为一种功能提供多种实现.编译时,根据方法实际参数的数据类型\个数和次序,决定究竟应该执行重载方法中的哪一个.

(2)子类重定义从父类继承来的成员

当子类从父类继承来的成员不适合子类时,子类不能删除它们,但可以重定义它们,使弗雷成员适应子类的新需求.子类重定义父类成员,同名成员在父类与子类之间表现出多态性,父类对象引用父类成员,子类对象引用子类成员,不会产生冲突和混乱.

子类可重定义父类的同名成员变量,称子类隐藏父类成员变量.子类也可以重定义父类的同名成员方法，当子类方法的参数列表与父类方法参数列表完全相同时，称为子类方法覆盖（override）父类方法。覆盖父类方法时，子类方法的访问权限不能小于父类方法的权限。

由于Object类的equals()方法比较两个对象的引用是否相等而不是值是否相等,因此一个类要覆盖Object类的equals()方法,提供本类两个对象比较相等方法.

覆盖表现为父类与子类之间方法的多态性.java 寻找执行方法的原则是:从对象所属的类开始,寻找匹配的方法执行,如果当前类中没有匹配的方法,则逐层向上依次在父类或祖先类中寻找匹配方法,直到Object类.

2、super 引用

在子类的成员方法中,可以使用代词super引用父类成员.super引用的语法如下:

super([参数列表]) //在子类的构造方法体中,调用父类的构造方法

super.成员变量 //当子类隐藏父类成员变量时,引用父类同名成员变量

super.成员方法([参数列表]) //当子类覆盖父类成员方法时,调用父类同名成员方法

*注意:super引用没有单独使用的语法

3、多态性有两种:

1）编译时多态性

对于多个同名方法,如果在编译时能够确定执行同名方法中的哪一个,则称为编译时多态性.

2）运行时多态性

如果在编译时不能确定,只能在运行时才能确定执行多个同名方法中的哪一个,则称为运行时多态性.

方法覆盖表现出两种多态性,当对象获得本类实例时,为编译时多态性,否则为运行时多态性,例如:

XXXX x1 = new XXXX(参数列表); //对象获得本类实例,对象与其引用的实例类型一致

XXX xx1 = new XXX(参数列表);

x1.toString(); //编译时多态性,执行XXX类的方法.

xx1.toString(); //编译时多态性,执行XXXX类覆盖的方法.

XXXX为XXX的父类.

由于子类对象既是父类对象,父类对象与子类对象之间具有赋值相容性,父类对象能够被赋值为子类对象.例如,

XXXX x2 = new XXX(参数列表); //父类对象获得子类实例,子类对象即是父类对象

x2.toString(); //运行时多态

x2声明为父类对象却获得子类XXX的实例,那么x2.toString()究竟执行父类方法还是执行子类覆盖的方法呢?

这分为两种情况:

取决于子类是否覆盖父类方法.如果子类覆盖父类方法,则执行子类方法;

如果没有覆盖,则执行父类方法.

在编译时,仅仅依据对象所属的类,系统无法确定到底应该执行那个类的方法,只有运行时才能确定,因此这是运行时多态.

父类对象并不能执行所有的子类方法,只能执行那些父类中声明\子类覆盖的子类方法.

在这样一个体系中，多态表现出多种形式的能力。通用多态引用有相同结构类型的大量对象，他们有着共同的特征。特定的多态涉及的是小部分没有相同特征的对象。四种多态可做以下描述：

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

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

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

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

我将在讲述子类型多态前简单介绍一下这几种多态。

强制的多态

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

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类的所有参数。

C c = new C();

Derived derived = new Derived();

c.m( derived );

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

重载的多态

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

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

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

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

参数的多态

　 　参数多态允许把许多类型抽象成单一的表示。例如，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开发者们所提及的多态就特指子类型的多态。通过一种面向类型的观点，我们可以看到子类型多态的强大功能。以下的文章中我们将仔细探讨这个问题。为简明起见，下文中的多态均指包含多态。

1个行为,不同的对象,他们具体体现出来的方式不一样,

比如:方法重载 overloading 以及 方法重写(覆盖)override

class Human{

void run(){输出 人在跑}

}

class Man extends Human{

void run(){输出 男人在跑}

}

这个时候,同是跑,不同的对象,不一样(这个是方法覆盖的例子)

class Test{

void out(String str){输出 str}

void out(int i){输出 i}

}

这个例子是方法重载,方法名相同,参数表不同

ok,明白了这些还不够,还用人在跑举例

Human ahuman=new Man();

这样我等于实例化了一个Man的对象,并声明了一个Human的引用,让它去指向Man这个对象

意思是说,把 Man这个对象当 Human看了.

比如去动物园,你看见了一个动物,不知道它是什么, "这是什么动物? " "这是大熊猫! "

这2句话,就是最好的证明,因为不知道它是大熊猫,但知道它的父类是动物,所以,

这个大熊猫对象,你把它当成其父类 动物看,这样子合情合理.

这种方式下要注意 new Man();的确实例化了Man对象,所以 ahuman.run()这个方法 输出的是 "男人在跑 "

如果在子类 Man下你 写了一些它独有的方法 比如 eat(),而Human没有这个方法,

在调用eat方法时,一定要注意 强制类型转换 ((Man)ahuman).eat(),这样才可以...

对接口来说,情况是类似的...

java 多态怎么回事，如何实现？

出自：

一、基本概念

多态性：发送消息给某个对象，让该对象自行决定响应何种行为。

通过将子类对象引用赋值给超类对象引用变量来实现动态方法调用。

java 的这种机制遵循一个原则：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。

1. 如果a是类A的一个引用，那么，a可以指向类A的一个实例,或者说指向类A的一个子类。

2. 如果a是接口A的一个引用，那么,a必须指向实现了接口A的一个类的实例。

二、Java多态性实现机制

SUN目前的JVM实现机制，类实例的引用就是指向一个句柄（handle）的指针，这个句柄是一对指针：

一个指针指向一张表格，实际上这个表格也有两个指针（一个指针指向一个包含了对象的方法表，另外一个指向类对象，表明该对象所属的类型）；

另一个指针指向一块从java堆中为分配出来内存空间。

The Java Virtual Machine does not require any particular internal structure for objects. In Sun 's current implementation of the Java Virtual Machine, a reference to a class instance is a pointer to a handle that is itself a pair of pointers: one to a table containing the methods of the object and a pointer to the Class object that represents the type of the object, and the other to the memory allocated from the Java heap for the object data. （jvm规范中关于对象内存布局的说明）

三、总结

1、通过将子类对象引用赋值给超类对象引用变量来实现动态方法调用。

DerivedC c2=new DerivedC();

BaseClass a1= c2; //BaseClass 基类，DerivedC是继承自BaseClass的子类

a1.play(); //play()在BaseClass，DerivedC中均有定义，即子类覆写了该方法

分析：

* 为什么子类的类型的对象实例可以覆给超类引用？

自动实现向上转型。通过该语句，编译器自动将子类实例向上移动，成为通用类型BaseClass；

* a.play()将执行子类还是父类定义的方法？

子类的。在运行时期，将根据a这个对象引用实际的类型来获取对应的方法。所以才有多态性。一个基类的对象引用，被赋予不同的子类对象引用，执行该方法时，将表现出不同的行为。

在a1=c2的时候，仍然是存在两个句柄，a1和c2，但是a1和c2拥有同一块数据内存块和不同的函数表。

2、不能把父类对象引用赋给子类对象引用变量

BaseClass a2=new BaseClass();

DerivedC c1=a2;//出错

在java里面，向上转型是自动进行的,但是向下转型却不是，需要我们自己定义强制进行。

c1=(DerivedC)a2; 进行强制转化,也就是向下转型.

3、记住一个很简单又很复杂的规则，一个类型引用只能引用引用类型自身含有的方法和变量。

你可能说这个规则不对的，因为父类引用指向子类对象的时候，最后执行的是子类的方法的。

其实这并不矛盾，那是因为采用了后期绑定，动态运行的时候又根据型别去调用了子类的方法。而假若子类的这个方法在父类中并没有定义，则会出错。

例如，DerivedC类在继承BaseClass中定义的函数外，还增加了几个函数（例如 myFun()）

分析：

当你使用父类引用指向子类的时候，其实jvm已经使用了编译器产生的类型信息调整转换了。

这里你可以这样理解，相当于把不是父类中含有的函数从虚拟函数表中设置为不可见的。注意有可能虚拟函数表中有些函数地址由于在子类中已经被改写了，所以对象虚拟函数表中虚拟函数项目地址已经被设置为子类中完成的方法体的地址了。

配合这到体有助理解：

关于java强制多态和多态Java的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。