【面向对象】06一文搞懂抽象和接口 类与类之间的关系 抽象类与接口的相同点与不同点(多代码)

一、抽象

1.抽象类与抽象方法

// 抽象类
public abstract class Pet {
    // 抽象方法
	public abstract void toHospital() ;
}

2.抽象方法的特点

• 修饰符：抽象方法必须 abstract 修饰，只有方法签名，不能有方法体
• 抽象类中的方法：抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
• 类和成员：类该有的成员抽象类都可以有，但是不可以抽象构造方法和静态方法
• 子类的要求：子类继承抽象类，必须重写完抽象类的全部抽象方法，否则子类也必须定义成抽象类。
• 构造方法：抽象类中可以有非抽象的构造方法，创建子类的实例时可能调用

// 抽象类
abstract class Shape {
    // 抽象方法，没有方法体
    abstract void draw();
    // 具体方法
    void describe() {
        System.out.println("This is a shape.");
    }
    // 非抽象构造方法
    Shape() {
        System.out.println("A shape is created.");
    }
}

// 子类实现
class Circle extends Shape {
    // 实现抽象方法
    @Override
    void draw() {
        System.out.println("Drawing a circle.");
    }
    // 可以有自己的方法
    void resize() {
        System.out.println("Resizing the circle.");
    }
}

// 使用
public class Main {
    public static void main(String[] args) {
        // 创建 Circle 对象
        Circle circle = new Circle();
        // 调用具体方法
        circle.describe();
        // 调用实现的抽象方法
        circle.draw();
        // 调用子类特有的方法
        circle.resize();
    }
}
/* 控制台输出:
A shape is created.
This is a shape.
Drawing a circle.
Resizing the circle.
*/

抽象类 VS 普通类

抽象类（Abstract Class）：

• 不能实例化（即不能创建对象）。
• 可以包含抽象方法（未实现的方法）和具体方法（已实现的方法）。
• 主要用于作为其他类的基类，定义通用的接口或实现共享功能。

abstract class Animal {
    abstract void makeSound();  // 抽象方法
    void sleep() {
        System.out.println("This animal sleeps.");
    }
}

普通类（Concrete Class）：

• 可以实例化（即可以创建对象）。
• 必须实现所有从抽象类继承的抽象方法。
• 可以包含具体的方法。

class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("Woof!");
    }
}

抽象方法 VS 普通方法

抽象方法（Abstract Method）：

• 只有方法签名，没有方法体。
• 由抽象类声明，并由子类实现。
• 目的是为子类提供统一的接口或行为规范。

abstract class Animal {
    abstract void makeSound();  // 抽象方法
}

普通方法（Concrete Method）：

• 有完整的方法体（实现）。
• 可以在普通类或抽象类中定义。
• 子类可以继承并重写（覆盖）普通方法。

class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("Woof!");
    }

    void fetch() {
        System.out.println("Dog is fetching.");
    }
}

二、接口

1.interface

接口是一种能力（体现在接口的方法上 ），接口是一种约束（有些接口只有名称）。

public interface 接口名 {
	// 成员变量（常量    public static final 必须显式初始化）
	// 成员方法（抽象方法 public abstract）
} 

2.接口特征

• 接口没有构造方法，不可以被实例化；

• 接口是用来被类实现（implements）的，实现接口的类称为实现类；

• 实现类可以实现多个接口，接口之间用 , 隔开；

  修饰符 class 实现类 implements 接口1, 接口2, 接口3 , ... {} 
  

• 实现类（非抽象类）必须实现接口的所有方法。

一个接口不能实现另一个接口，但可以继承多个其他接口。子接口不需要实现父接口的抽象方法，但实现子接口的类必须实现父接口中的所有抽象方法，以及子接口中新增的抽象方法。

// 定义一个基础接口
interface BaseInterface {
    void baseMethod();
}
// 定义一个子接口继承 BaseInterface
interface SubInterface extends BaseInterface {
    void subMethod();
}
// 实现子接口的类
class ConcreteClass implements SubInterface {
    @Override
    public void baseMethod() {
        System.out.println("Implementing baseMethod");
    }
    @Override
    public void subMethod() {
        System.out.println("Implementing subMethod");
    }
}

三、类与类之间的关系

继承是 is a 的关系

public class Animal{
	public void method1(){};
}
public class Dog extends Animal{
}

实现是 is-like-a 的关系

public interface I{
	public void method1();
}
public class A implements I{
	public void method1(){}
}

关联是 has-a 的关系

public class A{
	private B b;
}
public class B{
}

四、抽象类 VS 接口

相同点

1、代表系统的抽象层

2、都不能被实例化

3、都能包含抽象方法（用于描述系统提供的服务，不必提供具体实现）

不同点

1、在抽象类中可以为部分方法提供默认实现，而接口中只能包含抽象方法（抽象类便于复用，接口便于代码维护）

2、一个类只能继承一个直接的父类，但可以实现多个接口