JAVA基础学习——抽象类与接口

抽象类

1. 抽象类的定义：

   • 抽象类用 abstract 关键字来声明，例如：abstract class Animal { ... }。
   • 抽象类可以包含抽象方法（没有实现体），也可以包含具体方法（有实现体）。
   • 抽象类可以有构造方法，用于子类的初始化。

2. 抽象方法：

   • 抽象类中可以包含抽象方法，抽象方法用 abstract 关键字声明，并且不包含方法体。例如：abstract void makeSound();。
   • 子类继承抽象类时必须实现（覆盖）所有父类的抽象方法，否则子类也必须声明为抽象类。

3. 无法实例化：

   • 抽象类不能直接实例化，也就是不能使用 new 关键字创建抽象类的对象。只能通过创建其具体子类的对象来使用。

4. 用途：

   • 抽象类通常用于建模具有通用特征和行为的类，但不能完全描述对象的特性的情况。它们提供了一种模板或契约，要求子类提供必要的实现。
   • 抽象类常常用于构建类层次结构，作为其他具体子类的基类，以确保子类都实现了抽象方法。

5. 继承：

   • 子类继承抽象类时，必须实现抽象类中的所有抽象方法。如果子类未实现全部抽象方法，那么子类也必须声明为抽象类。
   • 子类可以选择性地覆盖具体方法，但对于抽象方法，必须提供具体实现。

下面是一个简单的示例，展示了抽象类的用法：

abstract class Shape{
   protected double area;

//抽象方法，子类必须实现
   public abstract void caculateArea();

//具体方法，可以选择性覆盖
   public void displayArea(){
      System.out.println("Area:"+area);
   }
}
class Circle extends Shape{
    private double radius;

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

    // 实现抽象方法
    public void calculateArea() {
        area = Math.PI * radius * radius;
    }
}

class Rectangle extends Shape {
    private double length;
    private double width;
//构造器
    public Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }

    // 实现抽象方法
    public void calculateArea() {
        area = length * width;
    }
}

public class Main {
    public static void main(String[] args) {
        Circle circle = new Circle(5);
        circle.calculateArea();
        circle.displayArea();

        Rectangle rectangle = new Rectangle(4, 6);
        rectangle.calculateArea();
        rectangle.displayArea();
    }
}

在这个示例中，Shape 是一个抽象类，它包含一个抽象方法 calculateArea() 和一个具体方法 displayArea()。Circle 和 Rectangle 是 Shape 的具体子类，它们分别实现了 calculateArea() 方法来计算自己的面积。通过使用抽象类，我们可以定义通用的形状类，并确保每个具体子类都提供了必要的方法实现。

接口

在Java中，接口（Interface）是一种用来描述类应该具有哪些方法和功能的规范。接口定义了一组方法的声明，但没有提供方法的具体实现。其他类可以实现（implement）这个接口，并提供接口中定义的方法的具体实现。接口在Java中是一种重要的机制，用于实现多态性和代码的模块化

1.声明接口： 使用interface关键字来声明一个接口。接口的声明类似于类的声明，但使用interface关键字代替class关键字。接口中可以声明方法、常量和默认方法（从Java 8开始）。

public interface MyInterface {
    void method1();  // 抽象方法声明

    int CONSTANT = 100;  // 常量声明

    default void method2() {
        // 默认方法（从Java 8开始）
    }

2.实现接口： 一个类可以实现一个或多个接口。通过使用implements关键字，类可以声明它将实现哪些接口。实现接口要求类提供接口中声明的所有方法的具体实现。

public class MyClass implements MyInterface {
    //重写覆盖
    public void method1() {
        // 实现接口的抽象方法
    }
}

3.接口继承： 一个接口可以继承（extends）另一个接口，这样新接口将包含父接口中声明的所有方法。使用关键字extends来指定接口的继承关系

public interface MyExtendedInterface extends MyInterface {
    void method3();  // 在父接口的基础上增加新方法
}

4.多态性： 通过接口，可以实现多态性。即使是不同的类，只要它们实现了相同的接口，可以以相同的方式对它们进行处理。

MyInterface obj1 = new MyClass();
MyInterface obj2 = new AnotherClass();

obj1.method1();  // 调用接口方法
obj2.method1();  // 调用接口方法

上述示例中，MyClass和AnotherClass都实现了MyInterface接口。由于这两个类都实现了相同的接口，因此可以使用相同的接口引用来处理它们的实例。

5.默认方法（从Java 8开始）： 接口中可以包含默认方法，这些方法提供了接口的默认实现。默认方法使用default关键字进行声明，并提供了方法的具体实现。实现接口的类可以选择继承默认方法的实现或者重新实现该方法

public interface MyInterface {
    default void method2() {
        // 默认方法的实现
    }
}

当继承多个接口并且这些接口具有相同的默认方法时，实现类必须显式地提供对默认方法的实现或通过调用父类的默认方法。

public class MyClass implements MyInterface1, MyInterface2 {
    @Override
    public void method2() {
        // 提供对默认方法的实现
    }
}

附：实现obj1接口的完整代码示例

首先，创建一个接口MyInterface

// MyClass.java
public class MyClass implements MyInterface {
    @Override
    public void myMethod() {
        System.out.println("This is myMethod() implementation in MyClass");
    }
}

接着，创建一个实现该接口的类MyClass：

// MyClass.java
public class MyClass implements MyInterface {
    @Override
    public void myMethod() {
        System.out.println("This is myMethod() implementation in MyClass");
    }
}

最后，创建一个包含主方法的类，用于演示如何使用obj1接口变量：

// Main.java
public class Main {
    public static void main(String[] args) {
        // 声明一个接口类型的变量
        MyInterface obj1;

        // 实例化一个实现了该接口的类
        obj1 = new MyClass();

        // 调用接口方法
        obj1.myMethod();
    }
}