一、抽象類

（一）抽象類：包含抽象方法的類稱為抽象類。

抽象類也要被abstract修飾，抽象類中可以有非抽象方法，抽象類不能建立例項物件。

abstract class Animal {

    public abstract void bark();//抽象方法

    public void fun(){
        System.out.println("abstract Animal.fun()");
    }
}

（二）抽象方法：被abstract所修飾，在抽象類中不予以實現。

當有一個類繼承了當前的抽象類後，需要實現當中的抽象方法。

如果不加訪問修飾限定符，預設為public。

（三）抽象類的派生類：

（1）如果是普通方法，必須實現抽象類當中的抽象方法；

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

abstract class Dog extends Animal {
    public Dog() {
        System.out.println("Dod() init");
    }

    public abstract void bark();

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

class LittleDog extends Dog {
    public void bark() {
        System.out.println("Dog:wangwang");
    }
}
 

（四）問題1：

抽象類和普通類的區別：

（1）抽象類不能被例項化；

（2）抽象方法必須是public或protected，或者不寫；

（3）抽象類被abstract所修飾；

（4）抽象方法不能在抽象類當中實現。

二、密封類

（一）密封類：當一個類被final所修飾的時候，當前類被稱為密封類。

注意：1、該類不能作用於基類；

          2、就算派生類也被final所修飾也不可以。

作用：防止有意的派生。

/*
final class Person {
    private String name;
    private int age;
    public Person() {
       System.out.println("Person init()");
    }

    public void fun1() {
        System.out.println("Person fun1()");
    }

}

//Person不能被繼承
//class Student extends Person {
//
//}
*/
 

（二）密封方法：final

不能被重寫。

/*
class Person {
    private String name;
    private int age;
    public Person() {
        System.out.println("Person init()");
    }

    public final void fun1() {//密封方法
        System.out.println("Person fun1()");
    }

}

class Student extends Person {
    public final void fun1() {
        System.out.println("Person fun1()");
    }
}
*/

三、介面

（一）介面：

1、由interface定義；

2、屬性預設為public static final;

3、方法預設為public abstract；

4、實現介面：implements。

interface A {//定義一個介面
    public static final int AGE = 10;//屬性       預設為public static final
    public abstract void fun();//方法     預設為public abstract方法
    //介面中全部都是抽象方法
//    void fun2() {
//
//    }
}

interface B {//定義一個介面
    int AGE = 111;
    void fun2();
}

注：1、在JAVA裡，繼承只是單繼承

       2、類實現介面必須實現介面中定義的方法

       3、介面支援向上繼承。

（二）Cloneable介面：空介面（標記介面）

注：實現Cloneable介面必須要重寫Object的clone()方法。

public interface Cloneable {
}

問題2、這個空介面的設計有什麼作用？

標記當前類可以進行clone，如果不實現這個介面JVM不能識別。

（三）Comparable介面

public interface Comparable<T> {
    public int compareTo(T o);
}

//Comparable介面

package practise.abstractAndFinal;

import java.util.Arrays;


class Student1 implements Comparable<Student1>{
    private String name;
    private int age;
    private double score;

    public Student1(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 "Student1{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }

    @Override
    public int compareTo(Student1 o) {
//        return age-o.age;
//        return name.compareTo(o.name);//引用型別
        return (int)(score - o.score);
        //[Student1{name='li', age=22, score=77.7}, Student1{name='wang', age=21, score=88.8}, Student1{name='zhang', age=20, score=99.9}
    }
}

/*
public interface Comparable<T> {
    public int compareTo(T o);
}
 */

public class Test7_Comparable {
    public static void main(String[] args) {
        Student1[] students = new Student1[3];//物件陣列
        students[0] = new Student1("zhang",20,99.9);
        students[1] = new Student1("wang",21,88.8);
        students[2] = new Student1("li",22,77.7);
        
        //根據年齡進行排序
        /**
         * 自定義型別進行排序
         * 實現Compareable介面
         * 實現compareTo()方法
         */

        Arrays.sort(students);
        System.out.println(Arrays.toString(students));
    }
}

（四）Comparator介面

package practise.abstractAndFinal;

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

class Student2 {
    private String name;
    private int age;
    private double score;

    public Student2(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 "Student2{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }
}

public class Test8_Comparator {
    public static void main(String[] args) {
        Student2[] students = new Student2[3];//物件陣列
        students[0] = new Student2("zhang",20,99.9);
        students[1] = new Student2("wang",21,88.8);
        students[2] = new Student2("li",22,77.7);

        Arrays.sort(students, new Comparator<Student2>() {
            /**
             *介面不一定不能new
             * Arrays.sort()排序的時候，用來傳參
             */
            @Override
            public int compare(Student2 o1, Student2 o2) {
//                return o1.getAge() - o2.getAge();
                return (int)(o1.getScore() - o2.getScore());
//                return o1.getName().compareTo(o2.getName());
            }
        });

        System.out.println(Arrays.toString(students));

    }
}

問題3、Comparable和Comparator的區別：

（1）Comparable作用在類內；Comparator在類外。

（2）內部方法：Comparable(compareTo);Comparator(compare)。