java多態的機制
❶ java中實現多態的機制是什麼
父類A有一個方法function(),子類B,C分別繼承A並且重寫function()，當創建一個對象A b = new B(); b.function()就調用B的funciotn,假如你new C(),那調用的就是C重寫的function。怎麼判斷使用那個類的function就是動態綁定，這個現象就是多態...
❷ java中實現多態的機制
我的理解就是讓父類的引用指向子類的對象，你在使用父類的引用調用方法的時候，不是使用父類中的方法，而是父類指向的對象的方法。這樣就實現了多態···
❸ java 多態怎麼回事，如何實現
出自：http://..com/question/42014727.html
一、基本概念
多態性：發送消息給某個對象，讓該對象自行決定響應何種行為。
通過將子類對象引用賦值給超類對象引用變數來實現動態方法調用。
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已經使用了編譯器產生的類型信息調整轉換了。
這里你可以這樣理解，相當於把不是父類中含有的函數從虛擬函數表中設置為不可見的。注意有可能虛擬函數表中有些函數地址由於在子類中已經被改寫了，所以對象虛擬函數表中虛擬函數項目地址已經被設置為子類中完成的方法體的地址了。
配合這到體有助理解：http://..com/question/123628003.html
❹ java中構成多態的前提是什麼
java中實現多態需要三個條件：
1，需要有繼承關系的存在。
2，需要有方法的重寫。
3，需要有父類的引用指向子類對象。
java學習推薦你來北京尚學堂，雄厚的師資力量帶給你不一樣的學習體驗，在分享一下java學習的路線，希望對你有所幫助：
一、JavaSE基礎階段
面向對象編程(基礎)
面向對象編程(進階)
異常機制
Java常用類
數據結構和演算法
集合(容器)
IO流
多線程
網路編程
集合提升訓練
多線程提升訓練
二、資料庫階段
MySQL基礎
MySQL 查詢語句
資料庫對象
JDBC
反射和註解
資料庫建模和UML建模
設計模式
三、WEB前端
JavaScript
jQuery
BootStrap
Vue
四、JavaEE階段 （核心階段）
HTTP/Tomcat
MVC 架構
Servlet
JSP
EL+JSTL+過濾器+監聽器
Ajax和JSON
分頁和文件上傳/下載
五、JavaEE階段（高級框架）
Spring 5.2.2
SpringMVC 5.2.2
RBAC
EasyUI 1.7.0
支付/簡訊驗證
六、框架強化
Linux - CentOS 8
Maven
Logback
Quartz
Spring Boot 2.2.2
Shiro
Swagger
Git/GitEE
MyBatis
七、分布式架構
Zookeeper
RPC
Dubbo
Redis
Solr
RabbitMQ
FastDFS
Nginx
Spring Security
Spring Session
MyBatis Generator
Mycat
八、微服務階段
ElasticSearch
MongoDB
Spring Cloud Netflix Eureka
Spring Cloud Netflix Ribbon
Spring Cloud OpenFeign
Spring Cloud Netflix Hystrix
Spring Cloud Config
Spring Cloud Gateway
Docker
K8S
❺ 談談你對Java中的多態的理解.(為什麼要使用多態，有什麼好處，一般用在什麼場合)
面向對象編程有三大特性：封裝、繼承、多態。
封裝隱藏了類的內部實現機制，可以在不影響使用的情況下改變類的內部結構，同時也保護了數據。對外界而已它的內部細節是隱藏的，暴露給外界的只是它的訪問方法。
繼承是為了重用父類代碼。兩個類若存在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實例對象的。這樣做存在一個非常大的好處，在繼承中我們知道子類是父類的擴展，它可以提供比父類更加強大的功能，如果我們定義了一個指向子類的父類引用類型，那麼它除了能夠引用父類的共性外，還可以使用子類強大的功能。
但是向上轉型存在一些缺憾，那就是它必定會導致一些方法和屬性的丟失，而導致我們不能夠獲取它們。所以父類類型的引用可以調用父類中定義的所有屬性和方法，對於只存在與子類中的方法和屬性它就望塵莫及了。
publicclassWine{
publicvoidfun1(){
System.out.println("Wine的Fun.....");
fun2();
}
publicvoidfun2(){
System.out.println("Wine的Fun2...");
}
}
publicclassJNCextendsWine{
/**
*@desc子類重載父類方法
*父類中不存在該方法，向上轉型後，父類是不能引用該方法的
*@parama
*@returnvoid
*/
publicvoidfun1(Stringa){
System.out.println("JNC的Fun1...");
fun2();
}
/**
*子類重寫父類方法
*指向子類的父類引用調用fun2時，必定是調用該方法
*/
publicvoidfun2(){
System.out.println("JNC的Fun2...");
}
}
publicclassTest{
publicstaticvoidmain(String[]args){
Winea=newJNC();
a.fun1();
}
}-------------------------------------------------
Output:
Wine的Fun.....
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()方法。
所以對於多態我們可以總結如下：
指向子類的父類引用由於向上轉型了，它只能訪問父類中擁有的方法和屬性，而對於子類中存在而父類中不存在的方法，該引用是不能使用的，盡管是重載該方法。若子類重寫了父類中的某些方法，在調用該些方法的時候，必定是使用子類中定義的這些方法（動態連接、動態調用）。
對於面向對象而已，多態分為編譯時多態和運行時多態。其中編輯時多態是靜態的，主要是指方法的重載，它是根據參數列表的不同來區分不同的函數，通過編輯之後會變成兩個不同的函數，在運行時談不上多態。而運行時多態是動態的，它是通過動態綁定來實現的，也就是我們所說的多態性。
多態的實現
2.1實現條件
在剛剛開始就提到了繼承在為多態的實現做了准備。子類Child繼承父類Father，我們可以編寫一個指向子類的父類類型引用，該引用既可以處理父類Father對象，也可以處理子類Child對象，當相同的消息發送給子類或者父類對象時，該對象就會根據自己所屬的引用而執行不同的行為，這就是多態。即多態性就是相同的消息使得不同的類做出不同的響應。
Java實現多態有三個必要條件：繼承、重寫、向上轉型。
繼承：在多態中必須存在有繼承關系的子類和父類。
重寫：子類對父類中某些方法進行重新定義，在調用這些方法時就會調用子類的方法。
向上轉型：在多態中需要將子類的引用賦給父類對象，只有這樣該引用才能夠具備技能調用父類的方法和子類的方法。
只有滿足了上述三個條件，我們才能夠在同一個繼承結構中使用統一的邏輯實現代碼處理不同的對象，從而達到執行不同的行為。
對於Java而言，它多態的實現機制遵循一個原則：當超類對象引用變數引用子類對象時，被引用對象的類型而不是引用變數的類型決定了調用誰的成員方法，但是這個被調用的方法必須是在超類中定義過的，也就是說被子類覆蓋的方法。
2.2實現形式
在Java中有兩種形式可以實現多態。繼承和介面。
2.2.1、基於繼承實現的多態
基於繼承的實現機制主要表現在父類和繼承該父類的一個或多個子類對某些方法的重寫，多個子類對同一方法的重寫可以表現出不同的行為。
publicclassWine{
privateStringname;
publicStringgetName(){
returnname;
}
publicvoidsetName(Stringname){
this.name=name;
}
publicWine(){
}
publicStringdrink(){
return"喝的是"+getName();
}
/**
*重寫toString()
*/
publicStringtoString(){
returnnull;
}
}
publicclassJNCextendsWine{
publicJNC(){
setName("JNC");
}
/**
*重寫父類方法，實現多態
*/
publicStringdrink(){
return"喝的是"+getName();
}
/**
*重寫toString()
*/
publicStringtoString(){
return"Wine:"+getName();
}
}
publicclassJGJextendsWine{
publicJGJ(){
setName("JGJ");
}
/**
*重寫父類方法，實現多態
*/
publicStringdrink(){
return"喝的是"+getName();
}
/**
*重寫toString()
*/
publicStringtoString(){
return"Wine:"+getName();
}
}
publicclassTest{
publicstaticvoidmain(String[]args){
//定義父類數組
Wine[]wines=newWine[2];
//定義兩個子類
JNCjnc=newJNC();
JGJjgj=newJGJ();
//父類引用子類對象
wines[0]=jnc;
wines[1]=jgj;
for(inti=0;i<2;i++){
System.out.println(wines[i].toString()+"--"+wines[i].drink());
}
System.out.println("-------------------------------");
}
}OUTPUT:
Wine:JNC--喝的是JNC
Wine:JGJ--喝的是JGJ
在上面的代碼中JNC、JGJ繼承Wine，並且重寫了drink()、toString()方法，程序運行結果是調用子類中方法，輸出JNC、JGJ的名稱，這就是多態的表現。不同的對象可以執行相同的行為，但是他們都需要通過自己的實現方式來執行，這就要得益於向上轉型了。
我們都知道所有的類都繼承自超類Object，toString()方法也是Object中方法，當我們這樣寫時：
Objecto=newJGJ();
System.out.println(o.toString());
輸出的結果是Wine : JGJ。
Object、Wine、JGJ三者繼承鏈關系是：JGJ—>Wine—>Object。所以我們可以這樣說：當子類重寫父類的方法被調用時，只有對象繼承鏈中的最末端的方法才會被調用。但是注意如果這樣寫：
Objecto=newWine();
System.out.println(o.toString());
輸出的結果應該是Null，因為JGJ並不存在於該對象繼承鏈中。
所以基於繼承實現的多態可以總結如下：對於引用子類的父類類型，在處理該引用時，它適用於繼承該父類的所有子類，子類對象的不同，對方法的實現也就不同，執行相同動作產生的行為也就不同。
如果父類是抽象類，那麼子類必須要實現父類中所有的抽象方法，這樣該父類所有的子類一定存在統一的對外介面，但其內部的具體實現可以各異。這樣我們就可以使用頂層類提供的統一介面來處理該層次的方法。
2.2.2、基於介面實現的多態
繼承是通過重寫父類的同一方法的幾個不同子類來體現的，那麼就可就是通過實現介面並覆蓋介面中同一方法的幾不同的類體現的。
在介面的多態中，指向介面的引用必須是指定這實現了該介面的一個類的實常式序，在運行時，根據對象引用的實際類型來執行對應的方法。
繼承都是單繼承，只能為一組相關的類提供一致的服務介面。但是介面可以是多繼承多實現，它能夠利用一組相關或者不相關的介面進行組合與擴充，能夠對外提供一致的服務介面。所以它相對於繼承來說有更好的靈活性。
❻ Java中的多態機制（有關成員變數的）
java中，向上造型呈現的多態性僅僅針對成員函數，成員屬性不具有多態性，例如：
Father fs = new Son();
fs.m1(); //調用的是子類的函數
fs.a; // 調用的是父類的屬性
❼ java中實現多態的機制是什麼
多態包括重載和重寫。
重載是：同樣的方法名，包含不同的參數或者參數個數或者參數類型。
重寫是：同樣的方法名，同樣的參數個數。
❽ Java程序如何實現多態
多態,就是重載和重寫.重載發生在一個類中.重寫發生在子類,意思就是子類重寫父類相同名稱的方法.剛學語言有的東西,不必搞得那麼清楚,只有知道怎麼用就行了,有的問題你要想真正把它搞得很懂,短時間是不可能的,比如說介面,沒有幾年工作經驗你根本不可能真正理解什麼是介面,甚至有的人工作四,五年也沒搞明白什麼是介面,不要花太多時間去搞這些不容易搞懂的問題.
重載的特性,方法名相同.返回類型,傳入方法的參數不同(包括個數和類型).
重寫的特性,方法名相同,返回類型,參數均相同,必須發生在子類.
1.Java語言允許某個類型的引用變數引用子類的實例，而且可以對這個引用變數進行類型轉換。
Animal animal=new Dog(); //引用變數animal引用一個Animal子類Dog的實例
Dog dog=(Dog)animal; //向下轉型，把Animal類型轉換為Dog類型
Creature creature=animal; //向上轉型，把Animal類型轉換為 Creature類型
animal=new Cat(); //引用變數animal引用另一個Animal子類Cat的實例
註：Creature這里指的是生物。
2.如果把引用變數轉換為子類類型，稱為向下轉型，如果把引用變數轉換為父類類型，稱為向上轉型。
3.在進行引用變數的類型轉換時，會受到各種限制。而且在通過引用變數訪問它所引用的實例的靜態屬性、靜態方法、實例屬性、實例方法，以及從父類中繼承的方法和屬性時，Java虛擬機會採用不同的綁定機制。
4.成員變數、靜態方法按照引用變數聲明的類型靜態綁定；實例方法按照引用變數引用的實例動態綁定。
例如，對於以下這段代碼：
Fathers f＝new Sons();
System.out.println(「f.var=」+f.var);
System.out.println(「f.staticVar=」+f.staticVar);
f.method();
f.staticMethod();
運行時將會輸出如下結果：
f.var=FatherVar
f.staticVar=StaticFaterVar
Son method
Static Father method
class Fathers{
String var="FatherVar";
static String staticVar="StaticFatherVar";
void method(){System.out.println("Father method");}
static void staticMethod(){System.out.println("Static Father method");}
}
class Sons extends Fathers{
String var="SonVar";
static String staticVar="StaticSonVar";
void method(){System.out.println("Son method");}
static void staticMethod(){System.out.println("Static Son method");}
String sonVar=null;
void sonMethod(){}
}
❾ 談談Java中多態的意義；簡述多態的實現機制，並舉例分析
1、JAVA是區分類型的。算加法，這個方法名叫add，但是事實並不知道這個方法計算的是什麼類型的：add(int a,int b)、add(float a, float b)、混合的、double的、數組、集合等等，但是要計算的時候只要調用add方法，自動找類型匹配的。
2、參數個數不同。假如要計算3個整形參數的，調用2次add(int a,int b)太麻煩，直接調用add(int a,int b,int c)就好了。
3、重寫父類的方法。美國人和中國人都是繼承人這個父類，美國人吃飯用刀叉，中國人吃飯用筷子，子類自己定義吃飯怎麼實現，反正吃飯的方法名是一樣的，調用起來方便。
前兩種是重載可以理解成智能，第三個是重寫可以說是擴展性強。總之就是為了方便。