abstract类 ，密封类接口（interface）

abstract类：
包含抽象方法的类叫抽象类。
抽象方法由abstract所修饰，并且类也需要abstract所修饰。
抽象方法在抽象类的内部不予以实现。
当一个类继承了抽象类，而这个类则需要实现抽象类的方法，不能由private所修饰，（因为派生类要继承所以不能定义为私有的），如果不加访问限定修饰符，将默认为public。
注意：
1.抽象类当中可以有非抽象方法。
2.抽象类不能创建实例对象，（不能new抽象类的对象）。
抽象类：

abstract class Animal{
  public abstract void miaomiao();//抽象方法在抽象类的内部不予以实现
        public void fun1(){
            System.out.println("abstract Animal fun1()");
        }
    }
class cat extends Animal{
    public cat(){
        System.out.println("cat() intit");
    }
    public void miaomiao(){//派生类继承了抽象类之后需要实现抽象类里面的额方法。
         System.out.println("cat:miaomiao");
     }
}

public class eh{
    public static void main(String[] args) {
       cat cat1 = new cat();
        cat1.miaomiao();
    }
}

抽象类的派生类：
1.如果是普同类必须实现抽象类的方法。
2.如果派生类是抽象类，那么派生类可以不实现基类的抽象方法。
面试：抽象类和普通类的额区别？
1.抽象类不能实例化，不能new。
2.抽象方法必须是由public protected 或者默认。
3.抽象方法必须由abstract所修饰。
4.抽象方法不能再抽象类中实现。
二.密封类
当一个类被final所修饰的时候，我们就叫这个类为密封类。
注意：
1.密封类的方法不能被重写。
2.密封类不能作为基类。
3.就算派生类被final所修饰也不可以。

 final class Teacher{
     private String name;
     private int age;
     public Teacher(){
         System.out.println("Teacher(),init");
    }
    public final void fun(){//密封方法不能被重写。
         System.out.println("Teacher(),int");
    }
   /* public void fun(){//不能重写密封方法
         System.out.println("Teacher(),int ");
    }*/
}
/*final class Student extends Teacher{
     //密封类不能作为基类，并且就算派生类被final所修饰也不能完成继承。
}*/
class mf{
    public static void main(String[] args) {
        Teacher teacher = new Teacher();
        teacher.fun();
    }
}

三.接口：
由interface定义，
接口的属性:默认为public Static/final …
接口的方法：默认为：public abstract…
接口与抽象类的区别：
1.接口类的方法，必须不被实现，而接口内的方法有的部分非抽象类方法可以被实现。
2.抽象类只能被继承一次，而接口可以实现一个或继承多个。
在java里继承是单继承，而接口可以多个。
(接口内的方法不能被实现) ，例如：

interface dog{
    public static int age = 100;
    public abstract void fun();//接口内的方法不能被实现。
}
interface monkey{
    public static int age = 25;
    public abstract void fun1();//接口内的方法不能被实现。
}
interface animal extends dog,monkey{
    public void fun3();//接口内的方法不能被实现。
}

class jiekou{
    public static void main(String[] args) {
    }
}
`
被继承的接口叫基接口。
接口的成员包括从基接口继承的成员和由接口本身声明的成员，故实现该接口的类必须实现接口本身声明的成员以及该接口从基接口继承的成员。

```java
interface dog{
    public static int age = 100;
    public abstract void fun();
}
interface monkey{
    public static int age = 25;
    public abstract void fun1();
}
class animal{
}
class A extends animal implements dog,monkey{
    @Override
    public void fun() {
    }
    @Override
    public void fun1() {
    }
}
class jiekou{
    public static void main(String[] args) {
        A a = new A();
        a.fun();
        a.fun1();
    }
}

三大接口：
1.Comparable接口
在实现comparable接口时必须实现其自己内部特有的comparaTo 的方法。

class Tv implements Comparable<Tv>{
    private String name;
    private int date;
    public Tv(String name,int data){
        this.date = data;
        this.name =name;
    }

    public String getName() {
        return name;
    }

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

    public int getDate() {
        return date;
    }

    public void setDate(int date) {
        this.date = date;
    }

    @Override
    public String toString() {
        return "Tv{" +
                "name='" + name + '\'' +
                ", date=" + date +
                '}';
    }
//compareTo的方法作用在类的内部，属于类内部的方法。
    @Override
    public int compareTo(Tv o) {//使用comparable接口时必须实现compareTo方法。
        //return name.compareTo(o.name);
        return date - o.date;
    }
}
class comparable{
    public static void main(String[] args) {
        Tv[] tv = new Tv[3];
        tv[0] = new Tv("华为",2017);
        tv[1] = new Tv("小米",2015);
        tv[2] = new Tv("创维",2013);
        Arrays.sort(tv);
        System.out.println(Arrays.toString(tv));
    }
}

2.Comparator接口
在实现comparator接口时在类外要实现其类外特有的方法：int compare(T o1, T o2);

class Tv {
    private String name;
    private int date;
    public Tv(String name,int data){
        this.date = data;
        this.name =name;
    }

    public String getName() {
        return name;
    }

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

    public int getDate() {
        return date;
    }

    public void setDate(int date) {
        this.date = date;
    }

    @Override
    public String toString() {
        return "Tv{" +
                "name='" + name + '\'' +
                ", date=" + date +
                '}';
    }

class comparator{
    public static void main(String[] args) {
        Tv[] tv = new Tv[3];
        tv[0] = new Tv("海星",2017);
        tv[1] = new Tv("小米",1995);
        tv[2] = new Tv("创维",2013);
        Arrays.sort(tv, new Comparator<Tv>() {
            @Override
            public int compare(Tv o1, Tv o2) {//在外部实现compare的方法
                //return o1.getName().compareTo(o2.getName());
                return o1.getDate() - o2.getDate();
            }
        });

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

    }
}

3.cloneable接口。
object类的clone（）方法是一个本地方法，native的方法的效率一般来说都是远高于java中非native方法，
实现cloneable接口的三部曲：
clone三部曲。
1 声明实现Cloneable接口。
2 调用super.clone拿到一个对象，如果父类的clone实现没有问题的话，在该对象的内存存储中，所有父类定义的field都已经clone好了，该类中的primitive和不可变类型引用也克隆好了，可变类型引用都是浅copy。
3 把浅copy的引用指向原型对象新的克隆体。

class Age{
    int age = 20;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
class Student implements Cloneable{
    private String sex;
    Age  a ;
    public Student(String sex){
        this.sex = sex;
        this.a = new Age();
    }
如果在没有实现cloneable接口的实例上调用object的clone方法，则会导致抛CloneNotSupportedException
    @Override//重写object的方法
    protected Object clone() throws CloneNotSupportedException {
        Student student = (Student)super.clone();
         Student1.a = (Age)this.a.clone();
        return student;
    }
}
public class lxt {
    public static void main(String[] args) throws CloneNotSupportedException  {
        Student student = new Student("男");
        Student student1 = (Student)student.clone();
        System.out.println(student.a.age);
        System.out.println(student1.a.age);
        student.a.age = 30;
        System.out.println(student.a.age);
        System.out.println(student1.a.age);
    }
}

注意一点：在实现cloneable接口时，需要重写object类里的clone方法。
面试题：
如下代码，解释cloneable的空接口有什么用？
public interface Cloneable {
}
答：它是标记当前类可以进行clone，如果不实现这个接口，则jvm不能识别。