Java抽象类练习题|系统化练习与深度解析

夯实基础 · 深度理解 · 实战进阶

一、理解Java抽象类:从概念到实践

在Java语言体系中,抽象类(abstract class)作为面向对象编程(OOP)三大特性之一——抽象的直接体现,承担着定义通用行为规范与部分实现的双重职责。它既不是完全抽象的接口,也不是具体可实例化的实体类,而是介于两者之间的“半成品”模板,为子类提供统一的抽象契约与可复用的代码骨架。

与普通类不同,抽象类无法被直接实例化,必须通过继承(extend)其子类来完成具体化。这种设计强制开发者在使用前完成必要实现,从而保障系统的一致性与健壮性。例如,当我们定义一个“动物”抽象类时,不能直接创建“动物”对象,但可以创建“猫”“狗”等具体子类实例,因为它们实现了抽象方法(如makeSound())。

在实际开发中,抽象类广泛用于框架设计、模板方法模式、策略模式等场景。Spring Framework中的AbstractApplicationContext、JDK的AbstractList、AbstractMap等均采用抽象类作为基类,通过抽象方法定义扩展点,通过具体方法提供默认行为,极大提升代码复用性与可维护性。

抽象类的核心价值在于:①强制子类实现特定行为;②共享通用逻辑,避免重复代码;③支持多态性,实现运行时绑定;④提供部分实现,降低子类开发成本。这些特性使其成为构建可扩展、可维护系统的关键工具。

二、抽象类三大核心特性深度解析

⚡ 特性一:抽象方法必须由子类实现

抽象方法使用abstract关键字声明,无方法体(仅声明无实现),子类继承抽象类后,必须重写(override)所有抽象方法,否则子类也必须声明为抽象类。

示例:
abstract class Shape {
 abstract double area();
 abstract double perimeter();
}

子类Circle必须实现area()和perimeter(),否则编译报错。

⚙️ 特性二:可包含具体实现与成员变量

抽象类允许定义:
• 实例变量、静态变量
• 构造方法(供子类调用,不能直接实例化)
• 普通方法(含private、final等)
• 静态方法
• 默认方法(Java 8+)

示例:
abstract class Vehicle {
 protected String brand;
 protected int year;
 
 public Vehicle(String brand, int year) {
  this.brand = brand;
  this.year = year;
 }
 
 public void start() {
  System.out.println(brand + " engine started");
 }
}

子类可直接调用start()方法,并通过构造器初始化字段。

↺ 特性三:支持单继承与接口组合

Java中类只支持单继承(一个类只能extends一个父类),但抽象类可同时实现多个接口。这使得抽象类在保留单继承约束的同时,获得接口的多实现能力。

示例:
abstract class AbstractLogger implements Cloneable, Serializable {
 protected String level;
 
 public abstract void log(String msg);
}

子类既可复用Cloneable与Serializable能力,又可扩展log()抽象方法。

三、抽象类语法规范与关键细节

基本语法
构造器与初始化
访问修饰符规则

抽象类定义格式:
abstract class ClassName [extends ParentClass] [implements InterfaceList] {
 // 成员变量
 // 构造器
 // 普通方法
 abstract 返回类型 方法名(参数列表);
 // 抽象方法
}

注意:
• abstract关键字必须放在class之前
• 抽象类中可以没有抽象方法,但含抽象方法的类必须声明为抽象类
• 抽象方法不能为private、final或static(因无法被重写)

抽象类可定义构造器,但不能直接调用,只能通过子类的构造器通过super()调用。这常用于初始化共享字段。

示例:
abstract class Animal {
 protected String name;
 
 public Animal(String name) {
  this.name = name;
 }
}

class Dog extends Animal {
 public Dog(String name) {
  super(name); // 调用父类构造器
 }
}

若子类构造器未显式调用super(),编译器将自动插入对父类无参构造器的调用。若父类无无参构造器(如仅定义了带参构造器),则子类必须显式调用super(...),否则编译失败。

抽象类中各成员的访问修饰符规则:
• public:最常用,子类可自由访问
• protected:仅允许同包及子类访问,适合封装内部逻辑
• private:仅类内可见,子类不可见,但可通过公共方法间接访问
• default(包级私有):仅同包类可访问

特别注意:抽象方法不能为private,否则子类无法重写,违背设计初衷。例如:
abstract class Test {
 abstract void test(); // ✅ 正确
 // abstract private void fail(); // ❌ 编译错误
}

四、抽象类典型使用场景与实战案例

〔场景一〕模板方法模式(Template Method Pattern)

抽象类定义算法骨架,将可变步骤延迟到子类实现。JDK中AbstractList是经典案例:

abstract class AbstractList {
 public final void add(E e) {
  add(size(), e); // 调用抽象方法
 }
 public abstract void add(int index, E element);
}

子类ArrayList只需实现add(int, E),即可复用add(E)逻辑。

〔场景二〕策略框架的基类设计

例如支付系统中,抽象类PaymentStrategy定义统一接口:
abstract class PaymentStrategy {
 protected final double amount;
 protected final String currency;
 
 public PaymentStrategy(double amount, String currency) {
  this.amount = amount;
  this.currency = currency;
 }
 
 public abstract void pay();
 
 public final void validate() {
  if (amount <= 0) throw new IllegalArgumentException("Invalid amount");
 }
}

子类AliPayStrategy与WeChatPayStrategy分别实现pay(),而validate()统一复用。

〔场景三〕事件监听器基类(如Swing)

WindowAdapter是抽象类,实现WindowListener接口,提供空实现,子类仅需重写所需方法:
public abstract class WindowAdapter implements WindowListener {
 public void windowOpened(WindowEvent e) {}
 public void windowClosing(WindowEvent e) {}
 // ...
}

使用:
frame.addWindowListener(new WindowAdapter() {
 @Override
 public void windowClosing(WindowEvent e) {
  System.exit(0);
 }
});

五、常见误区与反模式(附修正方案)

误区一:将所有公共方法设为抽象

错误示例:
abstract class Service {
 public abstract void save();
 public abstract void delete();
 public abstract void update();
 public abstract void findById();
}

问题:子类被迫重复实现大量基础逻辑(如数据库连接、异常处理),违背复用原则。

✅ 修正:
abstract class Service {
 protected DataSource dataSource;
 
 public Service(DataSource ds) { this.dataSource = ds; }
 
 public void save(Object obj) {
  // 公共逻辑:连接→序列化→存储
 }
 
 public abstract void validate(Object obj); // 仅抽象校验逻辑
}

误区二:抽象类中缺少抽象方法

错误示例:
abstract class Config {
 protected String path;
 public Config(String p) { this.path = p; }
 public String load() { return "default"; }
}

问题:该类可被直接实例化(尽管标记为abstract),失去抽象意义。

✅ 修正:若仅需封装逻辑,用普通类即可;若需强制继承,应至少含一个抽象方法,或用private构造器阻止实例化:

abstract class Config {
 private Config() {} // 阻止实例化
 protected String path;
 public static String load(String path) { ... }
}

误区三:过度使用抽象类替代接口

在仅需定义行为契约时(无共享实现),应优先使用接口。例如:
interface Comparable { int compareTo(Object o); }
interface Serializable { }
interface Runnable { void run(); }

若用抽象类实现,会占用唯一继承位,限制子类扩展性。Java 8+的接口默认方法已弥补此缺陷。

六、系统化练习题库(含答案与解析)

基础题(10题)
进阶题(8题)
综合实战(5题)

⑴ 以下代码能否编译通过?
abstract class A {
 abstract void f();
 public void g() {}
}
class B extends A {
 public void f() {}
}

答案:能通过。子类B实现了所有抽象方法f(),且继承了具体方法g()。

⑵ 抽象类中是否可以定义构造器?能否被直接调用?

答案:可以定义构造器,但不能直接调用,只能通过子类构造器的super(...)调用。

⑶ 抽象方法能否为private?为什么?

答案:不能。因private方法无法被子类访问,自然无法重写,违背抽象方法设计初衷。编译器会报错。

⑷ 以下代码输出?
abstract class Base {
 public Base() { System.out.print("B"); }
}
class Derived extends Base {
 public Derived() { System.out.print("D"); }
}
public class Test {
 public static void main(String[] args) {
  new Derived();
 }
}

答案:BD。子类构造器隐式调用父类无参构造器,先执行Base()输出"B",再执行Derived()输出"D"。

⑸ 抽象类能否实现接口?能否继承普通类?

答案:可以实现多个接口;可以继承一个普通类(或另一个抽象类)。

⑹ 抽象类与接口的核心区别是什么?

答案:
• 抽象类可含成员变量、构造器、具体方法;接口(Java 8前)仅含常量与抽象方法
• 类单继承抽象类,多实现接口
• 抽象类体现“is-a”关系;接口体现“can-do”能力

⑺ 以下代码错误?
abstract class X {
 public abstract void f();
 private abstract void g();
}

答案:错误。抽象方法不能为private。

⑻ 抽象类能否用final修饰?为什么?

答案:不能。因final类禁止继承,而抽象类必须被继承才有意义,编译冲突。

⑼ 抽象类中能否有static方法?能否被子类继承?

答案:可以有static方法;可以被子类继承(但不能重写),子类通过ClassName.method()调用。

⑽ 抽象类是否必须包含至少一个抽象方法?

答案:否。抽象类可无抽象方法,但含抽象方法的类必须声明为抽象类。

⑾ 阅读代码,说明输出顺序:
abstract class A {
 { System.out.print("A1"); }
 public A() { System.out.print("A2"); }
}
class B extends A {
 { System.out.print("B1"); }
 public B() { System.out.print("B2"); }
}
new B();

答案:A1A2B1B2。执行顺序:父类实例初始化块→父类构造器→子类实例初始化块→子类构造器。

⑿ 抽象类子类未实现抽象方法,会怎样?

答案:子类必须也声明为抽象类,否则编译报错。

⒀ 以下代码能否编译?
abstract class Test {
 public static void main(String[] args) {
  System.out.println("Hello");
 }
}

答案:能。抽象类可含main方法,可直接运行,但无法实例化对象。

⒁ 抽象类中protected成员在子类中的可见性?

答案:子类可直接访问;同包其他类也可访问;不同包非子类不可访问。

⒂ 抽象类能否实现接口的默认方法?

答案:可以。抽象类实现接口时,可选择实现接口的默认方法,也可保留为抽象方法。

⒃ 以下代码输出?
abstract class Shape {
 protected String type;
 public Shape(String t) { type = t; }
 public abstract double area();
 public String getType() { return type; }
}
class Circle extends Shape {
 private double r;
 public Circle(double r) { super("Circle"); this.r = r; }
 public double area() { return Math.PI * r * r; }
}
Shape s = new Circle(2);
System.out.println(s.getType() + ":" + s.area());

答案:Circle:12.566370614359172。多态调用子类实现的area()。

⒄ 抽象类能否继承另一个抽象类?是否必须实现父类抽象方法?

答案:可以;若不实现,子类也需声明为抽象类。

⒅ 以下代码错误?
abstract class A {
 public void f() { g(); }
 public abstract void g();
}
class B extends A {
 public void g() { System.out.print("B"); }
}
调用new B().f()输出?

答案:B。父类具体方法f()调用抽象方法g(),运行时绑定子类实现。

⒆ 设计抽象类实现“文档打印”系统

需求:
• 定义抽象类Document,含title字段
• 抽象方法print()(各文档类型实现不同打印逻辑)
• 公共方法printHeader()(打印标题,所有文档共享)

参考实现:
abstract class Document {
 protected String title;
 
 public Document(String title) { this.title = title; }
 
 public final void print() {
  printHeader();
  doPrint();
 }
 
 protected void printHeader() {
  System.out.println("=== " + title + " ===");
 }
 
 protected abstract void doPrint();
}

⒇ 实现带缓存的抽象数据访问层

需求:
• 抽象类AbstractRepository实现find方法(带缓存逻辑)
• 抽象方法doLoad(子类实现真实加载逻辑)
• 用Map缓存已加载对象

参考实现:
abstract class AbstractRepository {
 private Map cache = new HashMap<>();
 
 public T find(String id) {
  return cache.computeIfAbsent(id, this::doLoad);
 }
 
 protected abstract T doLoad(String id);
}

⒇⒈ 重构“游戏角色”系统

需求:
• 抽象类Character含name、hp字段
• 抽象方法attack()
• 公共方法heal(int hp)(增加血量)
• 子类Warrior实现attack()为“挥剑”,Healer实现为“施法”

参考实现:
abstract class Character {
 protected String name;
 protected int hp;
 
 public Character(String name, int hp) {
  this.name = name;
  this.hp = hp;
 }
 
 public void heal(int amount) {
  hp += amount;
  System.out.println(name + " healed " + amount + " HP");
 }
 
 public abstract void attack();
}

⒇⒉ 抽象类与单例模式结合

需求:
• 抽象类SingletonBase实现单例逻辑
• 子类ConfigManager继承后自动获得单例能力

参考实现:
abstract class SingletonBase {
 private static final Map, SingletonBase> instances = new HashMap<>();
 
 protected SingletonBase() {
  if (instances.containsKey(getClass())) {
   throw new IllegalStateException("Instance exists");
  }
  instances.put(getClass(), this);
 }
 
 public static T getInstance(Class clazz) {
  return clazz.cast(instances.get(clazz));
 }
}

⒇⒊ 抽象类实现观察者模式基类

需求:
• 抽象类Observable管理观察者列表
• 抽象方法doNotify(子类实现具体通知逻辑)

参考实现:
abstract class Observable {
 private List observers = new ArrayList<>();
 
 public void addObserver(Observer o) { observers.add(o); }
 
 protected void notifyObservers() {
  for (Observer o : observers) doNotify(o);
 }
 
 protected abstract void doNotify(Observer o);
}

七、高频面试题与深度解析

Q1:抽象类与接口的区别?何时选择抽象类?

答案:
• 语法差异:抽象类可含构造器、成员变量、具体方法;接口(Java 8前)仅常量与抽象方法
• 继承限制:类单继承抽象类,多实现接口
• 设计意图:抽象类体现“is-a”关系(如Dog is Animal);接口体现“can-do”能力(如Serializable)
• 选择原则:
 - 需共享代码实现 → 抽象类
 - 仅定义契约 → 接口
 - 需多继承行为 → 接口
 - 需控制构造流程 → 抽象类

Q2:抽象类中私有方法能否被子类重写?

答案:不能。私有方法仅类内可见,子类无法访问,更无法重写。Java 9+允许抽象类中定义private方法用于内部辅助逻辑,但子类不可见。

Q3:抽象类能否被序列化?

答案:可以。只要子类实现Serializable接口,抽象类的字段也会被序列化(需满足字段可序列化条件)。

Q4:抽象类的静态方法能否被子类重写?

答案:不能。静态方法属于类本身,不参与多态。子类可定义同名静态方法(隐藏),但非重写。

Q5:以下代码是否合法?
abstract class A {
 public static abstract void f();
}

答案:非法。抽象方法不能为static,因静态方法无多态性,无法被重写。