抽象类、密封类，接口

抽象类

抽象类：主要是对类本身进行抽象
* 对于一个父类来说，如果其某个方法在父类之中实现出来没有任何意义，
* 必须根据子类情况来进行不同的实现。那么就可以将当前方法声明为抽象方法，包含
* 抽象方法的类 称为抽象类。
定义一个抽象类：

abstract class Animal{//抽象类  可以有抽象方法  也可以有非抽象方法
    abstract  void cry();//抽象方法 没有方法体 不做具体实现
    public void fun1(){//非抽象方法
        System.out.println("Animal.fun1!!");
    }
}

抽象类的使用：
抽象类的使用原则如下：
（1）抽象方法必须为public或者protected（因为如果为private，则不能被子类继承，子类便无法实现该方法），缺省情况下默认为public；
（2）抽象类不能直接实例化，需要依靠子类采用向上转型的方式处理；
（3）抽象类必须有子类，使用extends继承，一个子类只能继承一个抽象类；
（4）子类（如果不是抽象类）则必须覆写抽象类之中的全部抽象方法（如果子类没有实现父类的抽象方法，则必须将子类也定义为为abstract类。）；

class Dog extends Animal{

    public void cry() {
        System.out.println("wangwang");
    }
}
//如果一个抽象类   继承了一个抽象类  那么可以不实现基类的抽象方法
abstract class Cat extends Animal{

    abstract  void cry();

}
//如果一个类 再次继承了这个抽象类  必须进行实现
class LittleCat extends Cat{
    public void cry() {
        System.out.println("LittleCat miaomiao");
    }
}

密封类

• 密封类和密封方法：类和方法 被final修饰之后，类不能被继承 方法不能被修改
• 密封类的优点：防止有意的派生

class Base{

    public final void fun1(){
        System.out.println("Base.fun1!!");
    }
    public void fun2(){
        System.out.println("Base.fun2!!");
    }
}

接口

接口：主要是对行为进行抽象

• 默认数据成员是public static final
• 默认成员方法是 public abstract
• 接口的实现，可以实现多个接口
• 接口和接口之间也可以继承

接口和抽象类的区别：

• 接口可以被实现多个（继承–解决了java的单继承问题）
• 抽象类可以拥有非抽象方法，接口内都是抽象方法
• 接口的数据成员变量都是public static final
• 接口是对行为的抽象二抽象类是对类整体的抽象

//接口A
interface A {
    public int age = 10;
    public void fun1();
}
//接口B
interface B{
    int b = 100;
    void fun2();
}
//类C实现接口A和B（可以实现多个接口）
class C implements A,B{
    public void fun1(){
        System.out.println("A.fun1");
    }

    public void fun2() {
        System.out.println("b.fun2");

    }
}

接口和接口之间可以继承

//接口的继承
interface Mobike{
    public void scan();
}
interface Ofo{
    public void hand();
}
abstract class Bick{
    public abstract void fun1();
}
class FlyingDove extends Bick implements Mobike,Ofo{
    public void hand() {
        System.out.println("Ofo.hand()");//.表示作用域
    }

    public void scan() {
        System.out.println("Mobike.scan()");

    }

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

Cloneable
Cloneable接口主要是为了类的克隆。

class Money implements Cloneable{
    double money = 10.0;
    }

}
//Cloneable  空接口  标志接口  
//作用：标志位   flg 当前对象进行clone  如果你不实现  JVM无法识别
class Person implements Cloneable{
    public String name;
    Money m;
    public Person(String name){
        this.name = name;
        m = new Money();
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        //Person重写
        Person p = (Person)super.clone();
        p.m = (Money)this.m.clone();//对当前对象内的引用进行克隆
        return p;
    }
}

public class Test16 {  
    public static void main(String[] args) throws CloneNotSupportedException{  
        Person p1 = new Person("caocao");  
        Person p2 =(Person) p1.clone();       
        System.out.println(p1.m.money);  
        System.out.println(p2.m.money);  

        p1.m.money = 1000.0;  

        System.out.println(p1.m.money);  
        System.out.println(p2.m.money);  
    }     
}  

此时只克隆了person对象，并没有克隆Money对象。改变p1.m.money的值p2.m.money也会随之改变。
在Money类里重写clone方法：

class Money implements Cloneable{  
    double money = 10.0;  

    @Override  
    protected Object clone() throws CloneNotSupportedException {  
        // TODO Auto-generated method stub  
        return super.clone();  
    }  

} 

这样改变改变p1.m.money的值p2.m.money就不会改变。
Comparable
Comparable接口主要是用于比较。

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

    public Person2(String name, int age, double score) {
        super();
        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 "Person2 [name=" + name + ", age=" + age + ", "
                + "score=" + score + "]";
    }
        public int compareTo(Person2 o){
        return age - o.age;//按age排序

        //return name.compareTo(o.name);//按name排序
        //return (int)(score-o.score);//将score强转成int型排序
    }

}
    public static void main(String[] args) {

        Person2[] array = new Person2[3];
        array[0] = new Person2("caocao",18,29.0);
        array[1] = new Person2("aiubei",98,19.0);
        array[2] = new Person2("erke",38,99.99);
        Arrays.sort(array);
    System.out.println(Arrays.toString(array));
}