一、抽象類：
我們把一類事物抽象出來，類中只宣告方法，不實現，這就是抽象類存在的意義；

抽象類： 含有抽象方法的類，被abstract 關鍵字修飾；
抽象方法：只有方法宣告沒有方法實體，被abstract關鍵字修飾；

注意要點：
1、抽象類沒有例項物件，只能通過別的類繼承實現抽象方法；
2、抽象類可以含有普通方法，但是隻要包含一個抽象方法，此類就是抽象類；
3、抽象方法需要通過繼承來實現，所以抽象方法不能被private關鍵字所修飾；
4、繼承了抽象類的類必須實現抽象類裡面提供的所有抽象方法，不然這個子類依然是一個抽象類，需要被abstract所修飾；
5、一個子類只能繼承一個抽象類；

abstract class testAbstract {   //   定義了一個抽象類；
    public abstract void bark();   //   聲明瞭一個抽象方法；
}

class Dog extends testAbstract {   //  子類繼承了這個抽象類；就要實現抽象類的所有方法；
    @Override
    public void bark() {				//    實現了抽象類中的抽象方法，不然會報錯；如果不實現這個抽象方法，這個類依然是抽象類，需要abstract修飾
        System.out.println("汪汪汪");
    }
}
 

二、最終類（密封類）
1：被final關鍵字修飾；
2：表示不能被繼承，防止有意的派生；

final class plan{
	void fly() {
	System.out.println("fly fly fly");
	}
}

三、介面
對介面的理解：介面就是將某個功能抽象出來，如果某個類需要，呼叫介面，實現介面中的方法；
interface 關鍵字： 用於定義介面，
implements 關鍵字:實現介面；
1、介面中只有方法宣告，沒有方法實現；
2、介面中定義的變數都預設為public static final;
3、介面中的方法型別預設abstract型別；
4、介面也可以向上轉型，相當於多型；
5、介面可以繼承，而且也可以多繼承，而且不用實現父類介面的方法；
6、類實現多個介面，必須重寫介面中所有的方法；
7、介面的出現就是為了解決抽象類只能被單繼承的短板；

interface InterfaceFun1 {			//  定義了一個介面
	void fun1(); //   只有方法的宣告，沒有實現；
}
class gun  implements {		//  此類呼叫了介面，就必須實現接口裡面的方法； 
	 public void fun1(){
	 	Syste.out.println("槍可以用來射擊！");
	 }
}

練習： 一個門有開和關兩個行為，並且有的門有警報功能，現在使用所學知識實現這個類；
1、所有的門都有開和關這兩個行為，但是不一定都可以報警；
2、以此可以設計一個門的抽象類，定義一個開門行為和關門行為；
3、單獨設計一個報警的介面，定義一個報警的方法；

interface InterfaceAlarm {    //   報警介面
    void alarm();    //   方法宣告
}

abstract class doorFun {       //   抽象類
    abstract void open();		

    abstract void close();
}

class door extends doorFun implements InterfaceAlarm {  //   繼承了抽象類並且呼叫了介面

    void open() {
        System.out.println("開門");
    }

    void close() {
        System.out.println("關門");
    }

     public void alarm() {
        System.out.println("具有報警功能！！");
    }
}

標記介面：
1 Cloneable ： 此介面是個空介面，目的是為了標記當前類可以實現克隆（在類中得自己重寫object的clone方法，不然，jvm 不會識別）

 *   @Modified By:  此類是為了測試三個標記介面，關於介面的內容在testDemo_oop3_abstract類中；
 *   第一個標記介面： Cloneable；
 *   面試問題：
     Cloneable 介面是空的嗎？  設計這個介面的目的是什麼？
     標記介面：

     Cloneable ： 空的，目的是為了標記當前類可以克隆（實現：重寫object的clone方法），如果不實現jvm不能識別
 *
 */
class car implements Cloneable {   //  呼叫了cloneable介面，必須自己在類中重現clone方法
    int prise = 10;
    protected Object clone() throws CloneNotSupportedException {   //   重寫object的clone方法,並丟擲異常
        return super.clone();
    }
}
class people implements Cloneable {         //  呼叫了cloneable介面，必須自己在類中重現clone方法
    private String name;
    car jeep;
    public people(String name) {
        this.name = name;
        jeep = new car();
    }
    protected Object clone() throws CloneNotSupportedException {     //   重寫object的clone方法,並丟擲異常
        people businessman = (people) super.clone();    //  將 object型別返回值強轉成people型別
        businessman.jeep = (car) this.jeep.clone();   //  將 object型別返回值強轉成car型別
        return businessman;
    }
}
public class testDemo_oop3_interface  {
    public static void main(String[] args) throws CloneNotSupportedException {
        people man = new people("mayun");// 建立物件
      people superman= (people) man.clone();  //   將man的物件地址賦值給super，
        System.out.println(man.jeep.prise);   // 輸出man物件中jeep的價格
        System.out.println(superman.jeep.prise);   //  輸出引用物件jeep的價格
        System.out.println("======================");
        man.jeep.prise=263000;          // 將原物件的價格修改
        System.out.println(man.jeep.prise);         
        System.out.println(superman.jeep.prise);

    }
}

2、Comparable

*          Comparable: (用於比較)有一個ComparTo <T O>泛型方法宣告，實現此介面後需要實現此方法
 *           想對引用型別的物件進行排序
 */


import java.util.Arrays;
import java.util.Comparator;

class students implements Comparable<students> {  //  一個泛型新介面
    private int age;
    private String name;
    private int score;

    public students(int age, String name, int score) {
        this.age = age;
        this.name = name;
        this.score = score;
    }

    @Override
    public String toString() {
        return "students{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", score=" + score +
                '}';
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }

    @Override
    public int compareTo(students o) {
        // 以姓名排序
        //return name.compareTo(o.name);
        // 以成績排序：
        return  score-o.score;
    }
}

public class testDemo8_oop3_interface2 {
    public static void main(String[] args) {
        students[] stu = new students[4];
        stu[0] = new students(18, "awhvo", 89);
        stu[1] = new students(24, "bliming", 81);
        stu[2] = new students(28, "cxingling", 74);
        stu[3] = new students(26, "dhuzi", 99);
        Arrays.sort(stu);
        System.out.println(Arrays.deepToString(stu));
        Arrays.sort(stu,new Comparator<students> () {    
            @Override
            public int compare(students o1, students o2) {
                //return o1.getAge()-o2.getAge();
                return o1.getName().compareTo(o2.getName()); //  以姓名排序
            }
        });
        System.out.println(Arrays.deepToString(stu));  //輸出以姓名排序
    }
}