一 .抽象類

1. 介紹

1.1基本用法

隨着繼承層次中一個個新子類的定義，類變得越來越具體，而父類則更一般，更通用。類的設計應該保證父類和子類能夠共享特徵。有時將一個父類設計得非常抽象，以至於它沒有具體的實例，這樣的類叫做抽象類。

用abstract關鍵字來修飾一個類，這個類叫做抽象類。
比如：abstract class A{ }
用abstract來修飾一個方法，該方法叫做抽象方法。
- 抽象方法：只有方法的聲明，沒有方法的實現。以分號結束：比如：public abstract void talk();

1.2 抽象類的匿名子類

以下代碼中的Person類是一個抽象類

① 非匿名的類非匿名的對象

		Worker worker = new Worker();
		method1(worker);//非匿名的類非匿名的對象

② 非匿名的類匿名的對象

method1(new Worker());

③ 匿名子類的對象

            Person p = new Person(){//Person是一個抽象類，不能實例化，這兒運用了多態的性質
			@Override
			public void eat() {
				System.out.println("喫東西");
			}
		};
		
		method1(p);

④ 匿名子類的匿名對象

method1(new Person(){
			@Override
			public void eat() {
				System.out.println("喫好喫東西");
			}
		});

2. 注意事項

抽象類中一定有構造器，便於子類實例化時調用（涉及：子類對象實例化的全過程）
抽象方法不能包含在非抽象類中。如果抽象父類的子類不能實現所有的抽象方法，那麼子類也必須定義爲抽象的。換句話說，在抽象類擴展的非抽象子類中，必須實現所有的抽象方法。還要注意到，抽象方法是非靜態的。
不能用abstract修飾變量、代碼塊、構造器。
不能用abstract修飾私有方法、靜態方法、final的方法、final的類。但是可以有靜態方法，靜態方法的好處是不實例化就可由抽象類或子類類名直接調用
可以定義一個抽象類的對象變量，但是他只能引用非抽象類的對象。 如下代碼，這裏的p是一個抽象類Person的變量，Person引用了一個非抽象子類Student的實例。

Person p = new Student("John");

即使子類的父類是具體的，這個子類也可以是抽象的。
不能使用 new 操作符從一個抽象類創建一個實例，但是抽象類可以用作一種數據類
型。因此，下面的語句創建一個元素是 CeometricObject 類型的數組是正確的：

GeometricObject[] objects = new CeometricObject[10];

    然後可以創建一個 CeometricObject 的實例，並將它的引用陚值給數組，如下所示：

objects[0] =new Circle（）;

關於構造器與靜態方法的代碼如下：

abstract class AbstractClass{
    /**
     * 輸出
     */
    abstract void print();

    /**
     *
     */
    public AbstractClass() {//抽象類中可以定義構造器，雖然不能初始化，可以被子類繼承
        System.out.println("abstract class");
    }
    public static void staticAbstractMethod() {
        System.out.println("I am static method");
    }
}
/**
 * @author sir
 */
public class AbstractClassTest extends AbstractClass{
    public AbstractClassTest() {
        System.out.println("子類構造器");
    }
    @Override
    void print() {
        System.out.println("test");
    }
    public static void main(String[] args) {
        AbstractClassTest.staticAbstractMethod();//抽象類中可以定義靜態方法，可直接由類名調用
        AbstractClass.staticAbstractMethod();
        new AbstractClassTest().print();
    }

}

輸出結果：

二. 接口

1.介紹

1.1 基本用法

接口是一種與類相似的結構，它在許多方面都與抽象類很相似，但是它的目的是指明相關或者不相關類的多個對象的共同行爲。接口就是規範，定義的是一組規則，體現了現實世界中“如果你是/要…則必須能…”的思想。繼承是一個"是不是"的關係，而接口實現則是 "能不能"的關係。
語法：

修飾符 interface 接口名 {
 /** 常量聲明 */
  /** 方法簽名 */
}

定義Java類的語法格式：先寫extends，後寫implements

 class SubClass extends SuperClass implements InterfaceA{ }

接口中不能定義構造器的！意味着接口不可以實例化。
Java開發中，接口通過讓類去實現(implements)的方式來使用。類和接口之間的關係稱爲接口繼承（ interface inheritance)。因爲接口繼承和類繼承本質上是相同的，所以我們將它們都簡稱爲繼承。如果實現類覆蓋了接口中的所有抽象方法，則此實現類就可以實例化。如果實現類沒有覆蓋接口中所有的抽象方法，則此實現類仍爲一個抽象類。
Java類可以實現多個接口，彌補了Java單繼承性的侷限性
格式：class AA extends BB implements CC,DD,EE
接口與接口之間可以繼承，而且可以多繼承

1.2接口和抽象類之間的對比

接口示例：

public class USBTest {
    public static void main(String[] args) {

        Computer computer = new Computer();
        //1.創建了接口的非匿名實現類的非匿名對象
        Flash flash = new Flash();
        computer.transferData(flash);

        //2. 創建了接口的非匿名實現類的匿名對象
        computer.transferData(new Printer());

        //3. 創建了接口的匿名實現類的非匿名對象
        USB phone = new USB(){

            @Override
            public void start() {
                System.out.println("手機開始工作");
            }

            @Override
            public void stop() {
                System.out.println("手機結束工作");
            }

        };
        computer.transferData(phone);


        //4. 創建了接口的匿名實現類的匿名對象

        computer.transferData(new USB(){
            @Override
            public void start() {
                System.out.println("mp3開始工作");
            }

            @Override
            public void stop() {
                System.out.println("mp3結束工作");
            }
        });
    }
}

class Computer{

    public void transferData(USB usb){//USB usb = new Flash();
        usb.start();

        System.out.println("具體傳輸數據的細節");

        usb.stop();
    }


}

interface USB{
    //常量：定義了長、寬、最大最小的傳輸速度等

    void start();

    void stop();

}

class Flash implements USB{

    @Override
    public void start() {
        System.out.println("U盤開啓工作");
    }

    @Override
    public void stop() {
        System.out.println("U盤結束工作");
    }

}

class Printer implements USB{
    @Override
    public void start() {
        System.out.println("打印機開啓工作");
    }

    @Override
    public void stop() {
        System.out.println("打印機結束工作");
    }

}

1.3JDK8接口新特性

除了定義全局常量和抽象方法之外，還可以定義靜態方法、默認方法
Java 8中，你可以爲接口添加靜態方法和默認方法。從技術角度來說，這是完全合法的，只是它看起來違反了接口作爲一個抽象定義的理念。

靜態方法：使用 static 關鍵字修飾。可以通過接口直接調用靜態方法，並執行其方法體。 我們經常在相互一起使用的類中使用靜態方法。你可以在標準庫中找到像Collection/Collections或者Path/Paths這樣成對的接口和類。
默認方法：默認方法使用 default 關鍵字修飾。可以通過實現類對象來調用。 我們在已有的接口中提供新方法的同時，還保持了與舊版本代碼的兼容性。比如：java 8 API中對Collection、List、Comparator等接口提供了豐富的默認方法。
若一個接口中定義了一個默認方法，而另外一個接口中也定義了一個同名同參數的方法（不管此方法是否是默認方法），在實現類同時實現了這兩個接口時，會出現：接口衝突。
- 解決辦法：實現類必須覆蓋接口中同名同參數的方法，來解決衝突。
若一個接口中定義了一個默認方法，而父類中也定義了一個同名同參數的非抽象方法，則不會出現衝突問題。因爲此時遵守：類優先原則。接口中具有相同名稱和參數的默認方法會被忽略

public interface CompareA {
	
	//靜態方法
	public static void method1(){
		System.out.println("CompareA:北京");
	}
	//默認方法
	public default void method2(){
		System.out.println("CompareA：上海");
	}
	
	default void method3(){
		System.out.println("CompareA：上海");
	}
}

**********************************************

public interface CompareB {
	
	default void method3(){
		System.out.println("CompareB：上海");
	}
	
}
public class SuperClass {
	
	public void method3(){
		System.out.println("SuperClass:北京");
	}
	
}

**********************************************

public class SubClassTest {
	
	public static void main(String[] args) {
		SubClass s = new SubClass();
		
//		s.method1();
//		SubClass.method1();
		//知識點1：接口中定義的靜態方法，只能通過接口來調用。
		CompareA.method1();
		//知識點2：通過實現類的對象，可以調用接口中的默認方法。
		//如果實現類重寫了接口中的默認方法，調用時，仍然調用的是重寫以後的方法
		s.method2();
		//知識點3：如果子類(或實現類)繼承的父類和實現的接口中聲明瞭同名同參數的默認方法，
		//那麼子類在沒有重寫此方法的情況下，默認調用的是父類中的同名同參數的方法。-->類優先原則
		//知識點4：如果實現類實現了多個接口，而這多個接口中定義了同名同參數的默認方法，
		//那麼在實現類沒有重寫此方法的情況下，報錯。-->接口衝突。
		//這就需要我們必須在實現類中重寫此方法
		s.method3();
		
	}
	
}

*************************************************************

class SubClass extends SuperClass implements CompareA,CompareB{
	
	public void method2(){
		System.out.println("SubClass：上海");
	}
	
	public void method3(){
		System.out.println("SubClass：深圳");
	}
	
	//知識點5：如何在子類(或實現類)的方法中調用父類、接口中被重寫的方法
	public void myMethod(){
		method3();//調用自己定義的重寫的方法
		super.method3();//調用的是父類中聲明的
		//調用接口中的默認方法
		CompareA.super.method3();
		CompareB.super.method3();
	}
}

輸出結果：

2. Comparable接口

2.1 用法

Comparable 接口定義了 compareTo 方法，用於比較對象 。
compareTo 方法判斷這個對象相對於給定對象 o 的順序，並且當這個對象小於、等於或大於給定對象 o 時，分別返回負整數、0或正整數。
Comparable 接口是一個泛型接口。在實現該接口時，泛型類型 E 被替換成一種具體的類型。
Java 類庫中的許多類實現了 Comparable 接口以定義對象的自然順序。Byte、Short、Integer、Long、Float、Double、Character、Biglnteger、BigDecimalx Calendar、String以及 Date 類都實現了 Comparable 接口。

import java.util.Date;

/**
 * @author mazouri
 * @create 2020-04-12 17:40
 */
public class CompareTest {
    public static void main(String[] args) {
        System.out.println((new Integer(3).compareTo(new Integer(5))));
       // System.out.println((Integer.compare(3, 5)));當然可以用這個更好的方法
        System.out.println("ABC".compareTo("ABE"));
        Date date1 = new Date(1990, 1, 1);
        Date date2 = new Date(1989, 6, 4);
        System.out.println(date1.compareTo(date2));
    }
}

輸出結果：

2.2 自定義實現Comparable的類進行比較

題目：
定義一個接口用來實現兩個對象的比較。 interface CompareObject{ public int
compareTo(Object o);
//若返回值是 0 , 代表相等; 若爲正數，代表當前對象大；負數代表當前對象小 }
定義一個Circle類，聲明width，height屬性，提供getter和setter方法
定義一個ComparableRectangle.類，繼承Rectangle類並且實現CompareObject接口。在
ComparableCircle類中給出接口中方法compareTo的實現體，用來比較兩個長方形面積大小。
定義一個測試類ComparableRectangleTest，創建兩個ComparableRectangle對象，調用compareTo 方法比較兩個類的面積大小。

public interface CompareObject<C extends Rectangle> {
    /**
     * @return 若返回值是 0 , 代表相等; 若爲正數，代表當前對象大；負數代表當前對象小
     */
    int compareTo(Object o);
}

******************************************************************
public class Rectangle {
    private double width;
    private double height;

    public Rectangle() {
    }

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    public double getWidth() {
        return width;
    }

    public void setWidth(double width) {
        this.width = width;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    public double getArea() {
        return height * width;
    }
}

******************************************************************

public class ComparableRectangle extends Rectangle implements CompareObject {
    public ComparableRectangle() {
    }

    public ComparableRectangle(double width, double height) {
        super(width, height);
    }

    @Override
    public int compareTo(Object o) {
        if (this == o) {
            return 0;
        }

        if (o instanceof ComparableRectangle) {
            ComparableRectangle c = (ComparableRectangle) o;
            // return Double.compare(getArea(), c.getArea());
            if (getArea() > c.getArea()) {
                return 1;
            } else if (getArea() < c.getArea()) {
                return -1;
            } else {
                return 0;
            }
        } else {
            throw new RuntimeException("傳入的數據類型不匹配");
        }
    }
}

******************************************************************

public class ComparableRectangleTest {
    public static void main(String[] args) {
        ComparableRectangle c1 = new ComparableRectangle(2.2, 3.4);
        ComparableRectangle c2 = new ComparableRectangle(2.3, 3.4);

        int compareValue = c1.compareTo(c2);
        if (compareValue > 0) {
            System.out.println("c1對象大");
        } else if (compareValue < 0) {
            System.out.println("c2對象大");
        } else {
            System.out.println("c1與c2一樣大");
        }
    }
}

輸出結果：

三. 內部類

1. 介紹

當一個事物的內部，還有一個部分需要一個完整的結構進行描述，而這個內部的完整的結構又只爲外部事物提供服務，那麼整個內部的完整結構最好使用內部類。
在Java中，允許一個類的定義位於另一個類的內部，前者稱爲內部類，後者稱爲外部類。

分類：
① 成員內部類（static成員內部類和非static成員內部類）
② 局部內部類（不談修飾符）、匿名內部類

2.局部內部類

2.1 基本用法

java局部內部類就是在方法中定義的類，它僅在該方法中有效。

class 外部類{
方法(){
     class 局部內部類{ 
     }
  }
  {
     class 局部內部類{ 
     } 
   } 
 }

2.2 如何使用局部內部類：

只能在聲明它的方法或代碼塊中使用，而且是先聲明後使用。除此之外的任何地方都不能使用該類
但是它的對象可以通過外部方法的返回值返回使用，返回值類型只能是局部內部類的父類或父接口類型

2.3 局部內部類的特點

內部類仍然是一個獨立的類，在編譯之後內部類會被編譯成獨立的.class文件，但是前面冠以外部類的類名和$符號，以及數字編號。
只能在聲明它的方法或代碼塊中使用，而且是先聲明後使用。除此之外的任何地方都不能使用該類。
局部內部類可以使用外部類的成員，包括私有的。
局部內部類可以使用外部方法的局部變量，但是必須是final的。 由局部內部類和局部變量的聲明週期不同所致。
- jdk 7及之前版本：要求此局部變量顯式的聲明爲final的
- jdk 8及之後的版本：可以省略final的聲明
局部內部類和局部變量地位類似，不能使用public,protected,缺省,private
局部內部類不能使用static修飾，因此也不能包含靜態成員

3.匿名內部類

3.1 基本用法

匿名內部類不能定義任何靜態成員、方法和類，只能創建匿名內部類的一個實例。一個匿名內部類一定是在new的後面，用其隱含實現一個接口或實現一個類。
格式：

new 父類構造器（實參列表）實現接口(){
//匿名內部類的類體部分
}

interface A{
public abstract void fun1();
}
public class Outer{
public static void main(String[] args) {
new Outer().callInner(new A(){
//接口是不能new但此處比較特殊是子類對象實現接口，只不過沒有爲對象取名
public void fun1() {
System.out.println(“implement for fun1");
}
});// 兩步寫成一步了
}
public void callInner(A a) {
a.fun1();
}
}

3.2匿名內部類的特點

匿名內部類必須繼承父類或實現接口
匿名內部類只能有一個對象
匿名內部類對象只能使用多態形式引用

4.成員內部類

4.1 成員內部類作爲類的成員的角色：

和外部類不同，Inner class還可以聲明爲private或protected；
可以調用外部類的結構
Inner class 可以聲明爲static的，但此時就不能再使用外層類的非static的成員變量；

4.2 成員內部類作爲類的角色：

可以在內部定義屬性、方法、構造器等結構
可以聲明爲abstract類，因此可以被其它的內部類繼承
可以聲明爲final
編譯以後生成OuterClass$InnerClass.class字節碼文件（也適用於局部內部類）

注意

非static的成員內部類中的成員不能聲明爲static的，只有在外部類或static的成員內部類中才可聲明static成員。
外部類訪問成員內部類的成員，需要“內部類.成員”或“內部類.對象.成員”的方式
成員內部類可以直接使用外部類的所有成員，包括私有的數據
當想要在外部類的靜態成員部分使用內部類時，可以考慮內部類聲明爲靜態的

public class InnerClassTest {
	public static void main(String[] args) {
		
		//創建Dog實例(靜態的成員內部類):
		Person.Dog dog = new Person.Dog();
		dog.show();
		//創建Bird實例(非靜態的成員內部類):
//		Person.Bird bird = new Person.Bird();//錯誤的
		Person p = new Person();
		Person.Bird bird = p.new Bird();
		bird.sing();
		
		System.out.println();
		
		bird.display("黃鸝");
		
	}
}


class Person{
	
	String name = "小明";
	int age;
	
	public void eat(){
		System.out.println("人：喫飯");
	}
	
	
	//靜態成員內部類
	static class Dog{
		String name;
		int age;
		
		public void show(){
			System.out.println("卡拉是條狗");
//			eat();
		}
		
	}
	//非靜態成員內部類
	class Bird{
		String name = "杜鵑";
		
		public Bird(){
			
		}
		
		public void sing(){
			System.out.println("我是一隻小小鳥");
			Person.this.eat();//調用外部類的非靜態屬性
			eat();
			System.out.println(age);
		}
		
		public void display(String name){
			System.out.println(name);//方法的形參
			System.out.println(this.name);//內部類的屬性
			System.out.println(Person.this.name);//外部類的屬性
		}
	}
}

輸出結果：

一篇文章快速瞭解Java中的抽象類，接口和內部類（含JDK8接口新特性）

目錄

一 .抽象類

1. 介紹

1.1基本用法

1.2 抽象類的匿名子類

2. 注意事項

二. 接口

1.介紹

1.1 基本用法

1.2接口和抽象類之間的對比

1.3JDK8接口新特性

2. Comparable接口

2.1 用法

2.2 自定義實現Comparable的類進行比較

三. 內部類

1. 介紹

2.局部內部類

2.1 基本用法

2.2 如何使用局部內部類：

2.3 局部內部類的特點

3.匿名內部類

3.1 基本用法

3.2匿名內部類的特點

4.成員內部類

4.1 成員內部類作爲類的成員的角色：

4.2 成員內部類作爲類的角色：

微服務實踐之使用 Visual Studio 2022 調試Dapr 應用程序

一篇文章快速搞懂Java中的字符串與包裝類

快速瞭解Biglnteger 和 BigDecimal 類

一篇文章快速瞭解Java中的抽象類，接口和內部類（含JDK8接口新特性）

編寫程序，讀取在1到 100 之間的整數，然後計算每個數出現的次數。假定輸入是以 0 結束的。

遊戲：九個正面和背面

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

linux以太網驅動總結