溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
本篇內容主要講解“Java面向對象的三大特性”，感興趣的朋友不妨來看看。本文介紹的方法操作簡單快捷，實用性強。下面就讓小編來帶大家學習“Java面向對象的三大特性”吧!
面向對象簡稱 OO（Object Oriented），20 世紀 80 年代以后，有了面向對象分析（OOA）、 面向對象設計（OOD）、面向對象程序設計（OOP）等新的系統開發方式模型的研究。
對語言來說，一切皆是對象。把現實世界中的對象抽象地體現在編程世界中，一個對象代表了某個具體的操作。一個個對象最終組成了完整的程序設計，這些對象可以是獨立存在的，也可以是從別的對象繼承過來的。對象之間通過相互作用傳遞信息，實現程序開發。
Java 是面向對象的編程語言，對象就是面向對象程序設計的核心。所謂對象就是真實世界中的實體，對象與實體是一一對應的，也就是說現實世界中每一個實體都是一個對象，它是一種具體的概念。對象有以下特點：
對象具有屬性和行為。
對象具有變化的狀態。
對象具有唯一性。
對象都是某個類別的實例。
一切皆為對象，真實世界中的所有事物都可以視為對象。
面向過程：
??一種較早的編程思想，顧名思義就是該思想是站著過程的角度思考問題，強調的就是功能行為，功能的執行過程，即先后順序，而每一個功能我們都使用函數（類似于方法）把這些步驟一步一步實現。使用的時候依次調用函數就可以了。
面向過程的設計：
??最小的程序單元是函數，每個函數負責完成某一個功能，用于接受輸入數據，函數對輸入數據進行處理，然后輸出結果數據，整個軟件系統由一個個的函數組成，其中作為程序入口的函數稱之為主函數，主函數依次調用其他函數，普通函數之間可以相互調用，從而實現整個系統功能。
??面向過程最大的問題在于隨著系統的膨脹，面向過程將無法應付，最終導致系統的崩潰。為了解決這一種軟件危機，我們提出面向對象思想。
面向過程的缺陷：
??是采用指定而下的設計模式，在設計階段就需要考慮每一個模塊應該分解成哪些子模塊，每一個子模塊又細分為更小的子模塊，如此類推，直到將模塊細化為一個個函數。
存在的問題
設計不夠直觀，與人類的思維習慣不一致
系統軟件適應新差，可拓展性差，維護性低
面向對象：
一種基于面向過程的新編程思想，顧名思義就是該思想是站在對象的角度思考問題，我們把多個功能合理放到不同對象里，強調的是具備某些功能的對象。
??具備某種功能的實體，稱為對象。面向對象最小的程序單元是：類。面向對象更加符合常規的思維方式，穩定性好，可重用性強，易于開發大型軟件產品，有良好的可維護性。
??在軟件工程上，面向對象可以使工程更加模塊化，實現更低的耦合和更高的內聚。
面向對象開發模式更有利于人們開拓思維，在具體的開發過程中便于程序的劃分，方便程序員分工合作，提高開發效率。
該開發模式之所以使程序設計更加完善和強大，主要是因為面向對象具有繼承、封裝和多態 3 個核心特性。
1、繼承的概念
繼承是java面向對象編程技術的一塊基石，因為它允許創建分等級層次的類。
繼承就是子類繼承父類的特征和行為，使得子類對象（實例）具有父類的實例域和方法，或子類從父類繼承方法，使得子類具有父類相同的行為。
兔子和羊屬于食草動物類，獅子和豹屬于食肉動物類。
食草動物和食肉動物又是屬于動物類。
所以繼承需要符合的關系是：is-a，父類更通用，子類更具體。
雖然食草動物和食肉動物都是屬于動物，但是兩者的屬性和行為上有差別，所以子類會具有父類的一般特性也會具有自身的特性。
2、Java 多態
多態是同一個行為具有多個不同表現形式或形態的能力。
多態就是同一個接口，使用不同的實例而執行不同操作，如圖所示：
多態性是對象多種表現形式的體現。
現實中，比如我們按下 F1 鍵這個動作：
如果當前在 Flash 界面下彈出的就是 AS 3 的幫助文檔；
如果當前在 Word 下彈出的就是 Word 幫助；
在 Windows 下彈出的就是 Windows 幫助和支持。
同一個事件發生在不同的對象上會產生不同的結果。
3、Java 封裝
在面向對象程式設計方法中，封裝（英語：Encapsulation）是指一種將抽象性函式接口的實現細節部份包裝、隱藏起來的方法。
封裝可以被認為是一個保護屏障，防止該類的代碼和數據被外部類定義的代碼隨機訪問。
要訪問該類的代碼和數據，必須通過嚴格的接口控制。
封裝最主要的功能在于我們能修改自己的實現代碼，而不用修改那些調用我們代碼的程序片段。
適當的封裝可以讓程式碼更容易理解與維護，也加強了程式碼的安全性。
面向對象編程是利用 類和對象編程的一種思想。萬物可歸類，類是對于世界事物的高度抽象 ，不同的事物之間有不同的關系 ，一個類自身與外界的封裝關系，一個父類和子類的繼承關系， 一個類和多個類的多態關系。萬物皆對象，對象是具體的世界事物，面向對象的三大特征封裝，繼承，多態，封裝，封裝說明一個類行為和屬性與其他類的關系，低耦合，高內聚；繼承是父類和子類的關系，多態說的是類與類的關系。
如同生活中的子女繼承父母擁有的所有財產，程序中的繼承性是指子類擁有父類 數據結構的方法和機制，這是類之間的一種關系；繼承只能是單繼承。
例如定義一個語文老師類和數學老師類，如果不采用繼承方式，那么兩個類中需要定義的屬性和方法如圖 1 所示。
圖1 語文老師類和數學老師類中的屬性和方法
從圖 1 能夠看出，語文老師類和數學老師類中的許多屬性和方法相同，這些相同的屬性和方法可以提取出來放在一個父類中，這個父類用于被語文老師類和數學老師類繼承。當然父類還可以繼承別的類，如圖 2 所示。
圖2 父類繼承示例圖
總結圖 2 的繼承關系，可以用概括的樹形關系來表示，如圖 3 所示。
圖3 類繼承示例圖
從圖 3 中可以看出，學校主要人員是一個大的類別，老師和學生是學校主要人員的兩個子類，而老師又可以分為語文老師和數學老師兩個子類，學生也可以分為班長和組長兩個子類。
使用這種層次形的分類方式，是為了將多個類的通用屬性和方法提取出來，放在它們的父類中，然后只需要在子類中各自定義自己獨有的屬性和方法，并以繼承的形式在父類中獲取它們的通用屬性和方法即可。
繼承是類與類的一種關系，是一種“is a”的關系。比如“狗”繼承“動物”，這里動物類是狗類的父類或者基類，狗類是動物類的子類或者派生類。如下圖所示：
注：java中的繼承是單繼承，即一個類只有一個父類。
補充：Java中的繼承只能單繼承，但是可以通過內部類繼承其他類來實現多繼承。
public class Son extends Father{
public void go () {
System.out.println("son go");
}
public void eat () {
System.out.println("son eat");
}
public void sleep() {
System.out.println("zzzzzz");
}
public void cook() {
//匿名內部類實現的多繼承
new Mother().cook();
//內部類繼承第二個父類來實現多繼承
Mom mom = new Mom();
mom.cook();
}
private class Mom extends Mother {
@Override
public void cook() {
System.out.println("mom cook");
}
}
}子類擁有父類的所有屬性和方法（除了private修飾的屬性不能擁有）從而實現了實現代碼的復用；
子類如果對繼承的父類的方法不滿意（不適合），可以自己編寫繼承的方法，這種方式就稱為方法的重寫。當調用方法時會優先調用子類的方法。
重寫要注意：
a、返回值類型
b、方法名
c、參數類型及個數
都要與父類繼承的方法相同，才叫方法的重寫。
重載和重寫的區別：
方法重載：在同一個類中處理不同數據的多個相同方法名的多態手段。
方法重寫：相對繼承而言，子類中對父類已經存在的方法進行區別化的修改。
1、初始化父類再初始化子類
2、先執行初始化對象中屬性，再執行構造方法中的初始化。
基于上面兩點，我們就知道實例化一個子類，java程序的執行順序是：
父類對象屬性初始化——>父類對象構造方法——>子類對象屬性初始化—->子類對象構造方法
下面有個形象的圖：
使用final關鍵字做標識有“最終的”含義。
1. final 修飾類，則該類不允許被繼承。
2. final 修飾方法，則該方法不允許被覆蓋(重寫)。
3. final 修飾屬性，則該類的該屬性不會進行隱式的初始化，所以 該final 屬性的初始化屬性必須有值，或在構造方法中賦值(但只能選其一，且必須選其一，因為沒有默認值！)，且初始化之后就不能改了，只能賦值一次。
4. final 修飾變量，則該變量的值只能賦一次值，在聲明變量的時候才能賦值，即變為常量。
在對象的內部使用，可以代表父類對象。
1、訪問父類的屬性：super.age
2、訪問父類的方法：super.eat()
super的應用：
首先我們知道子類的構造的過程當中必須調用父類的構造方法。其實這個過程已經隱式地使用了我們的super關鍵字。
這是因為如果子類的構造方法中沒有顯示調用父類的構造方法，則系統默認調用父類無參的構造方法。
那么如果自己用super關鍵字在子類里調用父類的構造方法，則必須在子類的構造方法中的第一行。
要注意的是：如果子類構造方法中既沒有顯示調用父類的構造方法，而父類沒有無參的構造方法，則編譯出錯。
（補充說明，雖然沒有顯示聲明父類的無參的構造方法，系統會自動默認生成一個無參構造方法，但是，如果你聲明了一個有參的構造方法，而沒有聲明無參的構造方法，這時系統不會動默認生成一個無參構造方法，此時稱為父類有沒有無參的構造方法。）
封裝是將代碼及其處理的數據綁定在一起的一種編程機制，該機制保證了程序和數據都不受外部干擾且不被誤用。封裝的目的在于保護信息，使用它的主要優點如下。
保護類中的信息，它可以阻止在外部定義的代碼隨意訪問內部代碼和數據。
隱藏細節信息，一些不需要程序員修改和使用的信息，比如取款機中的鍵盤，用戶只需要知道按哪個鍵實現什么操作就可以，至于它內部是如何運行的，用戶不需要知道。
有助于建立各個系統之間的松耦合關系，提高系統的獨立性。當一個系統的實現方式發生變化時，只要它的接口不變，就不會影響其他系統的使用。例如 U 盤，不管里面的存儲方式怎么改變，只要 U 盤上的 USB 接口不變，就不會影響用戶的正常操作。
提高軟件的復用率，降低成本。每個系統都是一個相對獨立的整體，可以在不同的環境中得到使用。例如，一個 U 盤可以在多臺電腦上使用。
Java 語言的基本封裝單位是類。由于類的用途是封裝復雜性，所以類的內部有隱藏實現復雜性的機制。Java 提供了私有和公有的訪問模式，類的公有接口代表外部的用戶應該知道或可以知道的每件東西，私有的方法數據只能通過該類的成員代碼來訪問，這就可以確保不會發生不希望的事情。
在面向對象程式設計方法中，封裝（英語：Encapsulation）是指一種將抽象性函式接口的實現細節部份包裝、隱藏起來的方法。
封裝可以被認為是一個保護屏障，防止該類的代碼和數據被外部類定義的代碼隨機訪問。
要訪問該類的代碼和數據，必須通過嚴格的接口控制。
封裝最主要的功能在于我們能修改自己的實現代碼，而不用修改那些調用我們代碼的程序片段。
適當的封裝可以讓程式碼更容易理解與維護，也加強了程式碼的安全性。
封裝的優點
良好的封裝能夠減少耦合。
類內部的結構可以自由修改。
可以對成員變量進行更精確的控制。
隱藏信息，實現細節。
Java 封裝，說白了就是將一大坨公共通用的實現邏輯玩意，裝到一個盒子里（class），出入口都在這個盒子上。你要用就將這個盒子拿來用，連接出入口，就能用了，不用就可以直接扔，對你代碼沒什么影響。
對程序員來說，使用封裝的目的：
偷懶，辛苦一次，后面都能少敲很多代碼，增強了代碼得復用性
簡化代碼，看起來更容易懂
隱藏核心實現邏輯代碼，簡化外部邏輯，并且不讓其他人修改，jar 都這么干
一對一，一個功能就只為這個功能服務；避免頭發繩子一塊用，導致最后一團糟
需要注意：對封裝的屬性不一定要通過get/set方法，其他方法也可以對封裝的屬性進行操作。當然最好使用get/set方法，比較標準。
從表格可以看出從上到下封裝性越來越差。
1.this關鍵字代表當前對象
this.屬性 操作當前對象的屬性
this.方法 調用當前對象的方法。
2.封裝對象的屬性的時候，經常會使用this關鍵字。
3.當getter和setter函數參數名和成員函數名重合的時候，可以使用this**區別。如：**
內部類（ Inner Class ）就是定義在另外一個類里面的類。與之對應，包含內部類的類被稱為外部類。
那么問題來了：那為什么要將一個類定義在另一個類里面呢？清清爽爽的獨立的一個類多好啊！！
答：內部類的主要作用如下：
1. 內部類提供了更好的封裝，可以把內部類隱藏在外部類之內，不允許同一個包中的其他類訪問該類。
2. 內部類的方法可以直接訪問外部類的所有數據，包括私有的數據。
3. 內部類所實現的功能使用外部類同樣可以實現，只是有時使用內部類更方便。
內部類可分為以下幾種：
成員內部類
靜態內部類
方法內部類
匿名內部類
面向對象的多態性，即“一個接口，多個方法”。多態性體現在父類中定義的屬性和方法被子類繼承后，可以具有不同的屬性或表現方式。多態性允許一個接口被多個同類使用，彌補了單繼承的不足。多態概念可以用樹形關系來表示，如圖 4 所示。
圖4 多態示例圖
從圖 4 中可以看出，老師類中的許多屬性和方法可以被語文老師類和數學老師類同時使用，這樣也不易出錯。
可替換性（substitutability）。多態對已存在代碼具有可替換性。例如，多態對圓Circle類工作，對其他任何圓形幾何體，如圓環，也同樣工作。
可擴充性（extensibility）。多態對代碼具有可擴充性。增加新的子類不影響已存在類的多態性、繼承性，以及其他特性的運行和操作。實際上新加子類更容易獲得多態功能。例如，在實現了圓錐、半圓錐以及半球體的多態基礎上，很容易增添球體類的多態性。
接口性（interface-ability）。多態是超類通過方法簽名，向子類提供了一個共同接口，由子類來完善或者覆蓋它而實現的。
靈活性（flexibility）。它在應用中體現了靈活多樣的操作，提高了使用效率。
簡化性（simplicity）。多態簡化對應用軟件的代碼編寫和修改過程，尤其在處理大量對象的運算和操作時，這個特點尤為突出和重要。
子代父類實例化，然后就相當于一個父親有很多兒子，送快遞的給這個父親的兒子送東西，他只需要送到父親的家就行了，至于具體是那個兒子的，父親還會分不清自己的兒子么，所以你就不用操心了。
使用多態是一種好習慣
多態方式聲明是一種好的習慣。當我們創建的類，使用時，只用到它的超類或接口定義的方法時，我們可以將其索引聲明為它的超類或接口類型。
它的好處是，如果某天我們對這個接口方法的實現方式變了，對這個接口又有一個新的實現類，我們的程序也需要使用最新的實現方式，此時只要將對象實現修改一下，索引無需變化。
比如Map< String,String> map = new HashMap < String,String>();
想換成HashTable實現，可以Map< String,String> map = new HashTable < String,String>();
比如寫一個方法，參數要求傳遞List類型，你就可以用List list = new ArrayList()中的list傳遞，但是你寫成ArrayList list = new ArrayList()是傳遞不進去的。盡管方法處理時都一樣。另外，方法還可以根據你傳遞的不同list（ArrayList或者LinkList）進行不同處理。
java里的多態主要表現在兩個方面：
父類的引用可以指向本類的對象；
父類的引用可以指向子類的對象；
這兩句話是什么意思呢，讓我們用代碼來體驗一下，首先我們創建一個父類Animal和一個子類Dog，在主函數里如下所示：
注意：我們不能使用一個子類的引用來指向父類的對象，如：
。
這里我們必須深刻理解引用多態的意義，才能更好記憶這種多態的特性。為什么子類的引用不能用來指向父類的對象呢？我在這里通俗給大家講解一下：就以上面的例子來說，我們能說“狗是一種動物”，但是不能說“動物是一種狗”，狗和動物是父類和子類的繼承關系，它們的從屬是不能顛倒的。當父類的引用指向子類的對象時，該對象將只是看成一種特殊的父類（里面有重寫的方法和屬性），反之，一個子類的引用來指向父類的對象是不可行的！！
根據上述創建的兩個對象：本類對象和子類對象，同樣都是父類的引用，當我們指向不同的對象時，它們調用的方法也是多態的。
創建本類對象時，調用的方法為本類方法；
創建子類對象時，調用的方法為子類重寫的方法或者繼承的方法；
使用多態的時候要注意：如果我們在子類中編寫一個獨有的方法（沒有繼承父類的方法），此時就不能通過父類的引用創建的子類對象來調用該方法！！！
注意： 繼承是多態的基礎。
了解了多態的含義后，我們在日常使用多態的特性時經常需要進行引用類型轉換。
引用類型轉換：
1.向上類型轉換(隱式/自動類型轉換)，是小類型轉換到大類型
就以上述的父類Animal和一個子類Dog來說明，當父類的引用可以指向子類的對象時，就是向上類型轉換。如：
2. 向下類型轉換(強制類型轉換)，是大類型轉換到小類型(有風險,可能出現數據溢出)。
將上述代碼再加上一行，我們再次將父類轉換為子類引用，那么會出現錯誤，編譯器不允許我們直接這么做，雖然我們知道這個父類引用指向的就是子類對象，但是編譯器認為這種轉換是存在風險的。如：
那么我們該怎么解決這個問題呢，我們可以在animal前加上（Dog）來強制類型轉換。如：
但是如果父類引用沒有指向該子類的對象，則不能向下類型轉換，雖然編譯器不會報錯，但是運行的時候程序會出錯，如：
其實這就是上面所說的子類的引用指向父類的對象，而強制轉換類型也不能轉換！！
還有一種情況是父類的引用指向其他子類的對象，則不能通過強制轉為該子類的對象。如：
這是因為我們在編譯的時候進行了強制類型轉換，編譯時的類型是我們強制轉換的類型，所以編譯器不會報錯，而當我們運行的時候，程序給animal開辟的是Dog類型的內存空間，這與Cat類型內存空間不匹配，所以無法正常轉換。這兩種情況出錯的本質是一樣的，所以我們在使用強制類型轉換的時候要特別注意這兩種錯誤！！下面有個更安全的方式來實現向下類型轉換。。。。
3. instanceof運算符，來解決引用對象的類型，避免類型轉換的安全性問題。
instanceof是Java的一個二元操作符，和==，>，<是同一類東東。由于它是由字母組成的，所以也是Java的保留關鍵字。它的作用是測試它左邊的對象是否是它右邊的類的實例，返回boolean類型的數據。
我們來使用instanceof運算符來規避上面的錯誤，代碼修改如下：
利用if語句和instanceof運算符來判斷兩個對象的類型是否一致。
補充說明：在比較一個對象是否和另一個對象屬于同一個類實例的時候，我們通常可以采用instanceof和getClass兩種方法通過兩者是否相等來判斷，但是兩者在判斷上面是有差別的。Instanceof進行類型檢查規則是:你屬于該類嗎？或者你屬于該類的派生類嗎？而通過getClass獲得類型信息采用==來進行檢查是否相等的操作是嚴格的判斷,不會存在繼承方面的考慮；
總結：在寫程序的時候，如果要進行類型轉換，我們最好使用instanceof運算符來判斷它左邊的對象是否是它右邊的類的實例，再進行強制轉換。
D、重寫和重載
多態一般可以分為兩種，一個是重寫override，一個是重載overload。
重寫是由于繼承關系中的子類有一個和父類同名同參數的方法，會覆蓋掉父類的方法。重載是因為一個同名方法可以傳入多個參數組合。 注意，同名方法如果參數相同，即使返回值不同也是不能同時存在的，編譯會出錯。 從jvm實現的角度來看，重寫又叫運行時多態，編譯時看不出子類調用的是哪個方法，但是運行時操作數棧會先根據子類的引用去子類的類信息中查找方法，找不到的話再到父類的類信息中查找方法。 而重載則是編譯時多態，因為編譯期就可以確定傳入的參數組合，決定調用的具體方法是哪一個了。
1. 向上轉型和向下轉型
public static void main(String[] args) {
Son son = new Son();
//首先先明確一點，轉型指的是左側引用的改變。
//father引用類型是Father，指向Son實例，就是向上轉型，既可以使用子類的方法，也可以使用父類的方法。
//向上轉型,此時運行father的方法
Father father = son;
father.smoke();
//不能使用子類獨有的方法。
// father.play();編譯會報錯
father.drive();
//Son類型的引用指向Father的實例，所以是向下轉型，不能使用子類非重寫的方法，可以使用父類的方法。
//向下轉型，此時運行了son的方法
Son son1 = (Son) father;
//轉型后就是一個正常的Son實例
son1.play();
son1.drive();
son1.smoke();
//因為向下轉型之前必須先經歷向上轉型。
//在向下轉型過程中，分為兩種情況：
//情況一：如果父類引用的對象如果引用的是指向的子類對象，
//那么在向下轉型的過程中是安全的。也就是編譯是不會出錯誤的。
//因為運行期Son實例確實有這些方法
Father f1 = new Son();
Son s1 = (Son) f1;
s1.smoke();
s1.drive();
s1.play();
//情況二：如果父類引用的對象是父類本身，那么在向下轉型的過程中是不安全的，編譯不會出錯，
//但是運行時會出現java.lang.ClassCastException錯誤。它可以使用instanceof來避免出錯此類錯誤。
//因為運行期Father實例并沒有這些方法。
Father f2 = new Father();
Son s2 = (Son) f2;
s2.drive();
s2.smoke();
s2.play();
//向下轉型和向上轉型的應用，有些人覺得這個操作沒意義，何必先向上轉型再向下轉型呢，不是多此一舉么。其實可以用于方法參數中的類型聚合，然后具體操作再進行分解。
//比如add方法用List引用類型作為參數傳入，傳入具體類時經歷了向下轉型
add(new LinkedList());
add(new ArrayList());
//總結
//向上轉型和向下轉型都是針對引用的轉型，是編譯期進行的轉型，根據引用類型來判斷使用哪個方法
//并且在傳入方法時會自動進行轉型（有需要的話）。運行期將引用指向實例，如果是不安全的轉型則會報錯。
//若安全則繼續執行方法。
}
public static void add(List list) {
System.out.println(list);
//在操作具體集合時又經歷了向上轉型
// ArrayList arr = (ArrayList) list;
// LinkedList link = (LinkedList) list;
}總結：
向上轉型和向下轉型都是針對引用的轉型，是編譯期進行的轉型，根據引用類型來判斷使用哪個方法。并且在傳入方法時會自動進行轉型（有需要的話）。運行期將引用指向實例，如果是不安全的轉型則會報錯，若安全則繼續執行方法。
2. 編譯期的靜態分派
其實就是根據引用類型來調用對應方法。
public static void main(String[] args) {
Father father = new Son();
靜態分派 a= new 靜態分派();
//編譯期確定引用類型為Father。
//所以調用的是第一個方法。
a.play(father);
//向下轉型后，引用類型為Son，此時調用第二個方法。
//所以，編譯期只確定了引用，運行期再進行實例化。
a.play((Son)father);
//當沒有Son引用類型的方法時，會自動向上轉型調用第一個方法。
a.smoke(father);
//}
public void smoke(Father father) {
System.out.println("father smoke");
}
public void play (Father father) {
System.out.println("father");
//father.drive();
}
public void play (Son son) {
System.out.println("son");
//son.drive();
}3. 方法重載優先級匹配
public static void main(String[] args) {
方法重載優先級匹配 a = new 方法重載優先級匹配();
//普通的重載一般就是同名方法不同參數。
//這里我們來討論當同名方法只有一個參數時的情況。
//此時會調用char參數的方法。
//當沒有char參數的方法。會調用int類型的方法，如果沒有int就調用long
//即存在一個調用順序char -> int -> long ->double -> ..。
//當沒有基本類型對應的方法時，先自動裝箱，調用包裝類方法。
//如果沒有包裝類方法，則調用包裝類實現的接口的方法。
//最后再調用持有多個參數的char...方法。
a.eat('a');
a.eat('a','c','b');
}
public void eat(short i) {
System.out.println("short");
}
public void eat(int i) {
System.out.println("int");
}
public void eat(double i) {
System.out.println("double");
}
public void eat(long i) {
System.out.println("long");
}
public void eat(Character c) {
System.out.println("Character");
}
public void eat(Comparable c) {
System.out.println("Comparable");
}
public void eat(char ... c) {
System.out.println(Arrays.toString(c));
System.out.println("...");
}
// public void eat(char i) {
// System.out.println("char");
// }到此，相信大家對“Java面向對象的三大特性”有了更深的了解，不妨來實際操作一番吧！這里是億速云網站，更多相關內容可以進入相關頻道進行查詢，關注我們，繼續學習！
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
