抽象类和接口

抽象类：包含抽象方法的类叫抽象类 抽象方法由abstract修饰，类也需要；
抽象方法：抽象类内部不给予实现， 当有一个类继承了当前类，需要实现；
抽象方法不能被private所修饰 如果不加访问修饰限定符 默认为public
抽象类：包含抽象方法的类。
（1） 抽象方法由abstract修饰，类也需要由abstract修饰；
（2）抽象方法不能被private所修饰，可以被public、protected修饰；如果不加访问修饰限定符，那么默认为public。
（3）抽象类中可以有非抽象方法；
（4）抽象类不能创建实例对象。（new）

abstract  class Fish{
	//抽象类中的抽象方法不予以实现；   当有一个类继承了当前的抽象类后，需要实现。
    public abstract void swim();
    protected abstract void eat();
    //private abstract void fly();//error   抽象方法不能被private所修饰
    public void fun1(){
        System.out.println("abstract Fish fun1()");//抽象类中的非抽象方法，要进行实现
    }
}

抽象类的派生类：
1.如果是普通类，必须实现抽象类的抽象方法
2.如果是抽象类那么可以不实现基类的抽象方法 派生类前加abstract
a.抽象类中可以有非抽象方法b.抽象类不能创建实例对象 不能new

下面我们想象这么一个场景：动物分为好多种，现在拿出来猫和狗，猫会喵喵喵叫，狗会汪汪汪叫。现在我们抽象出来一个Animal类，根据动物的不同发出的叫声不同。

abstract  class Animal {
    private String name;

    public Animal(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

    //普通方法
    public void say(){
        this.getContent();
    }
    //抽象方法
    public abstract void getContent();
}
public class Dog extends Animal {
    public Dog(String name){
        super(name);
    }
    public void getContent(){
        System.out.println(getName()+"汪汪汪");
    }
}
public class Cat extends Animal {
    public Cat(String name){
        super(name);
    }
    public void getContent(){
        System.out.println(getName()+" 喵喵喵");
    }
}
@Test
    public void test(){
        Animal a1 = new Dog("dog");
        Animal a2 = new Cat("cat");
        a1.say();
        a2.say();
    }

面试题：抽象类的普通类的区别：
1.抽象类不能被实例化 new不行
2.抽象方法必须是public protectecd 或不写
3.抽象类被abstract修饰
4.抽象方法不能在抽象类中实现
密封类：当一个类被final所修饰时就叫密封类 作用：防止有意的派生
注意：1.该类不能作用于基类 2.就算派生类被final修饰也不行 密封方法不能被重写

final class Person{
    private String name;
    public String sex;
    private int age;
    public Person(){
        System.out.println("final() init");
    }
}
//class Student extends Person{}//密封类不能被继承 error
// final class Studebt extends Person{}//派生类被final所修饰也不能 error

接口：interface A{ }有属性：默认为public static final 有方法：默认为public abstract
在JAVA中，继承只是单继承 imliementsA,B,实现接口，，A B 必须实现方法 interface D extends A,B{} 可以不实现AB接口的方法
class A extends B imliements C
cloneable：public interface Cloneable{} 实现Cloneable接口，并且需要重写object的clone方法
几个常用的接口：
1、Cloneable接口：
如果要克隆自定义类必须实现Cloneable接口（接口里啥都没有，标记接口），然后重写Object类的克隆方法。
①空接口设计的作用：标记当前类可以进行克隆，如果不实现这个接口，JVM不能够识别。
2、comparable接口：
实现compareTo方法，在类里面比较
3、Comparator接口：
排序的时候可以new接口
面试问题：空接口即标机接口的设计有何作用？标记当前类可以进行clone，如果不实现这个接口，JVM不能识别
Camparable:public int compapreTo(o.name)
面试题：comparable作用在类的内部 comparator作用在类外 int compare（T o1,T o2);
注意：1.接口内方法必须不能被实现，而抽象类可以有部分非抽象方法
2.抽象类只能继承一次，接口可以被继承多个
抽象类是对类整体的抽象 而接口是对行为进行抽象
报警门问题：

abstract class Door {
    public abstract void open();  //开
    public abstract void close();  //关
}

interface Alarm {
    void alarm();  //报警
}

class AlarmDoor extends Door implements Alarm {
    public void open() {
        System.out.println("开门");
    }

    public void close() {
        System.out.println("关门");
    }

    public void alarm() {
        System.out.println("报警");
    }
}

public class TestDemo19 {
    public static void main(String[] args) {
        AlarmDoor door1 = new AlarmDoor();
        door1.open();
        door1.alarm();
        door1.close();
    }
}