重寫

             定義：重寫是子類對父類的允許訪問的方法的實過程進行重現新編寫, 返回值和形參都不能改變。即外殼不變，核心重寫！

            重寫的好處在於子類可以根據需要，定義特定於自己的行為。 也就是說子類能夠根據需要實現父類的方法。

class Member {                            //普通會員類

    String username;                      //名字

    List<String>  list=new ArrayList();   
 
    public void setUserName(String username){
    	this.username=username;
    }
    
    public void watchPower(){            //普通會員可以看以看的視屏的清晰度
    	list.add("流暢");
    	list.add("標清");
    	list.add("高清");       
    }	
    public void showPower(){                
    	System.out.print("使用者"+username+"可以看：");
    	for(String i:list){
    		System.out.print(i+"     ");
    	}
    }

}
 

class  SuperMember extends Member{
	
	public void watchPower() {    //重寫
		list.add("流暢");
		list.add("標清");
    	list.add("高清");
		list.add("超清");
	}
  
}

上面是一個看視屏的例子，普通使用者可以看流暢、標清、高清，超級使用者還可以看超清，重寫了watchPower 這個方法。

    重寫規則： 兩同兩小，一大原則：

                       方法名相同，引數型別相同。

                       子類返回型別小於等於父類返回型別，

                       子類丟擲異常小於父類方法丟擲異常，

                       子類訪問許可權大於等於父類訪問許可權。

                       宣告為final的方法不能被重寫。

                       宣告為static的方法不能被重寫，但是能夠被再次宣告。

                       子類和父類在同一個包中，那麼子類可以重寫父類所有方法，除了宣告為private和final的方法。

                       子類和父類不在同一個包中，那麼子類只能夠重寫父類的宣告為public和protected的非final方法。

                       構造方法不能被重寫。

                       如果不能繼承一個方法，則不能重寫這個方法。

過載            

過載(overloading) 是在一個類裡面，方法名字相同，而引數不同。返回型別可以相同也可以不同。

每個過載的方法（或者建構函式）都必須有一個獨一無二的引數型別列表。

最常用的地方就是構造器的過載。

過載規則:

• 被過載的方法必須改變引數列表(引數個數或型別不一樣)；
• 被過載的方法可以改變返回型別；
• 被過載的方法可以改變訪問修飾符；
• 被過載的方法可以宣告新的或更廣的檢查異常；
• 方法能夠在同一個類中或者在一個子類中被過載。
• 無法以返回值型別作為過載函式的區分標準。

重寫與過載之間的區別

總結

方法的重寫(Overriding)和過載(Overloading)是java多型性的不同表現，重寫是父類與子類之間多型性的一種表現，過載可以理解成多型的具體表現形式。

• (1)方法過載是一個類中定義了多個方法名相同,而他們的引數的數量不同或數量相同而型別和次序不同,則稱為方法的過載(Overloading)。
• (2)方法重寫是在子類存在方法與父類的方法的名字相同,而且引數的個數與型別一樣,返回值也一樣或者比父類方法返回型別小的方法,就稱為重寫(Overriding)。
• (3)方法過載是一個類的多型性表現,而方法重寫是子類與父類的一種多型性表現。

多型

多型是同一個行為具有的多個不同表現形式或形態的能力。

多型存在的三個必要條件

• 繼承
• 重寫
• 父類引用指向子類物件

博主個人認為，多型分為兩種，一種賦值多型，一種傳參多型。

賦值多型；就是指父類的引用指向了子類，當父類的引用變數執行同一個函式時，執行不同的操作。

傳參多型：就是指擴大一個函式的入口範圍，使某個頂級父類作為這個函式的引數型別，從而可以讓每一個子類物件都可以傳參進來。

下面，先給大家用程式碼分別表現一下賦值多型和傳參多型。

賦值多型：

定義一個usb介面，提供給介面方法。

public interface UsbInter {
	public  void transferSingal();
	public void transferFile();
	public void charging();
}

 定義一個電腦Usb的類把功能加進來

public class Usb implements UsbInter{ 
         
	public void transferSingal(){
		System.out.println("接收訊號入口");
	}
	public void transferFile(){
		System.out.println("接收檔案");
	}
	public void charging(){
		System.out.println("充電");
	}
}

 滑鼠實現了這個介面，它只有傳輸訊號的功能

public class Mouse implements UsbInter{
	public void transferSingal() {
	    System.out.println("輸出訊號");
	}
	public void transferFile() {
		System.out.println("無此功能");
	}
	public void charging() {
	   System.out.println("無此功能");
	}
}

 u盤實現了這個介面，他只有傳檔案的功能

public class UsbDrive implements UsbInter{
    public void transferSingal() {
    	System.out.println("無此功能");
    }
    public void transferFile() {
    	System.out.println("傳輸檔案");
    }
    public void charging() {
    	System.out.println("無此功能");
    }
}

 手機實現，它出了傳輸訊號，傳檔案，還有可以被充電的功能。

public class Phone implements UsbInter{
		public void transferSingal() {
			// TODO Auto-generated method stub
			 System.err.println("傳輸訊號");
		}
		   public void transferFile() {
		      System.out.println("傳輸檔案");
		   }
		public void charging() {
		System.out.println("正在充電");
		}
}

測試類

public class Test {
    public static void main(String[] args) {
		UsbInter uInter=new Usb();
		UsbInter uInter2=new Mouse();
		UsbInter uInter3=new Phone();
		UsbInter uInter4=new UsbDrive();
		uInter.charging();
		uInter2.charging();
		uInter3.charging();
		uInter4.charging();
	
	}
}

結果

充電
無此功能
正在充電
無此功能

可以看到同一種類型的引用變數，由於指向了不同的子類型別之後，執行同一個函式時，進行了不同的操作。

傳參多型：

建立使用者類

public class User {
    private  String name;
    private  String passWord;
    private  int  score;
         
      public  User(){}
     
      public User(String name,String pass0) {
		this.name=name;
		this.passWord=passWord;
	}
    
      public static final void alterPassWord(User user,String pass0) {
		user.passWord=pass0;
		System.out.println(user.name+"  您好，您已經成功修改密碼");
	}
 
}

建立Student類

public class Student extends User{
    
	public Student(String name,String PassWord) {
		super(name, PassWord);
	}
	
}

建立教師類

public class Teacher extends User {
	public Teacher(String name,String PassWord) {
		super(name, PassWord);
	}
}

建立測試類

public class Test {
    public static void main(String[] args) {
    	Student s1=new Student("lxt","1234ds");
    	Teacher t1=new Teacher("sjc", "dsfa");
    	User.alterPassWord(s1, "queen");
    	User.alterPassWord(t1, "kingdom");
	}
}

可以看到Student，和Teacher是無法自己更改密碼的，必須user類呼叫。並且可以看到，alterPassWord方法並沒有過載，而是傳了一個User型別的引數，這樣當引用變數為，User或者Student或者Teacher時，都可以使用，從而做到了多型。

結果：

lxt  您好，您已經成功修改密碼
sjc  您好，您已經成功修改密碼