一.抽象類：

1.抽象類介紹

抽象方法的類

abstract 關鍵字；

抽象方法由abstract修飾，類需要由 abstract修飾

抽象方法在抽象類內部不予以實現

抽象方法不能被private修飾，預設為public的

abstract class Animal{
    public abstract void bark();

    public void fun(){
        System.out.println("abstract Animal fun()");
    }
}
 abstract class Dog extends Animal{
    public Dog
 
(){
        System.out.println("Dog:.............");
    }
}
 class LittleDog extends Dog{

     public void bark() {
     System.out.println("Dog:xiao.....");
     }
 }

Animal 被 absrract修飾，所以是抽象類，其中的fun()方法為普通方法，直接實現；

而public abstract void bark();為抽象方法，由abstract修飾，在這個抽象類中不予以實現，Dog繼承了Animal，單被abstract修飾，所以也為抽象類，LittleDog 繼承了 Dog

為普通類，所以要在其中實現它父類的抽象方法；

2.總結

即：  (1).抽象類中可以有非抽象方法

​ (2).抽象類不能建立例項物件；

抽象類的派生類：

1.如果是普通類，必須實現抽象類的抽象方法

2.如果是抽象類，可以不實現基類的抽象方法

3.面試題：

抽象類和普通類的普別？

1. 抽象類不能被實力化
2. 抽象方法必須是public或者protected，或者不寫
3. 抽象類被，abstract所修飾
4. 抽象方法不能在抽象類當中實現。

二.密封類：

當一個類，被final所修飾的時候，成為密封類；

final class Boys1 {
     private String name;
 

     private int age;
     public Boys1() {
         System.out.println("Boys1 init()");
     }
     public  void fun1() {
         System.out.println("Boys1 init().......");
     }
 }

注意的是：

1.該類不能作用於基類； （即不能派生子類）

2. 就算派生類被final修飾，也不可以

作用：防止有意的派生。

密封方法：  密封方法不能被重寫。

三 .介面

1.介面的介紹：

Java中只能單繼承（介面主要解決單繼承的侷限問題）

interface 關鍵字所修飾；

介面中的屬性：預設為：public static final

介面中的方法：預設為：public abstract

interface A{
    public static final  int age=1;
    public abstract void fun();
}

interface A{
     int age=1;
     void fun();
}

上面兩種寫法表示的是一樣的；

注意（介面和抽象類的區別）：

1.介面內的方法，必須不能被實現（都是抽象方法） 而抽象類可以有部分非抽象方法；

2.抽象類只能繼承一次，介面可以被實現或者繼承多個

implements實現介面，A，必須實現方法

interface D extend A,B   不用實現方法

interface A{
    public static final  int age=1;
    public abstract void fun();
}
interface B{
    int age=2;
    void fun2();
}
interface C extends A,B{
    void fun3();
}
class D  implements C{
    public void fun(){
        System.out.println("A.fun().");
    }
    public void fun2(){
        System.out.println("B.fun2().");
    }
    public void fun3(){
        System.out.println("C.fun3().");
    }
}

介面繼承介面時，可以實現多繼承，interface C extends A,B C不用實現A，B中的方法，

class D implements C ，類D實現了介面C,關鍵字 implements，既要實現介面C中的方法，還必須要實現介面A，B中的方法（因為介面C繼承A，B）

2.cloneable 介面：

class Money implements Cloneable{
    double money=1.0;

    protected Object clone() throws CloneNotSupportedException{
        return super.clone();
    }
}
class Man implements Cloneable{
    private String name;
    Money m;
    public Man(String name){
        this.name=name;
        this.m=new Money();
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Man man1=(Man) super.clone();
        man1.m=(Money)this.m.clone();
        return man1;
    }
}

public static void main1(String[] args)throws CloneNotSupportedException{
        Man man1=new Man("001");
        Man man2=(Man) man1.clone();
        System.out.println(man1.m.money);
        System.out.println(man2.m.money);
        man1.m.money=2.0;
        System.out.println(man1.m.money);
        System.out.println(man2.m.money);
    }
/*輸出結果為：
  1.0
  1.0
  2.0
  1.0 
  */

實現Clonable介面，並且需要重寫Object的clone方法。

​ 面試問題：

1. 空介面，標記介面，請問這個空介面的設計有什麼作用？

​

  public interface Cloneable{ 
    
  }     

它是標記這個類可以進行克隆，如果不實現這個介面，JVM不能夠識別。

3.Comparable介面：

class Student implements Comparable<Student>{
    private String name;
    private int age;
    private double score;
    public Student(String name,int age,double score){
        this.name=name;
        this.age=age;
        this.score=score;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    public double getScore() {
        return score;
    }

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

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

    @Override
    public int compareTo(Student o) {
        //return name.compareTo(o.name);
        return (int)(score-o.score);
    }
}
public class Test1031_3 {
    public static void main(String[] args) {
        Student[] students = new Student[3];
        students[0] = new Student("qwer", 22, 98);
        students[1] = new Student("asd", 20, 48);
        students[2] = new Student("zxc", 18, 68);
        Arrays.sort(students);
        System.out.println(Arrays.toString(students));
    }

需要Student implements Comparable 介面，然後在類的內部重寫public int compareTo(Student o)方法。

4.Comparator介面:

class Student {
    private String name;
    private int age;
    private double score;
    public Student(String name,int age,double score){
        this.name=name;
        this.age=age;
        this.score=score;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    public double getScore() {
        return score;
    }

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

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }
}
 public static void main(String[] args) {
        Student[] students = new Student[3];
        students[0] = new Student("qwer", 22, 98);
        students[1] = new Student("asd", 20, 48);
        students[2] = new Student("zxc", 18, 68);

        Arrays.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                //return o1.getAge()-o2.getAge();
                //return (int) (o1.getScore()-o2.getScore());
                return o1.getName().compareTo(o2.getName());
            }
        });
        System.out.println(Arrays.toString(students));
    }