接口、抽象、继承定义和区别

接口（Interface）、抽象类（Abstract Class）和继承（Inheritance）是Java面向对象编程中的重要概念。

接口

是一种抽象的类，它定义了一组方法的规范，但没有具体的实现。接口通过关键字interface来定义，其中可以包含常量和抽象方法。其他类可以通过实现（implements）接口来遵循接口定义的规范，并提供具体的方法实现。一个类可以实现多个接口。

下面是一个接口的示例：

interface Shape {
    double calculateArea();
    double calculatePerimeter();
}

class Circle implements Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;
    }

    @Override
    public double calculatePerimeter() {
        return 2 * Math.PI * radius;
    }
}

在上述代码中，Shape接口定义了两个抽象方法calculateArea和calculatePerimeter。Circle类实现了Shape接口，并提供了具体的方法实现。

通过实现接口，Circle类必须提供这两个方法的具体实现。

抽象

类是一种不能被实例化的类，它可以包含抽象方法和具体方法。抽象方法是没有实现的方法，需要在子类中进行具体实现。抽象类通过关键字abstract来定义。其他类可以继承抽象类，并实现其中的抽象方法。

下面是一个抽象类的示例：

abstract class Animal {
    protected String name;

    public Animal(String name) {
        this.name = name;
    }

    public abstract void makeSound();

    public void sleep() {
        System.out.println(name + " is sleeping");
    }
}

class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }

    @Override
    public void makeSound() {
        System.out.println("Woof!");
    }
}

在上述代码中，Animal类是一个抽象类，它包含一个抽象方法makeSound和一个具体方法sleep。Dog类继承自Animal类，并实现了makeSound方法。

由于Animal类是抽象的，不能直接实例化，但可以通过子类Dog进行实例化。

继承

是面向对象编程中实现类之间代码重用的机制。通过继承，一个类（称为子类或派生类）可以从另一个类（称为父类或基类）继承属性和方法，并且可以在子类中添加额外的属性和方法。子类可以通过关键字extends来继承父类。

下面是一个继承的示例：

class Vehicle {
    protected String brand;

    public Vehicle(String brand) {
        this.brand = brand;
    }

    public void start() {
        System.out.println("Starting the " + brand);
    }
}

class Car extends Vehicle {
    private int numWheels;

    public Car(String brand, int numWheels) {
        super(brand);
        this.numWheels = numWheels;
    }

    public void drive() {
        System.out.println("Driving the " + brand);
    }
}

在上述代码中，Vehicle类是一个父类，Car类继承自Vehicle类。Car类添加了一个额外的属性numWheels和一个方法drive。

通过继承，Car类可以使用Vehicle类中定义的属性和方法，并且可以扩展自己的功能。

区别

定义和用途：
- 接口：接口是一组方法规范的定义，它没有具体的实现，并且用于实现类遵循接口定义的行为规范。
- 抽象类：抽象类是一个类，可以包含抽象方法和具体方法。抽象类用于作为其他类的基类，提供通用的属性和方法实现，并定义一些必须由子类实现的抽象方法。
- 继承：继承是一种类之间的关系，它允许子类继承父类的属性和方法，并且可以添加自己的属性和方法。
实例化：
- 接口：接口不能直接实例化，它只能通过实现接口的类来创建对象。
- 抽象类：抽象类不能直接实例化，它只能作为父类被其他类继承，并由子类实例化。
- 继承：子类可以实例化，并继承父类的属性和方法。
实现：
- 接口：一个类可以实现多个接口，通过implements关键字实现接口，并提供接口中定义的方法的具体实现。
- 抽象类：一个类只能继承一个抽象类，通过extends关键字继承抽象类，并实现抽象类中的抽象方法。
- 继承：子类通过extends关键字继承父类，并继承父类中的属性和方法。
方法实现：
- 接口：接口中的方法都是抽象的，没有具体的实现。实现接口的类必须提供方法的具体实现。
- 抽象类：抽象类中可以包含抽象方法和具体方法。抽象方法没有具体实现，由子类提供实现；具体方法有具体的实现，子类可以直接继承使用。
- 继承：子类可以继承父类的方法，并根据需要重写或覆盖父类的方法。
构造函数：
- 接口：接口不能有构造函数。
- 抽象类：抽象类可以有构造函数，并且在子类实例化时会调用父类的构造函数。
- 继承：子类可以调用父类的构造函数，并根据需要添加自己的构造函数。
多重继承：
- 接口：一个类可以实现多个接口，从而达到多重继承的效果。
- 抽象类：Java中不支持多重继承，一个类只能继承一个抽象类。