字节后端面试题：接口和抽象类的区别？抽象类可以多继承吗？

// 定义接口
interface Shape {
    double calculateArea();
    double calculatePerimeter();
}

public class Main {
    public static void main(String[] args) {
        // 创建一个圆形对象
        Circle circle = new Circle(5.0);

        // 计算并打印圆形的面积和周长
        System.out.println("Circle Area: " + circle.calculateArea());
        System.out.println("Circle Perimeter: " + circle.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;
    }
}

// 定义抽象类
abstract class Animal {
    abstract void makeSound();
    void eat() {
        System.out.println("Animal is eating...");
    }
}

// 定义 Dog 类继承 Animal 抽象类
class Dog extends Animal {
    // 实现抽象方法
    void makeSound() {
        System.out.println("Dog barks...");
    }
}

// 主类
public class Main {
    // 主方法
    public static void main(String[] args) {
        // 创建 Dog 对象
        Dog dog = new Dog();
        dog.makeSound(); // 调用 Dog 类中的 makeSound 方法
        dog.eat(); // 调用 Animal 类中的 eat 方法
    }
}

// 定义接口
interface MyInterface {
    // 接口中的方法只有声明，没有实现
    void method1();
}

// 定义抽象类
abstract class MyAbstractClass {
    // 抽象方法可以有实现
    abstract void method2();

    // 抽象类中的非抽象方法可以有实现
    void method3() {
        System.out.println("This is a method in abstract class.");
    }
}

// 定义实现多个接口的类
class MyClass implements MyInterface {
    // 实现接口中的方法
    public void method1() {
        System.out.println("Method 1 implemented from interface.");
    }
}

// 主类
public class Main {
    public static void main(String[] args) {
        // 创建实现多个接口的类的对象
        MyClass myClass = new MyClass();

        // 调用接口中的方法
        myClass.method1();

        // 实例化抽象类
        MyAbstractClass myAbstractClass = new MyAbstractClass() {
            @Override
            void method2() {
                System.out.println("Method 2 implemented from abstract class.");
            }
        };

        // 调用抽象类中的方法
        myAbstractClass.method2();
        myAbstractClass.method3();
    }
}

// 定义抽象类 Animal
abstract class Animal {
    abstract void makeSound();
}

// 定义抽象类 Color
abstract class Color {
    abstract void showColor();
}

// 定义实现了多个抽象类的子类
class Dog extends Animal {
    void makeSound() {
        System.out.println("Dog barks...");
    }
}

class Red extends Color {
    void showColor() {
        System.out.println("The color is red.");
    }
}

// 主类
public class Main {
    public static void main(String[] args) {
        // 创建 Dog 对象
        Dog dog = new Dog();
        dog.makeSound(); // 调用 Dog 类中的 makeSound 方法

        // 创建 Red 对象
        Red red = new Red();
        red.showColor(); // 调用 Red 类中的 showColor 方法
    }
}

// 定义抽象类 Game
abstract class Game {
    abstract void initialize();
    abstract void startPlay();
    abstract void endPlay();

    // 模板方法
    public final void play() {
        initialize();
        startPlay();
        endPlay();
    }
}

// 具体的游戏类
class Cricket extends Game {
    @Override
    void initialize() {
        System.out.println("Cricket Game Initialized! Start playing.");
    }

    @Override
    void startPlay() {
        System.out.println("Cricket Game Started. Enjoy the game!");
    }

    @Override
    void endPlay() {
        System.out.println("Cricket Game Finished!");
    }
}

class Football extends Game {
    @Override
    void initialize() {
        System.out.println("Football Game Initialized! Start playing.");
    }

    @Override
    void startPlay() {
        System.out.println("Football Game Started. Enjoy the game!");
    }

    @Override
    void endPlay() {
        System.out.println("Football Game Finished!");
    }
}

// 主类
public class Main {
    public static void main(String[] args) {
        Game cricket = new Cricket();
        cricket.play();
        System.out.println();

        Game football = new Football();
        football.play();
    }
}

// 定义抽象类 Framework
abstract class Framework {
    // 框架提供的基础功能
    void basicFunctionality() {
        System.out.println("Framework: Providing basic functionality...");
    }

    // 抽象方法，允许用户根据需要扩展功能
    abstract void extendedFunctionality();
}

// 用户自定义的类，继承框架类，扩展功能
class MyFramework extends Framework {
    // 实现扩展功能
    @Override
    void extendedFunctionality() {
        System.out.println("MyFramework: Adding extended functionality...");
    }
}

// 主类
public class Main {
    public static void main(String[] args) {
        // 创建用户自定义的框架对象
        MyFramework myFramework = new MyFramework();

        // 使用框架提供的基础功能
        myFramework.basicFunctionality();

        // 使用用户扩展的功能
        myFramework.extendedFunctionality();
    }
}

// 定义抽象类 AbstractShape
abstract class AbstractShape {
    // 通用方法：计算面积
    abstract double calculateArea();

    // 通用方法：计算周长
    abstract double calculatePerimeter();

    // 通用字段：形状名称
    String shapeName;

    // 构造方法
    public AbstractShape(String shapeName) {
        this.shapeName = shapeName;
    }

    // 通用方法：展示形状信息
    void displayInfo() {
        System.out.println("Shape: " + shapeName);
        System.out.println("Area: " + calculateArea());
        System.out.println("Perimeter: " + calculatePerimeter());
    }
}

// 具体形状类：圆形
class Circle extends AbstractShape {
    double radius;

    // 构造方法
    public Circle(double radius) {
        super("Circle");
        this.radius = radius;
    }

    // 实现抽象方法：计算面积
    @Override
    double calculateArea() {
        return Math.PI * radius * radius;
    }

    // 实现抽象方法：计算周长
    @Override
    double calculatePerimeter() {
        return 2 * Math.PI * radius;
    }
}

// 具体形状类：矩形
class Rectangle extends AbstractShape {
    double width;
    double height;

    // 构造方法
    public Rectangle(double width, double height) {
        super("Rectangle");
        this.width = width;
        this.height = height;
    }

    // 实现抽象方法：计算面积
    @Override
    double calculateArea() {
        return width * height;
    }

    // 实现抽象方法：计算周长
    @Override
    double calculatePerimeter() {
        return 2 * (width + height);
    }
}

// 主类
public class Main {
    public static void main(String[] args) {
        // 创建圆形对象并展示信息
        Circle circle = new Circle(5);
        circle.displayInfo();
        System.out.println();

        // 创建矩形对象并展示信息
        Rectangle rectangle = new Rectangle(4, 6);
        rectangle.displayInfo();
    }
}