抽象类和接口

 抽象类

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

说明:
1.Animal是动物类，每个动物都有叫的方法，但由于Animal不是一个具体的动物，因此其内部 eat() 无法具体实现
2.Dog是狗类，首先狗是动物，因此与Animal是继承关系，其次狗是一种具体的动物，狗叫:汪汪汪，其 eat() 可以实现
3.Cat是猫类，首先猫是动物，因此与Animal是继承关系，其次猫是一种具体的动物，猫叫:喵喵喵，其 eat() 可以实现
4.因此:Animal可以设计为"抽象类”

抽象类的存在可以预防出错。

我们发现父类Animal中的bark方法并没有实际工作，主要的叫声都是通过Animal的各种子类的bark方法来完成的，像这种没有实际工作的方法, 我们可以把它设计成一个 抽象方法(abstractmethod), 包含抽象方法的类我们称为 抽象类(abstract class)

抽象类特性

1. 抽象类是被abstract 修饰的

2. 被abstract修饰的方法称为抽象方法，该方法没有具体实现（方法体）

3. 当一个类中含有抽象方法的时候，该类必须被abstract修饰（抽象类中不一定有抽象方法，但是有抽象方法的类一定是抽象类）

4. 抽象类当中可以有和普通类一样的成员，即方法体

5. 抽象类不能直接实例化对象

6. 抽象类是为了被继承

7. 当一个普通类继承了抽象类之后，这个普通类一定要重写这个抽象类当中所有的抽象方法

8. 当一个抽象类A不想被一个普通类B继承，此时可以把B这个类变成抽象类，那么在当普通类C继承这个抽象类B后，C中要重写B和A中的所有抽象方法。

9. final和abstract是不能同时存在的，抽象方法不能被private和static修饰。

10. 抽象类中可以有构造方法，供子类创建对象时，初始化父类的成员变量

//使用abstract创建抽象animal类
abstract class Animal{
    //创建抽象eat方法，没有方法体
    abstract public void eat();
    //创建普通run方法
    public void run(){
        System.out.println("跑快点");
    }
    //创建普通的属性
    public String name;
}
//创建抽象Animal类的子类Dog，
abstract class Dog extends Animal{
    //创建普通sleep方法
    public void sleep(){
        System.out.println("狗睡觉");
    }
    //构造方法
    public Dog(String name){
        this.name=name;
    }
}
//创建抽象类Dog的子类Art
class Art extends Dog{
    //重写Animal类中的eat方法
    public void eat(){
        System.out.println("狗吃饭");
    }
    //构造方法
    public Art(String name){
        super(name);//调用父类构造方法
        System.out.println(name);
    }
}
public class Test {
    public static void main(String[] args) {
        //Animal animal = new Animal();//抽象类不可以被实例化
        Dog dog = new Art("小黑");
        dog.eat();
        dog.sleep();
    }
}

接口

接口就是公共的行为规范标准，大家在实现时，只要符合规范标准，就可以通用。

在Java中，接口可以看成是：多个类的公共规范，是一种引用数据类型。

接口特性

1. 使用interface 来定义一个接口

2. 接口当中的成员变量默认是 public static final 的，在定义成员变量时可以不写

3. 接口成员变量必须在声明时被赋值。这是因为接口成员变量通常被用作常量（被final修饰），它们的值在编译时就已经确定，并且在程序的整个生命周期内保持不变，即不能被修改。

4. 由于接口变量是静态的（被static修饰），它们属于接口本身，而不是接口的任何实例。因此，它们可以在没有创建接口实例的情况下被访问

5. 接口当中的成员方法默认是 public abstract ，在定义成员方法时可以不写.且这些方法没有具体的实现（方法体），需要由实现接口的类来提供具体实现。

6. 从Java 8开始，接口可以包含默认方法（使用default关键字）和静态方法。且可以有具体的实现（方法体），而实现接口的类可以使用这个默认实现或者提供自己的实现。静态方法则可以在接口中直接被调用，而不需要实现接口的实例。

7. 从Java 9开始，接口还可以包含私有方法（使用private关键字），这些方法只能在接口内部被调用，通常用于辅助接口中的默认方法或静态方法

8. 接口当中不可以有普通方法

9. 接口不能直接通过 new 关键字进行实例化

10. 接口不能直接使用，类和接口之间可以通过关键字 implements 来实现接口

11. 接口也可以发生向上转型 和 动态绑定

12. 一个类可以实现多个接口用逗号“，”分隔，且在该类中每个接口中的抽象方法都要重写，否则该类必须设置为抽象类

13. 当一个类重写接口当中的所有抽象方法之后，所有重写的方法前必须加限定符 public，保持与接口中抽象方法的一致性。

14. 接口与接口之间可以多继承，达到复用的效果，使用 extends 关键字

15. 接口当中不能有构造方法和代码块

16. 接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class

//抽象类
abstract class Animal{
    public String name;
    //构造方法
    public Animal(String name){
        this.name=name;
    }
    abstract public void eat();
}
//接口Run
interface Run{
    int km=10;//被隐式的指定为 public static final，且在声明时赋值
    void running();//被隐式的指定为 public abstract,且没有方法体
    //默认方法
    default void first(){
        System.out.println("第一名");
    }
    //静态方法
    static void last(){
        System.out.println("最后一名");
    }
}
//接口Swim
interface Swim{
    void swimming();
}
//接口Jump
interface Jump{
    void jumpping();
}
//一个接口可以继承多个接口
interface Amphibious extends Run,Swim{

}
//实现接口的方法
//类和类之间是单继承的，但一个类可以实现多个接口用逗号（，）隔开
class Dog extends Animal implements Run,Jump{
    //构造方法
    public Dog(String name){
        super(name);//调用父类Animal构造方法
    }
    //重写父类Animal中的抽象方法
    public void eat(){
        System.out.println(this.name+"吃狗粮");
    }
    //重写run接口当中的抽象方法
    public void running(){
        System.out.println(this.name+"跑得快");
    }
    //重写Jump中的抽象方法
    public void jumpping(){
        System.out.println(this.name+"跳得高");
    }
}
class Frog extends Animal implements Amphibious{
    public Frog(String name){
        super(name);
    }
    //重写父类Animal中的抽象方法
    public void eat(){
        System.out.println(this.name+"吃害虫");
    }
    //重写run接口当中的抽象方法
    public void running(){
        System.out.println(this.name+"跑得快");
    }
    //重写Swim中的抽象方法
    public void swimming(){
        System.out.println(this.name+"游得好");
    }
}
public class Test {
    public static void main(String[] args) {
        //接口中的静态成员，可以直接调用
        System.out.println(Run.km);
        Run.last();
        //类的实例化
        Run run = new Dog("小狗" );//向上引用
        run.running();
        Frog frog = new Frog("青蛙");
        frog.swimming();
    }
}

抽象类和接口的区别

核心区别: 抽象类中可以包含普通方法和普通字段, 这样的普通方法和字段可以被子类直接使用(不必重写), 而接口中不能包含普通方法, 子类必须重写所有的抽象方法

区别	抽象类（abstract）	接口（interface）
结构组成	普通类 + 抽象方法	抽象方法 + 全局变量
权限	各种权限	public
子类使用	使用extends关键字继承抽象类	使用implements关键字实现接口
关系	一个抽象类可以实现若干接口	接口不能继承抽象类，但是接口可以使用extends关键字继承多个父接口
子类限制	一个子类只能继承一个抽象类	一个子类可以实现多个接口