抽象类
使用abstract关键字修饰的类叫做抽象类
定义抽象类的语法格式: [访问修饰符] abstract class <类名>
普通类可以实例化，抽象类不能实例化，但是可以创建子类实例对象。
使用abstract关键字修饰的方法叫做抽象方法
定义抽象类的语法格式: [访问修饰符] abstract <返回值类型><方法名>([参数列表])
普通方法有方法体，抽象方法没有方法体。
几个要点：
- 抽象方法只能定义在抽象类里。也就是说有抽象方法的类一定是抽象类，抽象类不一定有抽象方法。
- 抽象类可以和普通类一样包含各类型的成员，包括属性和方法。
- 如果子类没有实现父类所有的抽象方法，子类必须被定义为抽象类
- 没有抽象构造方法，也没有抽象静态方法
- 抽象类中可以有非抽象的构造方法，创建子类实例时可能调用，继承树的顶层一般是抽象类
示例：
public abstract class Person{ //定义了抽象类
String name; //在抽象类中可以定义成员变量
private int age;
public abstract void eat(); //在抽象类中可以定义抽象方法，抽象方法没有方法体
public void sleep(){ //在抽象类中也可以定义普通方法
System.out.print("正在睡觉......");
}
}
class Test{
public static void main(String[] args) {
Person p = new Person(); //这种写法是错误的，抽象类不能直接被实例化，只能实例化子类对象
}
}
接口
接口（interface）是一系列方法的声明，是抽象方法的集合。一个接口只有方法的特征，没有方法的实现。
面向接口编程就是只关心实现类有何能力，不关心实现细节；面向接口的约定，不考虑接口的具体实现。
接口是一种功能，是一种能力。一个类可以实现一个接口，使用关键字implements，实现一个接口就必须实现接口里声明的方法。如果说继承是一种
is a的关系，那么接口就是一种has a的关系，实现一个接口就是拥有某种能力。接口是一种标识，是一种约束。一个接口可以只有一个名字，接口里面什么也没有，方法的声明也没有，这种接口叫做标识接口，作用是标识一种身份。如java中的Serializalbe接口，接口里面什么也没有，只实现了这个接口，才能被序列化。
接口和类相似，但他们是不同的概念，类描述对象的属性和方法； 接口声明了一些方法的特征。
public interface MyInterface{ //定义一个接口
public static final COUNT = 100; //定义一个变量，只能是静态常量
public abstract void eat(); //定义一个方法，只能是public的抽象方法
}
//一个类只能继承一个父类，但是可以实现多个接口
class Studnet extends Person implements A,B,C{
}
接口示例：
public interface Lock {//定义一个接口，功能是上锁和开锁
public void lock();
public void unlock();
}
public interface Camera {//定义一个接口，功能是拍照
public void takePhoto();
}
public abstract class Gate {//定义一个抽象类，门
public abstract void open();//定义抽象方法，开门和关门
public abstract void close();
}
//防盗门类，继承门类，实现锁和拍照功能
class ProofGate extends Gate implements Lock,Camera{
//实现抽象类的方法
public void open() {
System.out.println("门开了");
}
public void close() {
System.out.println("门关了");
}
//实现接口中声明的方法
public void lock() {
System.out.println("门锁了");
}
public void unlock() {
System.out.println("门开锁了");
}
public void takePhoto() {
System.out.println("拍一下张来访者照片");
}
}
class Test {
public static void main(String[] args) {
ProofGate pg = new ProofGate();
pg.close();
pg.lock();
pg.takePhoto();
pg.unlock();
pg.open();
}
}
标识接口示例：
public interface Human {//定义一个标识接口，标识人类
}
public interface Animal {//定义一个标识接口，标识动物
}
class Chinese implements Human{//实现标识接口
}
class American implements Human{//实现标识接口
}
class Wolf implements Animal{//实现标识接口
}
class Bear implements Animal{//实现标识接口
}
class Hunt {
void hunt(Object obj){
//用标识判断识别身份，是人类就不能开枪
if(obj instanceof Human){
System.out.println("不能开枪，这是人类");
}else if(obj instanceof Animal){ //是动物就开枪
System.out.println("砰砰砰，开枪......"+obj.getClass().getName()+"被打死了");
}
}
public static void main(String[] args) {
Hunt hunt = new Hunt();
Chinese man1 = new Chinese();
American man2 = new American();
Wolf wolf = new Wolf();
Bear bear = new Bear();
hunt.hunt(man1);
hunt.hunt(man2);
hunt.hunt(bear);
hunt.hunt(wolf);
}
}
几个要点：
- 接口没有构造方法，无法被实例化，接口不是被类继承，而是可以被类实现。
- 接口类型可用来声明一个变量，指向此接口实现的对象，也就是接口可以实例化它的实现类的对象。
- 接口中不能有方法的实现。
- 接口中所有的变量会被隐式的指定为 public static final 变量（并且只能是 public）；接口中的方法会被隐式的指定为 public abstract （只能是 public abstract，其他修饰符都会报错）。
- 实现类必须实现接口的所有方法，否则就必须声明为抽象类。
- 实现类可以实现多个接口，可以理解为JAVA中的多继承。
抽象类和接口的区别
相同点：
- 都代表了系统的抽象层，都很抽象
- 都不能被实例化
- 都能包含抽象方法
不同点：
- 抽象类中可以为部分方法提供默认实现，接口中只包含抽象方法，没有方法的实现。
- 一个类只有一个直接父类，但一个类可以实现多个接口。
- 已经存在的继承树，可以方便的抽取接口，担抽取抽象类不容易。
