抽象类，密封类和接口

一.抽象类：

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.面试题：

抽象类和普通类的普别？

抽象类不能被实力化
抽象方法必须是public或者protected，或者不写
抽象类被，abstract所修饰
抽象方法不能在抽象类当中实现。

二.密封类：

当一个类，被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.该类不能作用于基类；（即不能派生子类）

就算派生类被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方法。

面试问题：

空接口，标记接口，请问这个空接口的设计有什么作用？

  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));
    }