❶ 重寫，覆蓋，重載，隱藏，多態幾個概念的區別分析
override->重寫(=覆蓋)、overload->重載、polymorphism -> 多態
override是重寫（覆蓋）了一個方法，以實現不同的功能。一般是用於子類在繼承父類時，重寫（重新實現）父類中的方法。
重寫（覆蓋）的規則：
1、重寫方法的參數列表必須完全與被重寫的方法的相同,否則不能稱其為重寫而是重載.
2、重寫方法的訪問修飾符一定要大於被重寫方法的訪問修飾符（public>protected>default>private）。
3、重寫的方法的返回值必須和被重寫的方法的返回一致；
4、重寫的方法所拋出的異常必須和被重寫方法的所拋出的異常一致，或者是其子類；
5、被重寫的方法不能為private，否則在其子類中只是新定義了一個方法，並沒有對其進行重寫。
6、靜態方法不能被重寫為非靜態的方法（會編譯出錯）。
overload是重載，一般是用於在一個類內實現若乾重載的方法，這些方法的名稱相同而參數形式不同。
重載的規則：
1、在使用重載時只能通過相同的方法名、不同的參數形式實現。不同的參數類型可以是不同的參數類型，不同的參數個數，不同的參數順序（參數類型必須不一樣）；
2、不能通過訪問許可權、返回類型、拋出的異常進行重載；
3、方法的異常類型和數目不會對重載造成影響；
多態的概念比較復雜，有多種意義的多態，一個有趣但不嚴謹的說法是：繼承是子類使用父類的方法，而多態則是父類使用子類的方法。
一般，我們使用多態是為了避免在父類里大量重載引起代碼臃腫且難於維護。
❷ 簡述方法重載和方法重寫的區別
、方法重寫(0veriding)
在Java程序中，類的繼承關系可以產生一個子類，子類繼承父類，它具備了父類所有的特徵，繼承了父類所有的方法和變數。
子類可以定義新的特徵，當子類需要修改父類的一些方法進行擴展，增大功能，程序設計者常常把這樣的一種操作方法稱為重寫，也叫稱為覆寫或覆蓋。
重寫體現了Java優越性，重寫是建立在繼承關繫上，它使語言結構更加豐富。在Java中的繼承中，子類既可以隱藏和訪問父類的方法，也可以覆蓋繼承父類的方法。
在Java中覆蓋繼承父類的方法就是通過方法的重寫來實現的。所謂方法的重寫是指子類中的方法與父類中繼承的方法有完全相同的返回值類型、方法名、參數個數以及參數類型。
這樣，就可以實現對父類方法的覆蓋。如果子類將父類中的方法重寫了，調用的時候肯定是調用被重寫過的方法，那麼如果現在一定要調用父類中的方法該怎麼辦呢?
此時，通過使用super關鍵就可以實現這個功能，super關鍵字可以從子類訪問父類中的內容，如果要訪問被重寫過的方法，使用「super.方法名(參數列表)」的形式調用。
如果要使用super關鍵字不一定非要在方法重寫之後使用，也可以明確地表示某個方法是從父類中繼承而來的。使用super只是更加明確的說，要從父類中查找，就不在子類查找了。
重寫的好處在於子類可以根據需要，定義特定於自己的行為。
也就是說子類能夠根據需要實現父類的方法。
在面向對象原則里，重寫意味著可以重寫任何現有方法。實例如下：
class Animal{
public void move(){
System.out.println("動物可以移動");
}
}
class Dog extends Animal{
public void move(){
System.out.println("狗可以跑和走");
}
}
public class TestDog{
public static void main(String args[]){
Animal a = new Animal(); // Animal 對象
Animal b = new Dog(); // Dog 對象
a.move();// 執行 Animal 類的方法
b.move();//執行 Dog 類的方法
}
}
//運行結果
動物可以移動
狗可以跑和走
在上面的例子中可以看到，盡管b屬於Animal類型，但是它運行的是Dog類的move方法。
這是由於在編譯階段，只是檢查參數的引用類型。
然而在運行時，Java虛擬機(JVM)指定對象的類型並且運行該對象的方法。
因此在上面的例子中，之所以能編譯成功，是因為Animal類中存在move方法，然而運行時，運行的是特定對象的方法。
思考以下例子：
class Animal{
public void move(){
System.out.println("動物可以移動");
}
}
class Dog extends Animal{
public void move(){
System.out.println("狗可以跑和走");
}
public void bark(){
System.out.println("狗可以吠叫");
}
}
public class TestDog{
public static void main(String args[]){
Animal a = new Animal(); // Animal 對象
Animal b = new Dog(); // Dog 對象
a.move();// 執行 Animal 類的方法
b.move();//執行 Dog 類的方法
b.bark();
}
}
//以上實例編譯運行結果如下：
TestDog.java:30: cannot find symbol
symbol : method bark()
location: class Animal
該程序將拋出一個編譯錯誤，因為b的引用類型Animal沒有bark方法。
二、重寫規則
在重寫方法時，需要遵循以下的規則：
(一) 父類方法的參數列表必須完全與被子類重寫的方法的參數列表相同，否則不能稱其為重寫而是重載。
(二) 父類的返回類型必須與被子類重寫的方法返回類型相同，否則不能稱其為重寫而是重載。
(三) Java中規定，被子類重寫的方法不能擁有比父類方法更加嚴格的訪問許可權。編寫過Java程序的人就知道，父類中的方法並不是在任何情況下都可以重寫的，當父類中方法的訪問許可權修飾符為private時，該方法只能被自己的類訪問，不能被外部的類訪問，在子類是不能被重寫的。如果定義父類的方法為public，在子類定義為private，程序運行時就會報錯。
(四) 由於父類的訪問許可權修飾符的限制一定要大於被子類重寫方法的訪問許可權修飾符，而private許可權最小。所以如果某一個方法在父類中的訪問許可權是private，那麼就不能在子類中對其進行重寫。如果重新定義，也只是定義了一個新的方法，不會達到重寫的效果。
(五) 在繼承過程中如果父類當中的方法拋出異常，那麼在子類中重寫父類的該方法時，也要拋出異常，而且拋出的異常不能多於父類中拋出的異常(可以等於父類中拋出的異常)。換句話說，重寫方法一定不能拋出新的檢查異常，或者比被重寫方法聲明更加寬泛的檢查型異常。例如，父類的一個方法申明了一個檢查異常IOException，在重寫這個方法時就不能拋出Exception，只能拋出IOException的子類異常，可以拋出非檢查異常。同樣的道理，如果子類中創建了一個成員變數，而該變數和父類中的一個變數名稱相同，稱作變數重寫或屬性覆蓋。但是此概念一般很少有人去研究它，因為意義不大。
Super關鍵字的使用
當需要在子類中調用父類的被重寫方法時，要使用super關鍵字。
三、方法重載(Overloading)
方法重載是讓類以統一的方式處理不同類型數據的一種手段。調用方法時通過傳遞給它們的不同個數和類型的參數來決定具體使用哪個方法，這就是多態性。
所謂方法重載是指在一個類中，多個方法的方法名相同，但是參數列表不同。參數列表不同指的是參數個數、參數類型或者參數的順序不同。
方法的重載在實際應用中也會經常用到。不僅是一般的方法，構造方法也可以重載。
在方法重載時，方法之間需要存在一定的聯系，因為這樣可以提高程序的可讀性，一般只重載功能相似的方法。
重載是指我們可以定義一些名稱相同的方法，通過定義不同的參數來區分這些方法，然後再調用時，Java虛擬機就會根據不同的參數列表來選擇合適的方法執行。也就是說，當一個重載方法被調用時，Java用參數的類型或個數來決定實際調用的重載方法。因此，每個重載方法的參數的類型或個數必須是不同。
雖然每個重載方法可以有不同的返回類型，但返回類型並不足以區分所使用的是哪個方法。
當Java調用一個重載方法是，參數與調用參數匹配的方法被執行。在使用重載要注意以下的幾點:
1.在使用重載時只能通過不同的參數列表，必須具有不同的參數列表。
2.不能通過訪問許可權、返回類型、拋出的異常進行重載。
3.方法的異常類型和數目不會對重載造成影響。
4.可以有不同的返回類型，只要參數列表不同就可以了。
5.可以有不同的訪問修飾符。
6.可以拋出不同的異常。
重載(overloading) 是在一個類裡面，方法名字相同，而參數不同。返回類型呢？可以相同也可以不同。
每個重載的方法（或者構造函數）都必須有一個獨一無二的參數類型列表。
只能重載構造函數
四、重載規則
被重載的方法必須改變參數列表；
被重載的方法可以改變返回類型；
被重載的方法可以改變訪問修飾符；
被重載的方法可以聲明新的或更廣的檢查異
五、訪問修飾符
訪問修飾符 本類 同包 子類 其他
private √
默認 √ √
protected √ √ √
public √ √ √
重寫與重載之間的區別
方法重載：
1、同一個類中
2、方法名相同，參數列表不同（參數順序、個數、類型）
3、方法返回值、訪問修飾符任意
4、與方法的參數名無關
方法重寫：
1、有繼承關系的子類中
2、方法名相同，參數列表相同（參數順序、個數、類型），方法返回值相同
3、訪問修飾符，訪問范圍需要大於等於父類的訪問范圍
4、與方法的參數名無關
區別點 重載方法 重寫方法
參數列表 必須修改 一定不能修改
返回類型 可以修改 一定不能修改
異常 可以修改 可以減少或刪除，一定不能拋出新的或者更廣的異常
訪問 可以修改 一定不能做更嚴格的限制（可以降低限制）
❸ java中重寫，重載，多態幾個概念區別分析
重寫是方法名字一樣，返回類型一樣
重載：一個類，方法的名字相同，但是參數的個數，類型可能不同
❹ 請問各位大佬這道java的重寫equals和重寫hashcode方法內部是什麼意思呀
1.equals()的所屬以及內部原理（即Object中equals方法的實現原理）
說起equals方法，我們都知道是超類Object中的一個基本方法，用於檢測一個對象是否與另外一個對象相等。而在Object類中這個方法實際上是判斷兩個對象是否具有相同的引用，如果有，它們就一定相等。其源碼如下：
public boolean equals(Object obj) { return (this == obj); }
實際上我們知道所有的對象都擁有標識(內存地址)和狀態(數據)，同時「==」比較兩個對象的的內存地址，所以說 Object 的 equals() 方法是比較兩個對象的內存地址是否相等，即若 object1.equals(object2) 為 true，則表示 equals1 和 equals2 實際上是引用同一個對象。
2.equals()與『==』的區別
或許這是我們面試時更容易碰到的問題」equals方法與『==』運算符有什麼區別？「，並且常常我們都會胸有成竹地回答：「equals比較的是對象的內容，而『==』比較的是對象的地址。」。但是從前面我們可以知道equals方法在Object中的實現也是間接使用了『==』運算符進行比較的，所以從嚴格意義上來說，我們前面的回答並不完全正確。我們先來看一段代碼並運行再來討論這個問題。
package com.zejian.test;
public class Car {
private int batch;
public Car(int batch) {
this.batch = batch;
}
public static void main(String[] args) {
Car c1 = new Car(1);
Car c2 = new Car(1);
System.out.println(c1.equals(c2));
System.out.println(c1 == c2);
}
}
運行結果：
false
false
分析：對於『==』運算符比較兩個Car對象，返回了false，這點我們很容易明白，畢竟它們比較的是內存地址，而c1與c2是兩個不同的對象，所以c1與c2的內存地址自然也不一樣。現在的問題是，我們希望生產的兩輛的批次（batch）相同的情況下就認為這兩輛車相等，但是運行的結果是盡管c1與c2的批次相同，但equals的結果卻反回了false。當然對於equals返回了false，我們也是心知肚明的，因為equal來自Object超類，訪問修飾符為public，而我們並沒有重寫equal方法，故調用的必然是Object超類的原始方equals方法，根據前面分析我們也知道該原始equal方法內部實現使用的是'=='運算符，所以返回了false。因此為了達到我們的期望值，我們必須重寫Car的equal方法，讓其比較的是對象的批次（即對象的內容），而不是比較內存地址，於是修改如下：
@Override
public boolean equals(Object obj) {
if (obj instanceof Car) {
Car c = (Car) obj;
return batch == c.batch;
}
return false;
}
使用instanceof來判斷引用obj所指向的對象的類型，如果obj是Car類對象，就可以將其強制轉為Car對象，然後比較兩輛Car的批次，相等返回true，否則返回false。當然如果obj不是 Car對象，自然也得返回false。我們再次運行：
true
false
嗯，達到我們預期的結果了。因為前面的面試題我們應該這樣回答更佳
總結：默認情況下也就是從超類Object繼承而來的equals方法與『==』是完全等價的，比較的都是對象的內存地址，但我們可以重寫equals方法，使其按照我們的需求的方式進行比較，如String類重寫了equals方法，使其比較的是字元的序列，而不再是內存地址。
3.equals()的重寫規則
前面我們已經知道如何去重寫equals方法來實現我們自己的需求了，但是我們在重寫equals方法時，還是需要注意如下幾點規則的。
自反性。對於任何非null的引用值x，x.equals(x)應返回true。
對稱性。對於任何非null的引用值x與y，當且僅當：y.equals(x)返回true時，x.equals(y)才返回true。
傳遞性。對於任何非null的引用值x、y與z，如果y.equals(x)返回true，y.equals(z)返回true，那麼x.equals(z)也應返回true。
一致性。對於任何非null的引用值x與y，假設對象上equals比較中的信息沒有被修改，則多次調用x.equals(y)始終返回true或者始終返回false。
對於任何非空引用值x，x.equal(null)應返回false。
當然在通常情況下，如果只是進行同一個類兩個對象的相等比較，一般都可以滿足以上5點要求，下面我們來看前面寫的一個例子。
package com.zejian.test;
public class Car {
private int batch;
public Car(int batch) {
this.batch = batch;
}
public static void main(String[] args) {
Car c1 = new Car(1);
Car c2 = new Car(1);
Car c3 = new Car(1);
System.out.println("自反性->c1.equals(c1)：" + c1.equals(c1));
System.out.println("對稱性：");
System.out.println(c1.equals(c2));
System.out.println(c2.equals(c1));
System.out.println("傳遞性：");
System.out.println(c1.equals(c2));
System.out.println(c2.equals(c3));
System.out.println(c1.equals(c3));
System.out.println("一致性：");
for (int i = 0; i < 50; i++) {
if (c1.equals(c2) != c1.equals(c2)) {
System.out.println("equals方法沒有遵守一致性！");
break;
}
}
System.out.println("equals方法遵守一致性！");
System.out.println("與null比較：");
System.out.println(c1.equals(null));
}
@Override
public boolean equals(Object obj) {
if (obj instanceof Car) {
Car c = (Car) obj;
return batch == c.batch;
}
return false;
}
}
運行結果：
自反性->c1.equals(c1)：true
對稱性：
true
true
傳遞性：
true
true
true
一致性：
equals方法遵守一致性！
與null比較：
false
由運行結果我們可以看出equals方法在同一個類的兩個對象間的比較還是相當容易理解的。但是如果是子類與父類混合比較，那麼情況就不太簡單了。下面我們來看看另一個例子，首先，我們先創建一個新類BigCar，繼承於Car,然後進行子類與父類間的比較。
package com.zejian.test;
public class BigCar extends Car {
int count;
public BigCar(int batch, int count) {
super(batch);
this.count = count;
}
@Override
public boolean equals(Object obj) {
if (obj instanceof BigCar) {
BigCar bc = (BigCar) obj;
return super.equals(bc) && count == bc.count;
}
return false;
}
public static void main(String[] args) {
Car c = new Car(1);
BigCar bc = new BigCar(1, 20);
System.out.println(c.equals(bc));
System.out.println(bc.equals(c));
}
}
運行結果：
true
false
對於這樣的結果，自然是我們意料之中的啦。因為BigCar類型肯定是屬於Car類型，所以c.equals(bc)肯定為true，對於bc.equals(c)返回false，是因為Car類型並不一定是BigCar類型（Car類還可以有其他子類）。嗯，確實是這樣。但如果有這樣一個需求，只要BigCar和Car的生產批次一樣，我們就認為它們兩個是相當的，在這樣一種需求的情況下，父類（Car）與子類（BigCar）的混合比較就不符合equals方法對稱性特性了。很明顯一個返回true，一個返回了false，根據對稱性的特性，此時兩次比較都應該返回true才對。那麼該如何修改才能符合對稱性呢？其實造成不符合對稱性特性的原因很明顯，那就是因為Car類型並不一定是BigCar類型（Car類還可以有其他子類），在這樣的情況下(Car instanceof BigCar)永遠返回false，因此，我們不應該直接返回false，而應該繼續使用父類的equals方法進行比較才行（因為我們的需求是批次相同，兩個對象就相等，父類equals方法比較的就是batch是否相同）。因此BigCar的equals方法應該做如下修改：
@Override
public boolean equals(Object obj) {
if (obj instanceof BigCar) {
BigCar bc = (BigCar) obj;
return super.equals(bc) && count == bc.count;
}
return super.equals(obj);
}
這樣運行的結果就都為true了。但是到這里問題並沒有結束，雖然符合了對稱性，卻還沒符合傳遞性，實例如下：
package com.zejian.test;
public class BigCar extends Car {
int count;
public BigCar(int batch, int count) {
super(batch);
this.count = count;
}
@Override
public boolean equals(Object obj) {
if (obj instanceof BigCar) {
BigCar bc = (BigCar) obj;
return super.equals(bc) && count == bc.count;
}
return super.equals(obj);
}
public static void main(String[] args) {
Car c = new Car(1);
BigCar bc = new BigCar(1, 20);
BigCar bc2 = new BigCar(1, 22);
System.out.println(bc.equals(c));
System.out.println(c.equals(bc2));
System.out.println(bc.equals(bc2));
}
}
運行結果：
true
true
false
bc，bc2，c的批次都是相同的，按我們之前的需求應該是相等，而且也應該符合equals的傳遞性才對。但是事實上運行結果卻不是這樣，違背了傳遞性。出現這種情況根本原因在於：
父類與子類進行混合比較。
子類中聲明了新變數，並且在子類equals方法使用了新增的成員變數作為判斷對象是否相等的條件。
只要滿足上面兩個條件，equals方法的傳遞性便失效了。而且目前並沒有直接的方法可以解決這個問題。因此我們在重寫equals方法時這一點需要特別注意。雖然沒有直接的解決方法，但是間接的解決方案還說有滴，那就是通過組合的方式來代替繼承,還有一點要注意的是組合的方式並非真正意義上的解決問題（只是讓它們間的比較都返回了false，從而不違背傳遞性，然而並沒有實現我們上面batch相同對象就相等的需求），而是讓equals方法滿足各種特性的前提下，讓代碼看起來更加合情合理，代碼如下：
package com.zejian.test;
public class Combination4BigCar {
private Car c;
private int count;
public Combination4BigCar(int batch, int count) {
c = new Car(batch);
this.count = count;
}
@Override
public boolean equals(Object obj) {
if (obj instanceof Combination4BigCar) {
Combination4BigCar bc = (Combination4BigCar) obj;
return c.equals(bc.c) && count == bc.count;
}
return false;
}
}
從代碼來看即使batch相同，Combination4BigCar類的對象與Car類的對象間的比較也永遠都是false，但是這樣看起來也就合情合理了，畢竟Combination4BigCar也不是Car的子類，因此equals方法也就沒必要提供任何對Car的比較支持，同時也不會違背了equals方法的傳遞性。
4.equals()的重寫規則之必要性深入解讀
前面我們一再強調了equals方法重寫必須遵守的規則，接下來我們就是分析一個反面的例子，看看不遵守這些規則到底會造成什麼樣的後果。
package com.zejian.test;
import java.util.ArrayList;
import java.util.List;
/** * 反面例子 * @author zejian */
public class AbnormalResult {
public static void main(String[] args) {
List<A> list = new ArrayList<A>();
A a = new A();
B b = new B();
list.add(a);
System.out.println("list.contains(a)->" + list.contains(a));
System.out.println("list.contains(b)->" + list.contains(b));
list.clear();
list.add(b);
System.out.println("list.contains(a)->" + list.contains(a));
System.out.println("list.contains(b)->" + list.contains(b));
}
static class A {
@Override
public boolean equals(Object obj) {
return obj instanceof A;
}
}
static class B extends A {
@Override
public boolean equals(Object obj) {
return obj instanceof B;
}
}
}
上面的代碼，我們聲明了 A,B兩個類，注意必須是static，否則無法被main調用。B類繼承A，兩個類都重寫了equals方法，但是根據我們前面的分析，這樣重寫是沒有遵守對稱性原則的，我們先來看看運行結果：
list.contains(a)->true
list.contains(b)->false
list.contains(a)->true
list.contains(b)->true
19行和24行的輸出沒什麼好說的，將a，b分別加入list中，list中自然會含有a，b。但是為什麼20行和23行結果會不一樣呢？我們先來看看contains方法內部實現
@Override
public boolean contains(Object o) {
return indexOf(o) != -1;
}
進入indexof方法
@Override
public int indexOf(Object o) {
E[] a = this.a;
if (o == null) {
for (int i = 0; i < a.length; i++)
if (a[i] == null)
return i;
} else {
for (int i = 0; i < a.length; i++)
if (o.equals(a[i]))
return i;
}
return -1;
}
可以看出最終調用的是對象的equals方法，所以當調用20行代碼list.contains(b)時，實際上調用了
b.equals(a[i]),a[i]是集合中的元素集合中的類型而且為A類型(只添加了a對象)，雖然B繼承了A,但此時
a[i] instanceof B
結果為false，equals方法也就會返回false；而當調用23行代碼list.contains(a)時，實際上調用了a.equal(a[i]),其中a[i]是集合中的元素而且為B類型(只添加了b對象)，由於B類型肯定是A類型（B繼承了A），所以
a[i] instanceof A
結果為true，equals方法也就會返回true，這就是整個過程。但很明顯結果是有問題的，因為我們的 list的泛型是A,而B又繼承了A，此時無論加入了a還是b，都屬於同種類型，所以無論是contains(a),還是contains(b)都應該返回true才算正常。而最終卻出現上面的結果，這就是因為重寫equals方法時沒遵守對稱性原則導致的結果，如果沒遵守傳遞性也同樣會造成上述的結果。當然這里的解決方法也比較簡單，我們只要將B類的equals方法修改一下就可以了。
static class B extends A{
@Override
public boolean equals(Object obj) {
if(obj instanceof B){
return true;
}
return super.equals(obj);
}
}
到此，我們也應該明白了重寫equals必須遵守幾點原則的重要性了。當然這里不止是list，只要是java集合類或者java類庫中的其他方法，重寫equals不遵守5點原則的話，都可能出現意想不到的結果。
5.為什麼重寫equals()的同時還得重寫hashCode()
這個問題之前我也很好奇，不過最後還是在書上得到了比較明朗的解釋，當然這個問題主要是針對映射相關的操作（Map介面）。學過數據結構的同學都知道Map介面的類會使用到鍵對象的哈希碼，當我們調用put方法或者get方法對Map容器進行操作時，都是根據鍵對象的哈希碼來計算存儲位置的，因此如果我們對哈希碼的獲取沒有相關保證，就可能會得不到預期的結果。在java中，我們可以使用hashCode()來獲取對象的哈希碼，其值就是對象的存儲地址，這個方法在Object類中聲明，因此所有的子類都含有該方法。那我們先來認識一下hashCode()這個方法吧。hashCode的意思就是散列碼，也就是哈希碼，是由對象導出的一個整型值，散列碼是沒有規律的，如果x與y是兩個不同的對象，那麼x.hashCode()與y.hashCode()基本是不會相同的，下面通過String類的hashCode()計算一組散列碼：
package com.zejian.test;
public class HashCodeTest {
public static void main(String[] args) {
int hash=0;
String s="ok";
StringBuilder sb =new StringBuilder(s);
System.out.println(s.hashCode()+" "+sb.hashCode());
String t = new String("ok");
StringBuilder tb =new StringBuilder(s);
System.out.println(t.hashCode()+" "+tb.hashCode());
}
}
運行結果：
3548 1829164700
3548 2018699554
我們可以看出，字元串s與t擁有相同的散列碼，這是因為字元串的散列碼是由內容導出的。而字元串緩沖sb與tb卻有著不同的散列碼，這是因為StringBuilder沒有重寫hashCode方法，它的散列碼是由Object類默認的hashCode方法計算出來的對象存儲地址，所以散列碼自然也就不同了。那麼我們該如何重寫出一個較好的hashCode方法呢，其實並不難，我們只要合理地組織對象的散列碼，就能夠讓不同的對象產生比較均勻的散列碼。
原文鏈接：https://blog.csdn.net/javazejian/article/details/51348320
❺ 方法重載和重寫的區別
重載：重載字面意思多次的意思，也就是同一個方法實現多個不同的邏輯，並可以在同一個類中可以實現。其實現的原理是，方法名相同，參數的個數或者類型不同即可。
重寫：重寫就是要重新去寫（實現），一個類中不可能兩個定義一樣的方法。因此，重寫就是子類對父類定義的方法重新實現一次。
(5)重寫原理分析方法擴展閱讀
一、方法重載的具體規范：
1、必須具有不同的參數列表；
2、可以有不同的返回類型，只要參數列表不同就可以了；
3、可以有不同的訪問修飾符；
4、可以拋出不同的異常。
二、方法重寫的具體規范：
1、參數列表必須完全與被重寫的方法相同，否則不能稱其為重寫而是重載；
2、返回的類型必須一直與被重寫的方法的返回類型相同，否則不能稱其為重寫而是重載；
3、訪問修飾符的限制一定要大於被重寫方法的訪問修飾符號、（public>protected>default>private）；
4、重寫方法一定不能拋出新的檢查異常或者比被重寫方法申明更加寬泛的檢查型異常。
參考資料：搜狗網路——方法重載搜狗網路——方法重寫
❻ java重載和重寫的區別
怎樣才算是一個方法覆蓋：
1 首先要保證方法名、參數類型、參數個數、參數順序完全一樣
2 返回類型也必須要一致
3 子類方法不能縮小父類方法的訪問許可權比如不能由public變成
private了如果可以的話請看下面一段代碼會出現什麼問題
4 子類方法不能拋出比父類方法更多的異常，只能夠相同，或者是父類
方法拋出的異常類的子類。
因為如果可以的話，就會與Java語言的多態機制發生沖突
5 父類的static方法不能被子類覆蓋為非static方法 子類可以定義
static方法覆蓋父類的static方法 子類不可以定義static方法覆蓋父
類的非static方法
6 子類方法覆蓋父類方法的前提是，子類必須能夠繼承父類的特定方法
7 父類的抽象方法可以被子類通過兩種途徑覆蓋：一是子類實現父類的
抽象方法；二是子類重新聲明父類的抽象方法。
所以答案1：methodTwo和methodFour覆蓋了父類的方法。分析各個方法：因為methodOne不符合規則5，所以沒有覆蓋。你的methodTwo我認為應該是public static void 不是你發出來的public void void,所以符合規則5，所以methodTwo覆蓋了父類的方法。methodThree方法不符合規則5，所以沒有覆蓋。methodFour符合規則5，所以覆蓋了父類的方法。
答案2：重載是在同一個類中，所以子類沒有可能重載父類的任何一個方法。原則是：方法名一樣。所以父類的四個方法都沒有被子類重載。
問題3：根據原則5，可以看出static對方法覆蓋有影響，對重載也沒有影響。
第四個問題：是覆蓋。因為方法名一樣，返回類型一樣，參數個數和參數類型一樣。重載是在同一個類中，所以不是重載。
第五個問題：因為Object有toString方法，而所有的類都是繼承自Object，所以每個類中都有一個toString方法，如果我們在類中再寫toString方法，就是重載了。覆蓋是在父類和子類中說的，也就是平時所說的方法重寫。
對於方法重載來說，關鍵就是參數的類型、參數的個數、參數的順序至
少有一項不相同。至於修飾符
（private/protected/public/abstract/final/static），返回類型都
無所謂。
❼ java中重載和重寫有什麼區別最好舉一個程序例子分析一下。3Q
1，重載是指方法的參數個數或者類型不同，如果function(int i){}與function(String s){}，這個構成了重載。
2，重寫是指子類覆蓋了父類的方法，子類的方法名、參數與父類相同，就是重寫
❽ 文件重寫方法和原理(知情者進)
1、選用專業文件粉碎機軟體：
＞Data Shredder(www.datashreddergold.com)
CBL公司的Data Shredder，符合美國、加拿大、德國和英國政府數據消除標准。真正清空你的垃圾籮而不只是刪除而已。方式是通過多次重寫反復改寫數據不同的位模式，直到它完全無可挽救。
＞Eraser(www.heidi.ie/eraser/)
徹底刪除文件、清除回收站內刪除的文件，以及清除驅動器未用磁碟空間，但不影響未刪除的文件的工具軟體，可以徹底清除以前刪除文件的任何痕跡。
程序支持最高的Gutmann演算法35次消除，同時還內置符合美國防部U.S. DOD 5220.22-M標準的U.S. DOD 5220.22-M（C and E）消除演算法，可以徹底防止軟體和硬體恢復的工具。
程序同時也內置防止軟體恢復且速度快的Pseudorandom Data（偽隨機數據覆蓋）演算法。另外軟體允許用戶自己定製消除演算法。
＞Wipe(wipe.sourceforge.net/)
卸載工具EZ Wipe V2.0是文件清理工具，可以用來刪除檔案文件。 只要滑鼠點擊就可以完成任務，功能也很強大，所有的被刪除文件據說都不能復員。
＞Evidence Nuker( www.EvidenceNuker.com）
據說可永久刪除以下的電腦選項：Address Bar History、Browser Cache、Visited Sites History、Cookies、Autocomplete Data、Documents History、Recycle Bin、Run History、Search / Find Menu history、Windows Temp folder、Error Checking Temp、Click History、Clipboard，以及Media playerhistory。
＞Zilla Data Nuker(zilla-data-nuker.en.softonic.com/ )
適用於視窗95、98、me、XP、NT3.x 、NT4.x版本，以及2000，據知能以不同的粉碎文件方式（例如：快速模式） 粉碎銷毀硬碟驅動器里的任何敏感文件。
＞File Shredder(www.fileshredder.org)
集免費的個人和商業用途於一體的軟體，適合Windows NT 、 2000 、 XP、2003年的伺服器和Vista平台 。可選擇5種不同的碎紙法，也能掃除剩餘磁碟空間。
另外，眾多國內的軟體如優化大師、瑞星、金山、上網助手等軟體也都擁有文件粉碎功能，可嘗試使用。
2、在Windows 2000以上版本都內置了一個這樣的工具——cipher.exe。cipher使用方法很簡單，在命令行窗口中，鍵入： cipher /w:盤符:\目錄
其中，目錄是可選的，用於卷掛接點。一般情況下，只寫磁碟盤符就行了。比如清除E盤，就用「cipher /w:e」。
命令開始運行後，會依次用0X00、 0XFF和隨意數字覆蓋該分區中的全部空閑空間，能夠消除任何已刪除文件的痕跡。 此命令適用於NTFS格式的磁碟。cipher命令存在於Windows 2000、Windows XP、Windows 2003和Vista。
3、文件泄露的一個很主要的途徑就是在電腦維修時發生的。一個比較可行也更實在的方法，是將電腦硬碟上鎖。市面上一些筆記本電腦已經出現硬碟上鎖功能，如聯想的TVT (ThinkVantage Technology) 安全技術，就可以將電腦硬碟的資料上鎖，包括指紋識別軟體及IBM安全晶元系統，提供進階的加密措施並方便管理，即使將電腦送去維修，也不怕資料被盜取 。利用每個人的指紋將電腦里的數據安全的鎖在電腦里的保安方式最可靠。