java怎么理解多态(JAVA多态的理解)

多态性：顾名思义就是拥有“多种形态”的含义，是指属性或方法在子类中表现为多种形态。在JAVA中有两种多态是指：运行时多态和编译时多态。多态性是面向对象的核心特征之一,类的多态性提供类中成员设计的灵活性和方法执行的多样性。多态指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。（发送消息就是函数调用）实现多态的技术称为：动态绑定（dynamic binding），是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。扩展资料:多态的好处：1、可替换性（substitutability）多态对已存在代码具有可替换性。例如，多态对圆Circle类工作，对其他任何圆形几何体，如圆环，也同样工作。2、可扩充性（extensibility）多态对代码具有可扩充性。增加新的子类不影响已存在类的多态性、继承性，以及其他特性的运行和操作。实际上新加子类更容易获得多态功能。3、接口性（interface-ability）多态是超类通过方法签名，向子类提供了一个共同接口，由子类来完善或者覆盖它而实现的。4、灵活性（flexibility）它在应用中体现了灵活多样的操作，提高了使用效率。5、简化性（simplicity）多态简化对应用软件的代码编写和修改过程，尤其在处理大量对象的运算和操作时，这个特点尤为突出和重要。参考资料:百度百科-多态
java中多态性是指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。（发送消息就是函数调用）java的多态分为两种：a. 编译时多态：方法的重载。b. 运行时多态：JAVA运行时系统根据调用该方法的实例的类型来决定选择调用哪个方法则被称为运行时多态。（我们平时说得多的事运行时多态，所以多态主要也是指运行时多态）。扩展资料：java中多态性的好处：1、可替换性（substitutability）。多态对已存在代码具有可替换性。例如，多态对圆Circle类工作，对其他任何圆形几何体，如圆环，也同样工作。2、可扩充性（extensibility）。多态对代码具有可扩充性。增加新的子类不影响已存在类的多态性、继承性，以及其他特性的运行和操作。实际上新加子类更容易获得多态功能。例如，在实现了圆锥、半圆锥以及半球体的多态基础上，很容易增添球体类的多态性。3、接口性（interface-ability）。多态是超类通过方法签名，向子类提供了一个共同接口，由子类来完善或者覆盖它而实现的。4、灵活性（flexibility）。它在应用中体现了灵活多样的操作，提高了使用效率。5、简化性（simplicity）。多态简化对应用软件的代码编写和修改过程，尤其在处理大量对象的运算和操作时，这个特点尤为突出和重要。
理论解释：多态性，分静态多态性和动态多态性两种。多态性：顾名思义就是拥有“多种形态”的含义，是指属性或方法在子类中表现为多种形态。静态多态性：包括变量的隐藏、方法的重载(指同一个类中，方法名相同[方便记忆]，但是方法的参数类型、个数、次序不同，本质上是多个不同的方法)；动态多态性：是指子类在继承父类(或实现接口)时重写了父类(或接口)的方法，程序中用父类(或接口)引用去指向子类的具体实例，从代码形式上看是父类(或接口)引用去调用父类(接口)的方法，但是在实际运行时，JVM能够根据父类(或接口)引用所指的具体子类，去调用对应子类的方法，从而表现为不同子类对象有多种不同的形态。不过，程序代码在编译时还不能确定调用的哪一个类的方法，只有在运行时才能确定，故又称为运行时的多态性。例子：举例子说明一下：#include std::cout;class A{public:virtual void test() { cout<<"aaa"<test();}在Class A的test函数前加上virtual，即在运行时多态的时候，程序输出结果为：ccc在Class A的test函数前不加virtual，即在编译时多态的时候，程序输出结果为：aaa扩展资料：C++的多态性：在基类的函数前面加上Virtual关键字，在派生类中重写该函数，运行时将会根据对象的实际类型来调用相应的函数。如果对象类型是派生类，就调用派生类的函数；如果对象类型是基类，就调用基类的函数。参考资料：百度百科-多态性
java中多态性解释：1、多态性是面向对象编程的又一个重要特征，它是指在父类中定义的属性和方法被子类继承之后，可以具有不同的数据类型或表现出不同的行为，这使得同一个属性或方法在父类及其各个子类中具有不同的含义。2、对面向对象来说，多态分为编译时多态和运行时多态。其中编译时多态是静态的，主要是指方法的重载，它是根据参数列表的不同来区分不同的方法。通过编译之后会变成两个不同的方法，在运行时谈不上多态。而运行时多态是动态的，它是通过动态绑定来实现的，也就是大家通常所说的多态性。扩展资料：Java 实现多态有的3必要条件：继承、重写和向上转型。只有满足这 3 个条件，开发人员才能够在同一个继承结构中使用统一的逻辑实现代码处理不同的对象，从而执行不同的行为。1、继承：在多态中必须存在有继承关系的子类和父类。2、重写：子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法。3、向上转型：在多态中需要将子类的引用赋给父类对象，只有这样该引用才既能可以调用父类的方法，又能调用子类的方法。
多态性：顾名思义就是拥有“多种形态”的含义，是指属性或方法在子类中表现为多种形态。它包括两种类型：1、静态多态性：包括变量的隐藏、方法的重载(指同一个类中，方法名相同[方便记忆]，但是方法的参数类型、个数、次序不同，本质上是多个不同的方法)。2、动态多态性：是指子类在继承父类(或实现接口)时重写了父类(或接口)的方法，程序中用父类(或接口)引用去指向子类的具体实例，从代码形式上看是父类(或接口)引用去调用父类(接口)的方法，但是在实际运行时，JVM能够根据父类(或接口)引用所指的具体子类，去调用对应子类的方法。从而表现为不同子类对象有多种不同的形态。不过，程序代码在编译时还不能确定调用的哪一个类的方法，只有在运行时才能确定，故又称为运行时的多态性。扩展资料：C++中，实现多态有以下方法：虚函数，抽象类，覆盖，模板（重载和多态无关）。OC中的多态：不同对象对同一消息的不同响应.子类可以重写父类的方法多态允许方法重名 参数或返回值可以是父类型传入或返回。多态也指生物学中腔肠动物的特殊的生活方式。水螅态与水母态的世代交替现象。把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，以适应需求的不断变化。赋值之后，父类型的引用就可以根据当前赋值给它的子对象的特性以不同的方式运作。也就是说，父亲的行为像儿子，而不是儿子的行为像父亲。举个例子：从一个基类中派生，响应一个虚命令，产生不同的结果。比如从某个基类派生出多个子类，其基类有一个虚方法Tdoit，然后其子类也有这个方法，但行为不同，然后这些子类对象中的任何一个可以赋给其基类对象的引用。实际上你是在通过其基类的引用来访问其子类对象的，你要做的就是一个赋值操作。参考资料：百度百科-多态

多态你可以从字面上去理解，一个类表现出多种形态。它是一种编码的技巧而不是写代码的格式或者方式。 要想理解多态你需要从需求入手。伪代码例子：void method（Father instance）: instance.callmethod();现在有两个子类 girl 和 boy . 如果我传入给method的对象是girl，那么instance.callmethod()是否就等同于girl.callmethod(),如果传入的是boy，就等同于boy.callmethod().但是对于程序而言，表达式一直都是 void method（Father instance）: instance.callmethod();没有改变过只不过通过传入不同的子类对象使这样一个表达式表现出了多种“类的形态”。这样的现象就叫做多态。 多态在软件结构设计上是非常重要的一个抽象意识1：多态用于解决if,else 现代的编程技巧要求对于某一个函数专注于解决一类型的事情。这就要求一个函数中要尽量的避免出现>1个if，那么如果程序出现了分支而又要避免使用if应该怎么办呢。那就是多态最经常出现的场景。看下面的一个2：多态用于隐藏函数的具体内容在面向对象高度结构化的开发中，软件根据功能的不同需要分为各种模块分别交给不同的人开发。那么如果同一个接口描述一类情况显然是非常高明的。最明显的例子就是大家最常用的System,out.println(Object).初学者可能每天都在使用这样一个多态，但是却不知道这个是多态。System,out.println();无论你输入的是一个string,object,int,array,float都可以正常输出内容。为什么，因为所有的你string,Intege,array,Float都是Object的子类，根据填入参数的类型，System,out,println()就表现出了各种输出功能的形态。说了这么多希望你能够理解。 多态可以通过接口和继承来实现。 一个接口可以对应多个实现 （1vN : 多态的数学描述，1个形态代表多个形态）继承：一个父类可以有多个子类 （1vN : 多态的数学描述，1个形态代表多个形态）
我也不知道我写的是什么 不过可能是你要的答案 B b=new B(); C c=new C();A a=b;a.paint();a=c;a.paint();abstract class A{void paint(){System.out.println(getClass()+":"+"paint A");}}class B extends A{void paint(){System.out.println("B");}}class C extends A{ }
多态,就是重载和重写.重载发生在一个类中.重写发生在子类,意思就是子类重写父类相同名称的方法.刚学语言有的东西,不必搞得那么清楚,只有知道怎么用就行了,有的问题你要想真正把它搞得很懂,短时间是不可能的,比如说接口,没有几年工作经验你根本不可能真正理解什么是接口,甚至有的人工作四,五年也没搞明白什么是接口,不要花太多时间去搞这些不容易搞懂的问题. 重载的特性,方法名相同.返回类型,传入方法的参数不同(包括个数和类型). 重写的特性,方法名相同,返回类型,参数均相同,必须发生在子类.

方法的重写和重载是Java多态性的不同表现。 重写是父类与子类之间多态性的一种表现。重载是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载。并且重载的方法是可以改变返回值的类型的。应该能懂了吧…………我给你解释下多态的意思多态，我觉得它的作用就是用来将接口和实现分离开，改善代码的组织结构，增强代码的可读性。以下是我对多态的小结1. Java中除了static和final方法外，其他所有的方法都是运行时绑定的。在我另外一篇文章中说到private方法都被隐式指定为final 的，因此final的方法不会在运行时绑定。当在派生类中重写基类中static、final、或private方法时，实质上是创建了一个新的方法。2.在派生类中，对于基类中的private方法，最好采用不同的名字。3.包含抽象方法的类叫做抽象类。注意定义里面包含这样的意思，只要类中包含一个抽象方法，该类就是抽象类。抽象类在派生中就是作为基类的角色，为不同的子类提供通用的接口。4.对象清理的顺序和创建的顺序相反，当然前提是自己想手动清理对象，因为大家都知道Java垃圾回收器。5.在基类的构造方法中小心调用基类中被重写的方法，这里涉及到对象初始化顺序。6.构造方法是被隐式声明为static方法。7.用继承表达行为间的差异，用字段表达状态上的变化。为了给你讲明白，我再给你写端例子/*** 定义一个基类*/public Class Parents {public void print() {System.out.println(“parents”);}}/*** 定义两个派生类*/public Class Father extends Parents {public void print() {System.out.println(“father”);}}public Class Mother extends Parents {public void print() {System.out.println(“mother”);}}/*** 测试输出结果的类*/public Class Test {public void find(Parents p) {p.print();}public static void main(String[] args) {Test t = new Test();Father f = new Father();Mother m = new Mother();t.find(f);t.find(m);}} 最后的输出结果分别是father和mother，将派生类的引用传给基类的引用，然后调用重写方法，基类的引用之所以能够找到应该调用那个派生类的方法，就是因为程序在运行时进行了绑定。
我举例吧 假设中国人（子类） 继承自 人（基类）人（基类）定义了一个函数叫“吃晚饭”（可以定义为用手抓饭）如果这个函数不是virtual的话那么 下列代码Person p = new Chinese();p.EatDinner();调用的是 人（基类）的“吃晚饭” 而不是中国人的吃饭习惯而 如果这个函数是virtual的话那么 同样的代码p.EatDinner();调用的是 中国人的“吃晚饭”函数 也就是用筷子吃面等等具体的内部实现呢 是基类有一个虚函数表记录所有的virtual函数这样 如果子类把基类的virtual函数给实现了（有自己的一套吃饭办法）那么 虚函数表里的这个函数就指向子类的那个函数否则 就指向基类 这就是“晚绑定”——不在编译期间 而是运行期绑定子类已经覆盖的函数
数据抽象、继承和多态是面向对象程序设计语言的三大特性。多态，我觉得它的作用就是用来将接口和实现分离开，改善代码的组织结构，增强代码的可读性。在某些很简单的情况下，或许我们不使用多态也能开发出满足我们需要的程序，但大多数情况，如果没有多态，就会觉得代码极其难以维护。 关于java的多态，有的书上是这样讲的，它讲java的多态分成静态的多态，和动态的多态，而所谓静态的多态就是只函数的重载，动态的多态就是方法的覆写。 在Java中多态就是在讨论方法调用的绑定，绑定就是将一个方法调用同一个方法主体关联起来。在C语言中，方法(在C中称为函数)的绑定是由编译器来实现的，在英文中称为early binding(前期绑定)，因此，大家自然就会想到相对应的late binding(后期绑定)，这在Java中通常叫做run-time binding(运行时绑定)，我个人觉得这样称呼更贴切，运行时绑定的目的就是在代码运行的时候能够判断对象的类型。

多太就是，现实中的东西具有相同的行为，但行为的内部实现逻辑却不相同。举个例子，就如汽车会跑，但是有的汽车是前轮驱动，有的是后轮驱动。再譬如，足球场上的进球，可以抽射进球，也可以任意球，还可以点球。
这个问题很笼统，给你个提示吧，是面试的时候，总结的：你可以整体上从属性、方法、类三个方面分析多态，然后就会很清晰了。
方法的重写和重载是Java多态性的不同表现。 重写指子类方法与父类有相同的名称和参数，子类对象使用这个方法时调用子类中的定义，父类中的定义被屏蔽。 重载指类中定义了多个同名方法，有不同的参数个数、参数类型。
多态（polymorphism） 是多种形态的意思，比较抽象。 你最好到这里去看一下“http://hi.baidu.com/lyongliang3/blog/item/ea412b167893f700c83d6d1b.html ”

多态性是指允许不同类的对象对同一消息作出响应，多态性包括参数化多态性和包含多态性，多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。 多态有两种表现形式：重载和覆盖1、首先说重载（overload），是发生在同一类中，与什么父类子类、继承毫无关系。标识一个函数除了函数名外，还有函数的参数（个数和类型），也就是说，一个类中可以有两个或更多的函数，叫同一个名字而他们的参数不同。他们之间毫无关系，是不同的函数，只是可能他们的功能类似，所以才命名一样，增加可读性，仅此而已！2、再说覆盖(override),是发生在子类中，也就是说必须有继承的情况下才有覆盖发生。继承一个类，也就有了父类了全部方法，如果你感到哪个方法不爽，功能要变，那就把那个函数在子类中重新实现一遍。 这样再调用这个方法的时候，就是执行子类中的过程了，父类中的函数就被覆盖了。
多态具体表现在重写和重载，多态就是类的多种表现方式，比如同名不同参。 多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。首先说重载（overload），是发生在同一类中。与什么父类子类、继承毫无关系。标识一个函数除了函数名外，还有函数的参数（个数和类型）。也就是说，一个类中可以有两个或更多的函数，叫同一个名字而他们的参数不同。 再说重写(override),是发生在子类中！也就是说必须有继承的情况下才有重写发生
Java多态是java的多种实现方式，指在bai程序运行过程中由虚拟机确定到du底该使用哪种形态完成指定行为的一个过程。 实现多态的三个条件（前提条件，向上转型、向下转型）1、继承的存在；（继承是多态的基础，没有继承就没有多态）2、子类重写父类的方法。（多态下会调用子类重写后的方法）3、父类引用变量指向子类对象。（涉及子类到父类的类型转换）向上转型Student person = new Student()将一个父类的引用指向一个子类对象，成为向上转型，自动进行类型转换。此时通过父类引用变量调用的方法是子类覆盖或继承父类的方法，而不是父类的方法此时通过父类引用变量无法调用子类特有的方法。向下转型Student stu = (Student)person;将一个指向子类对象的引用赋给一个子类的引用，成为向下转型，此时必须进行强制类型转换。向下转型必须转换为父类引用指向的真实子类类型，，否则将出现ClassCastException，不是任意的强制转换 向下转型时可以结合使用instanceof运算符进行强制类型转换，比如出现转换异常---ClassCastException
将参数定义为一个父类，各子类中都重写了父类的方法，在方法中用传入的父类对象调用这个方法。当传入什么子类时就会调用相应的各子类的方法。这就是多态。 具体的例子代码书上有很多就不列出来了
首先表明观点，重载不是java多态的一种体现。java的多态是指在程序运行过程中由虚拟机确定到底该使用哪种形态完成指定行为的一个过程。如下:Parent p = new Son();p.speak();如果在Son中对父类speak()方法进行了重写，那么当你代码写到这里时，编译器是不知道要执行Parent中的speak()还是Son中的speak()方法的，编译器只知道这样写不会发生语法错误；只有在运行过程中才会根据实际在内存中(堆)创建的对象去执行相应的方法如果重载是多态，那我问你，当你在代码中写上某个重载的方法后，此时编译器不是已经确定了到底是哪个方法在完成你的功能吗？这仅仅是编译期，程序还没有运行呢。我还看到一些关于多态的其他说法，比如:编译时多态，运行时多态。而这种观点普遍认为重载就是多态体现的一种，因为重载算是编译时多态，而运行时多态中就是我上面写的那个例子。借用一句《Java编程思想》作者Bruce Eckel的话:"不要犯傻，如果它不是晚绑定，它就不是多态"。这里的晚绑定就是指动态绑定，早绑定就是指静态绑定，也就是所谓的重载。具体如何理解，网上关于这方面的讨论一大堆，各位自行参考。