Java提升學習（三）：抽象類、多態、接口

一、抽象類
父類中的方法，被它的子類們重寫，子類各自的實現都不盡相同。那麼父類的方法聲明和方法主體，只有聲明還有意義，而方法主體則沒有存在的意義了。我們把沒有方法主體的方法稱爲抽象方法。Java語法規定，包含抽象方法的類就是抽象類。

就像上面所畫出來的例子，圖形可以計算面積，但是，得具體到什麼圖形，動物們可以吃東西，但得具體到他們吃什麼東西。

定義：

修飾符 abstract 返回值類型 方法名 (參數列表)；

public abstract class animal {
	
	public abstract void eat();
	
}

注意：抽象方法所在的類，必須是抽象類，該抽象類中可以有其他非抽象方法。

使用：

創建抽象類

public abstract class first {

		public abstract void run();
}

繼承抽象類，去除abstract，並重寫

public class second extends first{
		
		@Override
		public void run() {
			System.out.print("rush B!!");
		}
}

實例化

public class third {

		public static void main(String[] args) {
			second a = new second();
			a.run();
	}
}
//----------輸出------------
rush B!!

值得注意的是：使用抽象類不得直接new一個對象，需要定義一個子類；
子類必須重寫父類方法；
抽象類中，可以有構造方法，是供子類創建對象時，初始化父類成員使用的；
抽象類中，不一定包含抽象方法，但是有抽象方法的類必定是抽象類。

二、多態
多態是繼封裝、繼承之後，面向對象的第三大特性。
多態是指：一個對象，既有一種性質，又有父類性質，同一行爲，具有多個不同表現形式。
生活中，比如跑的動作，小貓、小狗和大象，跑起來是不一樣的。再比如飛的動作，昆蟲、鳥類和飛機，飛起來也是不一樣的。可見，同一行爲，通過不同的事物，可以體現出來的不同的形態。多態，描述的就是這樣的狀態。

定義：

父類類型 變量名 = new 子類對象； 
變量名.方法名();

Fu f = new Zi(); 
f.method();

示例：

public abstract class first {

		public abstract void run();
		
		public void fly() {
			System.out.println("you can fly!");
		}
}


public class second extends first{
		
		@Override
		public void run() {
			System.out.println("rush B!!");
		}
	
}

當使用多態方式調用方法時，首先檢查父類中是否有該方法，如果沒有，則編譯錯誤；如果有，執行的是子類重寫後方法。


public class third {

	public static void main(String[] args) {
		first a = new second();//多態
		a.run();
		a.fly();//子方法沒有，繼續從上一層找。
	}
}
//---------輸出-----------
rush B!!
you can fly!

多態的好處：實際開發的過程中，父類類型作爲方法形式參數，傳遞子類對象給方法，進行方法的調用，更能體現出多態的擴展性與便利。

public abstract class first {

		public abstract void run();
		
}

public class second extends first{
		
		@Override
		public void run() {
			System.out.println("rush B!!");
		}
}

public class third extends first{
		
		public void run() {
			System.out.println("rush A!!");
		}
}

public class text {
	
	public static void output(first x) {
		x.run();
	}

	public static void main(String[] args) {
		first a = new second();//多態
		first b = new third();
		
		output(a);
		output(b);
	}
}
//----------輸出---------
rush B!!
rush A!!

從此處可以看出，多態是極其方便的，極容易對其擴展。

至此：Java的面向對象的三大性質記錄結束：封裝，繼承，多態。

三、接口
接口，是Java語言中一種引用類型，是方法的集合，如果說類的內部封裝了成員變量、構造方法和成員方法，那麼接口的內部主要就是封裝了方法。

定義：把class換成了interface

public interface 接口名稱 {
     // 抽象方法     
     // 默認方法     
     // 靜態方法     
     // 私有方法 
 }

使用：
通過interface定義一個接口類，通過implements來實現（類似繼承）。

含抽象方法：使用 abstract 關鍵字修飾，可以省略，沒有方法體。該方法供子類實現使用。

public interface InterFaceName {
     public abstract void method(); 
 }

定義接口：

public interface LiveAble {
     // 定義抽象方法     
     public abstract void eat();     
     public abstract void sleep(); 
 }

定義實現類：

public class Animal implements LiveAble {
     @Override     
     public void eat() {         
     	System.out.println("吃東西");     
}
     @Override     
     public void sleep() {
        System.out.println("晚上睡");
     } 
}

定義測試類：

public class InterfaceDemo {
     public static void main(String[] args) {
          // 創建子類對象           
          Animal a = new Animal();         
          // 調用實現後的方法         
          a.eat();         
          a.sleep();
      } 
  }//---------輸出---------
  吃東西 
  晚上睡

值得注意的是：調用接口的時候必須將其中的所有接口進行方法重寫，不然實現類自己就是抽象類。

含有默認方法：使用 default 修飾，不可省略，供子類調用或者子類重寫。

public interface InterFaceName {
     public default void method() { 
     	// 執行語句 
 }

定義接口：

public interface LiveAble {
     public default void fly(){         
     	System.out.println("天上飛");
     } 
 }

定義實現類：

public class Animal implements LiveAble {     
	@Override     
	public void fly() {
	         System.out.println("自由自在的飛"); 
	 } 
}

定義測試類：

public class InterfaceDemo {
     public static void main(String[] args) {
          // 創建子類對象           
          Animal a = new Animal();         
          // 調用重寫方法         
          a.fly(); 
          } 
 } 
 //-----------輸出------------- 
 自由自在的飛

如果去掉實現類裏的方法覆蓋重寫，將調用接口裏的默認方法。

含有靜態方法：使用 static 修飾，供接口直接調用。

public interface InterFaceName {
     public static void method(){
     	//執行語句
     } 
 }

定義接口：

public interface LiveAble {
     public static void run(){
              System.out.println("ruch B!!");
      } 
}

定義實現類：

public class Animal implements LiveAble {
 	// 無法重寫靜態方法      
 }

定義測試類：

public class InterfaceDemo {
     public static void main(String[] args) {
         // Animal.run(); // 【錯誤】無法繼承方法,也無法調用         
         LiveAble.run(); //      
      } 

} 
//----------輸出------------
ruch B!!

可以看出，需要直接從接口調用方法。

接口多實現：
之前學過，在繼承體系中，一個類只能繼承一個父類。而對於接口而言，一個類是可以實現多個接口的，這叫做接口的多實現。並且，一個類能繼承一個父類，同時實現多個接口。

class 類名 [extends 父類名] implements 接口名1,接口名2,接口名3... {
     // 重寫接口中抽象方法【必須】    
     // 重寫接口中默認方法【不重名時可選】    
     }

抽象方法：接口中，有多個抽象方法時，實現類必須重寫所有抽象方法。如果抽象方法有重名的，只需要重寫一次。
定義多個接口：

public interface A {
     public abstract void showA();
     public abstract void show();
   }

public interface B {
     public abstract void showB();     
     public abstract void show(); 
   }

public class C implements A,B{
	@Override
	public void showA() {
	         System.out.println("showA");     
	
	} 
	@Override     
	public void showB() {
	         System.out.println("showB");     
	 }
	 @Override     
	 public void show() {
	          System.out.println("show");    			
	 } 
}

默認方法：接口中，有多個默認方法時，實現類都可繼承使用。如果默認方法有重名的，必須重寫一次。
定義多個接口：

public interface A {
     public default void methodA(){} 
     public default void method(){} }    public interface B {
     public default void methodB(){}    
     public default void method(){} }

定義實現類:

public class C implements A,B{
     @Override     
     public void method() {
              System.out.println("method");     
      } 
}

靜態方法：接口中，存在同名的靜態方法並不會衝突，原因是隻能通過各自接口名訪問靜態方法。

優先級：當一個類，既繼承一個父類，又實現若干個接口時，父類中的成員方法與接口中的默認方法重名，子類就近選擇執行父類的成員方法。

interface A {//定義接口
     public default void methodA(){
              System.out.println("AAAAAAAAAAAA");
      } }

class D {//定義父類
     public void methodA(){
              System.out.println("DDDDDDDDDDDD");
     }

class C extends D implements A {//定義子類
    // 未重寫methodA方法    
    }

public class Test {
     public static void main(String[] args) {
         C c = new C();         
         c.methodA();
         } 
} 
//-----------輸出----------
 DDDDDDDDDDDD

接口的繼承：一個接口能繼承另一個或者多個接口，這和類之間的繼承比較相似。接口的繼承使用 extends 關鍵字，子接口繼承父接口的方法。如果父接口中的默認方法有重名的，那麼子接口需要重寫一次。

interface A {
     public default void method(){
              System.out.println("AAAAAAAAAAAAAAAAAAA");     } }   
interface B {
     public default void method(){
              System.out.println("BBBBBBBBBBBBBBBBBBB");     } }

interface D extends A,B{
     @Override     
     public default void method() {
              System.out.println("DDDDDDDDDDDDDD");     
     } }

值得注意的是：子接口重寫默認方法時，default關鍵字可以保留。子類重寫默認方法時，default關鍵字不可以保留。

接口中，無法定義成員變量，但是可以定義常量，其值不可以改變，默認使用public static ﬁnal修飾。接口中，沒有構造方法，不能創建對象。
接口中，沒有靜態代碼塊。
接口中，不得有私有方法，私有變量。

Java提升學習（三）：抽象類、多態、接口

Java提升學習（三）：抽象類、多態、接口

釘釘打卡速度慢

Nginx R31 doc 官方文檔-01-nginx 如何安裝

Qt/C++音視頻開發74-合併標籤圖形/生成yolo運算結果圖形/文字和圖形合併成一個/水印濾鏡

挑戰程序設計競賽 2.2章習題 POJ - 3617 Best Cow Line 貪心

字節面試：MySQL什麼時候鎖表？如何防止鎖表？

.NET8連接SQL SERVER 2008 R2 報：證書鏈是由不受信任的頒發機構頒發的

golang開發環境搭建(win10)

python計算機視覺學習筆記——PIL庫的用法

Golang初學：獲取程序內存使用情況，std runtime

C語言網練習題：蛇行矩陣Python的解題方法

Java基礎學習（三）：方法的定義和使用、可變參數

Java基礎學習（二）：常量變量，運算符，表達式，關鍵字

Java基礎學習（六）：StringBuilder、StringBuffer、String類方法彙總

用來圖像識別pytesseract，tesseract的相關問題和方法

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結