JAVA抽象类和接口

抽象类

使用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）是一系列方法的声明，是抽象方法的集合。一个接口只有方法的特征，没有方法的实现。
面向接口编程就是只关心实现类有何能力，不关心实现细节；面向接口的约定，不考虑接口的具体实现。

1. 接口是一种功能，是一种能力。一个类可以实现一个接口，使用关键字implements，实现一个接口就必须实现接口里声明的方法。如果说继承是一种is a的关系，那么接口就是一种has a的关系，实现一个接口就是拥有某种能力。

2. 接口是一种标识，是一种约束。一个接口可以只有一个名字，接口里面什么也没有，方法的声明也没有，这种接口叫做标识接口，作用是标识一种身份。如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中的多继承。

抽象类和接口的区别

相同点：

1. 都代表了系统的抽象层，都很抽象
2. 都不能被实例化
3. 都能包含抽象方法

不同点：

1. 抽象类中可以为部分方法提供默认实现，接口中只包含抽象方法，没有方法的实现。
2. 一个类只有一个直接父类，但一个类可以实现多个接口。
3. 已经存在的继承树，可以方便的抽取接口，担抽取抽象类不容易。