面向對象（四）接口、抽象類、匿名類

密封類：

sealed 被繼承類 permits可以被繼承的類

public  sealed  class  Animal  permits  Dog ,  Cat{
//定義一個 密封類 Animal, 隻允許 Dog, Cat 繼承           

允許某個類的可以被 特定的類繼承 ，子類必須是final或密封類（一般都用final），且 必須定義需要繼承的子類

abstract 修飾（抽象）

抽象類

1.抽象類用 abstract 修飾，此類不能執行個體化

2.抽象類不能建立對象、但必須定義定義構造器，便于子類執行個體化是調用（子類對象執行個體化的過程）

3.抽象類使用前提：繼承性

抽象方法

1.方法為抽象方法，此時該方法不能實作（不能執行個體化），具體實作由子類完成。

2.包含抽象方法的類，一定是一個抽象類。但是，抽象類中可以沒有抽象方法的

3.子類 重寫父類中的 所有抽象方法後，此子類才可以執行個體化（涉及到接口知識點，接口可以看成是特殊的抽象類）

4.若子類沒重寫父類中的所有的抽象方法，則此子類也是一個抽象類， 需要使用abstract修飾。

注意：

1.abstract不能用來修飾:屬性、構造器等結構

2.abstract不能用來修飾私有方法、靜态方法、final方法、final的類

public abstract class TuXing {

    public abstract double zhouchang();

    public  double mianji(){
    return 0;
    }
}           

關鍵字是有沖突的：

abstract與static 或者 final同時使用。

abstract 和 static 同時修飾類（内部類） ——可以。

static 和 final 同時 修飾 類，屬性，方法 ——可以。

剩下的一律不可以同時修飾

abstract class Template{
//計算某段代碼執行所需要花費的時間
public void spendTime(){
long start = System. currentTimeMillis();
this.code();//不确定的部分、易變的部分
long end = System. currentTimeMillis();
System.out.println("花費的時間為: " + (end-start));
}
public abstract void code();
}
class SubTemplate extends Template{
@Override
public void code() {
    for(int i = 2;i <= 1000;i++){
        boolean isFlag = true;
        for(int j = 2;j <= Math. sqrt(i);j++){
            if(i%j==0){
                isFlag = false; 
                break;
            }
        }
        if(isFlag){
            System. out.println(i);
        }
    }
}
}           

匿名内部類

new 類名(參數) implements 接口()

{

// 匿名内部類的類體部分

}

匿名内部類必須 且隻能 繼承一個父類，或實作一個接口。

規則：

匿名内部類不能是抽象類。

匿名内部類不能定義構造器。由于匿名内部類沒有類名，是以無法定義構造器，但匿名内部類可以初始化塊，可以通過初始化塊來完成構造器需要完成的工作。

舉例說明：

先建立一個接口

public interface Product{
 double getPrice();
 double getName();           

定義一個 實體類，實體類 定義一個方法，方法的 參數 為上述的 接口的對象，到時候會傳入一個匿名類對象，這個匿名類實作了上述建立的接口。

public class Anony{

public void test(Product product){

System.out.println("購買了一個"+product.getName()+"，花掉了"+product.getPrice());

測試運作：

pubic class Test{
    public static void main(String[] args){
        Anony anony=new anony();
        // 注意，此處要傳入一個匿名類對象
        anony.test(new Product(){
            @Override
            public double getPrice(){
                    return 2000.0;
                }
            @Override
            public String getName(){
                    return "聯想筆記本";
                }
            }
        );
    }
}           

接口

接口很重要

接口的定義：

一個接口隻有方法的特征沒有方法的實作，是以這些方法可以在不同的地方被不同的類實作，而這些實作類可以具有不同的功能

請牢記：接口中不能定義構造器

接口的概念：

用關鍵字 interface 定義一個接口 用 implements 來實作接口

接口是為了 指定 标準、規則

提高可擴充性

實作低耦合，高内聚

接口與接口之間采用 多繼承

接口與類之間采用 多實作 （多個類實作同一個接口）

接口的特點：

接口是特殊的抽象類

接口定義的 方法 必須是 抽象方法

（抽象方法隻能存在與 抽象類 和 接口中

但抽象類裡允許存在 非抽象方法 接口中必須全部都是抽象方法）

接口中的 屬性 都是 public static final（公開靜态常量）修飾的

接口中沒有構造方法

接口中允許定義 default 成員方法

接口中 允許 定義 私有 成員方法

接口中 允許定義公開/私有 靜态方法

ps：一個類實作這個接口 必須實作這個接口中定義的所有的抽象方法。

lambda表達式

函數式接口

過濾filter

int[] arr = {1,2,3};
int [] ints = Arrays.stream(arr).filter(s -> s%2==0).toArray();
System.out.println(Arrays.toString(ints));           

映射map

//map
        int[] arr = {1, 2, 3};
        int[] arr2 = Arrays.stream(arr).map(s -> s * 3).toArray();
        System.out.println(Arrays.toString(arr2));           

聚合reduce

//reduce 聚合
        int[] arr = {1, 2, 3};
        int arr2 = Arrays.stream(arr).reduce((max,a)->max > a?max:a).getAsInt();
        System.out.println(arr2);