JAVA编程基础——（抽象类、密封类和接口）

一、抽象类

（一）抽象类：包含抽象方法的类称为抽象类。

抽象类也要被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)。