java抽象类、密封类，接口

抽象类

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

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

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

class Dog extends Animal{

	public void bark() {
		System.out.println("wangwang");
	}
}
//如果一个抽象类   继承了一个抽象类  那么可以不实现基类的抽象方法
abstract class Cat extends Animal{
	
	abstract  void bark();
	
}
//如果一个类 再次继承了这个抽象类  必须进行实现
class LittleCat extends Cat{
	public void bark() {
		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，成员方法都是public static。抽象类的成员变量和成员方法都不能是private其余不作要求。
• 接口是对行为的抽象而抽象类是对类整体的抽象

//接口A
interface A {
    int age = 10;
    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;
	}
}
/*public interface Cloneable {
*	}
*/
//Cloneable  空接口  标志接口    
//作用：标志位   标记这个类可以进行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接口的类可以和自己比较，依赖compareTo方法实现比较。compareTo方法的返回值是int，有三种情况：
1、比较者大于被比较者，那么返回正整数（compareTo里原本的）
2、比较者等于被比较者，那么返回0
3、比较者小于被比较者，那么返回负整数

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

Comparator（类外部比较器）
Comparator接口里面有一个compare方法，方法有两个参数T o1和T o2，是泛型的表示方式，分别表示待比较的两个对象，方法返回值和Comparable接口一样是int，有三种情况：
1、o1大于o2，返回正整数
2、o1等于o2，返回0
3、o1小于o3，返回负整数