接口和抽象类的区别

接口和抽象类的区别(通俗易懂)

相信有很多的小伙伴会有这样的疑问？？？？

接口1.8以后的新特性：

	全局常量：public static final 数据类型 常量名 = 值

	抽象方法：public abstract 返回值类型 方法名()

	静态方法：public static 返回值类型 方法名(){方法体}

	默认方法（默认方法不用被重写）：public default 返回值类型 方法名(){方法体}

抽象类：

概念：用abstract修饰的，不能直接实例化的类

特点：

​ 1、当一个普通类去继承抽象类时，必须重写其所有抽象方法，除非自身生命为抽象类

​ 2、抽象类就是一个模板，其存在的意义就是根据其模板创建和修改新的类

​ 3、有抽象方法的类一定是抽象类或接口

​ 4、抽象类中可以没有抽象方法，但是抽象方法必须位于抽象类中

不能与abstract并列使用的三个修饰符

​ 原因：这三种方法不能被重写，而抽象方法必须被重写

​ 1、static

​ 2、final

​ 3、private

两者的区别（举例）

我举个例子


现在又鸡类和猫类，他们共同的属性：编号，年龄，姓名，腿数，他们共同的行为：吃饭（但是猫吃鱼、鸡吃小米）。另外，鸡还可以下蛋，猫可以捉老鼠

这里就需要一个抽象类（鸡类和猫类都同属于动物，动物这个叫法有点抽象），把它们公共的属性方法都写进去

public abstract class Animal {
    //共同的属性：编号、年龄、姓名、腿数
    private int id;
    private int age;
    private String name;
    private int legs;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getLegs() {
        return legs;
    }

    public void setLegs(int legs) {
        this.legs = legs;
    }

    public Animal(int id, int age, String name, int legs) {
        this.id = id;
        this.age = age;
        this.name = name;
        this.legs = legs;
    }

    @Override
    public String toString() {
        return "Animal{" +
                "id=" + id +
                ", age=" + age +
                ", name='" + name + '\'' +
                ", legs=" + legs +
                '}';
    }
    //他们共同的行为：吃饭
    public abstract void eat();
    
}

创建一个猫类继承这个抽象类

public class Cat extends Animal {

    public Cat(int id, int age, String name, int legs) {
        super(id, age, name, legs);
    }

    @Override
    public void eat() {
        System.out.println("大黑猫："+super.getName()+"正在吃鱼……");
    }
}

然后猫可以抓老鼠，我们可以定义一个接口，因为所有猫类都可以抓老鼠（鸡可不会抓老鼠）

创建接口还有一个用处（开发的六字真言：高内聚，低耦合），还有很高的拓展性

public interface Catchs {
    public abstract void catchs();
}

最终的代码就是

public class Cat extends Animal implements Catchs{

    public Cat(int id, int age, String name, int legs) {
        super(id, age, name, legs);
    }

    @Override
    public void eat() {
        System.out.println("大黑猫："+super.getName()+"正在吃鱼……");
    }

    @Override
    public void catchs() {
        System.out.println("大黑猫："+super.getName()+"抓老鼠……");
    }
}

鸡吃米那个和这个一样，我就不一一列举出来了

最后总结（仅供参考）

抽象类里面都是公共的属性，你不能把猫捉老鼠的，鸡吃米的都写进去，这样就体现不了抽象类的作用了，而且还会代码冗余，因为老鼠并没有吃米这个功能，但是你继承了你就需要实现。

接口是这个类独有的方法，谁有抓的功能，谁去实现，这样就避免了代码冗余、提高代码拓展性。

接口是接口，抽象类是抽象类，大家不要混淆。