一、抽象
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、一个类只能继承一个直接的父类,但可以实现多个接口