OCP 认证 - 高级 Java 类设计

1. 概述

本文深入探讨 OCP（Oracle Certified Professional）Java 认证考试中“高级 Java 类设计”这一核心目标。这部分内容是 OCA 的进阶，涉及更复杂的语言特性与设计模式，是区分中级与高级开发者的关键。

如果你正在备战 OCP，那么本文总结的“踩坑点”和典型题目将帮你少走弯路。✅

2. OCP Java 认证简介

OCP 认证是 OCA（Oracle Certified Associate）的进阶版本，考试形式依然是选择题，但内容深度和广度明显提升。它覆盖了并发编程、泛型、NIO 等高级主题。

本文聚焦于“高级 Java 类设计”这一考试目标。虽然部分内容与 OCA 有重叠，但 OCP 更侧重于：

✅ 内部类（Inner Classes）的复杂用法
✅ 枚举（enum）的高级特性
✅ Lambda 表达式与函数式接口
✅ 抽象类、final 关键字、接口设计的边界情况

接下来的每一节都对应一个具体的考试目标，结合典型“陷阱题”进行解析。

3. 使用抽象类和方法的代码开发

抽象类（abstract class）是实现代码复用和定义契约的重要手段。子类继承抽象类时，必须实现其所有抽象方法（除非子类也是抽象的）。

考试技巧 3.1：抽象方法的访问修饰符陷阱

⚠️ 重点：抽象方法的访问级别必须允许子类访问。

看下面这段代码：

package animal;
public abstract class Animal {
    
    abstract boolean canFly();
}
    
package horse;
import animal.Animal;

public class Horse extends Animal {
    
    @Override
    boolean canFly() {
        return false;
    }
    
    public static void main(String[] args) {
    
        System.out.println(new Horse().canFly());
    }    
}

哪个选项正确？
A. 输出 false
B. 第10行编译失败
C. 第12行编译失败
D. 以上都不对

分析： canFly() 方法没有显式访问修饰符，默认是 package-private（包私有）。Animal 在 animal 包，Horse 在 horse 包，跨包访问失败。❌

✅ 正确答案：B（第10行，Horse 类继承 Animal 时就无法访问抽象方法，编译直接失败）。

考试技巧 3.2：抽象类/方法的语法错误

⚠️ 核心规则：

抽象方法不能有方法体（大括号 {}）
非抽象类里不能包含抽象方法

来看这个“集错大礼包”：

public abstract class Animal {
  
    protected abstract boolean canFly() {
    }
  
    public abstract void eat() {
        System.out.println("Eat...");
    }
}
  
public class Amphibian extends Animal {
    @Override
    protected boolean canFly() {
        return false;
    }
  
    @Override
    public void eat() {
  
    }
  
    public abstract boolean swim();
}
  
public class Frog extends Amphibian {
}

哪些说法正确？（多选）
A. 第3行编译错误
B. 第6行编译错误
C. 第11行编译错误
D. 第13行编译错误
E. 第22行编译错误

分析：

A✅：canFly() 是抽象方法，却写了 {}，非法。
B✅：eat() 是抽象方法，却写了方法体，非法。
C✅：Amphibian 是普通类（非 abstract），却包含 swim() 这个抽象方法，非法。

D 和 E 没问题，Frog 类可以继承 Amphibian。

✅ 正确答案：A, B, C

考试技巧 3.3：子类未实现抽象方法

⚠️ 重点：非抽象子类必须实现所有继承来的抽象方法。

public abstract class Animal {
  
    protected abstract boolean canFly();
  
    public abstract void eat();
}
 
public abstract class Amphibian extends Animal {
  
    @Override
    public void eat() {
        System.out.println("Eat...");
    }
  
    public abstract boolean swim();
}
  
public class Frog extends Amphibian {
  
    @Override
    protected boolean swim() {
        return false;
    }
  
}

哪些说法正确？（多选）
A. 第8行编译错误
B. 第11行编译错误
C. 第18行编译错误
D. 第21行编译错误
E. 无编译错误

分析：

Frog 是普通类。
它没有实现从 Animal 继承的 canFly() 方法 ❌ → C 正确。
swim() 在父类 Amphibian 中是 public abstract，子类 Frog 中重写为 protected，降低了访问权限 ❌ → D 正确。

Amphibian 是抽象类，不实现 canFly() 合法，所以 A 错。

✅ 正确答案：C, D

考试技巧 3.4：abstract 与 private/final/static 的非法组合

⚠️ 绝对禁止：

abstract 方法不能是 private、final 或 static
abstract 类不能是 final

以下代码都会编译失败：

// 错误：final 和 abstract 互斥
public final abstract class Animal {
}

// 错误：abstract 方法不能是 final
public abstract class Animal {
    public final abstract void eat();
}

// 错误：abstract 方法不能是 private
public abstract class Animal {
    private abstract void eat();
}

记住：abstract 意味着“待实现”，而 final 意味着“不可变”，private 意味着“不可见”，三者与 abstract 的开放性本质冲突。

4. 使用 final 关键字的代码开发

final 关键字用于定义不可变性：

final 变量：值不可变（基本类型）或引用不可变（对象）
final 方法：不可被重写（override）
final 类：不可被继承

考试技巧 4.1：final 方法的重写与 final 变量的修改

⚠️ 重点：final 方法不能被子类重写。

public abstract class Animal {
  
    public final void eat() {
        System.out.println("Eat...");
    }
}
  
public class Horse extends Animal {
  
    public void eat() { // 试图重写 final 方法
        System.out.println("Eat Grass");
    }
  
    public static void main(String[] args) {
        Animal animal = new Horse();
        animal.eat();
    }
}

结果是？
A. Eat...
B. Eat Grass
C. 第3行编译失败
D. 第8行编译失败
E. 第10行编译失败

分析： Horse 类中的 eat() 方法试图重写父类的 final 方法，编译器直接报错。

✅ 正确答案：E（第10行是 main 方法的调用，但错误发生在第8行方法定义时，选项描述有歧义，但 E 指向的是这个错误）。

额外提醒： Lambda 或内部类中引用的局部变量，也必须是 final 或 实际上的 final（effectively final），即值不能被修改。

5. 内部类（Inner Classes）

内部类是 OCP 的重灾区，语法繁琐，容易出错。很多并发、集合题都用内部类包装，干扰判断。

考试技巧 5.1：非静态内部类的实例化方式

⚠️ 唯一方式：必须通过外部类的实例来创建。

public class Animal {

    class EatingHabbits {
    }

    private EatingHabbits eatingHabbits() {
        return new EatingHabbits(); // ✅ 合法，在外部类内部
    }
}

public class Zookeeper {

    public static void main(String[] args) {
        Zookeeper zookeeper = new Zookeeper();
        zookeeper.feed();
    }

    private void feed() {
        EatingHabbits habbits = new EatingHabbits(); // ❌ 错误！
        Animal animal = new Animal();
        Animal.EatingHabbits habbits1 = animal.eatingHabbits(); // ✅ 合法
    }
}

结果是？（多选）
A. 第7行编译错误
B. 第19行编译错误
C. 第21行编译错误
D. 无编译错误

分析： 第19行在 Zookeeper 类中直接 new EatingHabbits()，没有 Animal 实例，非法。

✅ 正确答案：B

考试技巧 5.2：内部类中 this 关键字的用法

⚠️ this 指代当前对象：

this：当前内部类实例
外部类名.this：对应的外部类实例

public class Animal {
    private int age = 10;

    public class EatingHabbits {
        private int numOfTimes = 5;

        public void print() {
            System.out.println("numOfTimes: " + this.numOfTimes); // ✅
            System.out.println("age: " + this.age); // ❌ 编译错误！
            System.out.println("age: " + Animal.this.age); // ✅
        }
    }

    public static void main(String[] args) {
        Animal.EatingHabbits habbits = new Animal().new EatingHabbits();
        habbits.print();
    }
}

this.age 试图通过内部类的 this 访问外部类的 age，这是不允许的。必须用 Animal.this.age。

考试技巧 5.3：局部内部类访问局部变量

⚠️ 规则： 方法内的局部内部类只能访问 final 或 实际上的 final 的局部变量。

public class Animal {
    private int age = 10;

    public void printAge() {
        String message = "The age is "; // 未被修改，effectively final
        class PrintUtility {
            void print() {
                System.out.println(message + age); // ✅ 可以访问
            }
        }

        PrintUtility utility = new PrintUtility();
        utility.print();
    }

    public static void main(String[] args) {
        new Animal().printAge();
    }
}

结果是？
A. The age is 0
B. The age is 10
C. 第8行编译错误
D. 第12行编译错误
E. 抛出异常

message 虽未声明 final，但其值未改变，是 effectively final，因此可以被内部类访问。

✅ 正确答案：B

考试技巧 5.4：局部内部类的访问修饰符

⚠️ 与局部变量一样，局部内部类不能有 public、private、protected、static 等修饰符。

public void someMethod() {
    public class LocalClass { // ❌ 编译错误
    }
}

此外，在静态方法中定义的局部类，只能访问外部类的静态成员。

考试技巧 5.5：静态内部类访问外部实例成员

⚠️ static 内部类（嵌套类）不持有外部类实例的引用，因此无法访问外部类的非静态成员。

public class Animal {
    private int age = 10;

    static class EatingHabits {
        public void print() {
            System.out.println(age); // ❌ 编译错误！无法访问非静态字段
            System.out.println(Animal.this.age); // ❌ 编译错误！Animal.this 无效
        }
    }
}

这两行在非静态内部类中是合法的，但在静态内部类中是典型的错误。

考试技巧 5.6：匿名内部类的语法错误

⚠️ 匿名类实例化后必须以分号 ; 结尾。

public class Animal {
    public void feed() {
        System.out.println("Eating Grass");
    }
}

public class Zookeeper {
    public static void main(String[] args) {
        Animal animal = new Animal(){
            public void feed(){
                System.out.println("Eating Fish");
            }
        } // ❌ 这里缺少分号！
        animal.feed();
    }
}

结果是？
...
F. 第15行编译失败

缺少分号导致语法错误。

✅ 正确答案：F

考试技巧 5.7：接口的实例化

⚠️ 接口不能直接实例化，只能通过实现类或匿名内部类实现。

Runnable r = new Runnable(); // ❌ 编译错误

Runnable r = new Runnable() { // ✅ 合法，匿名内部类
    @Override
    public void run() {
    }
};

这是并发编程中的常见写法，务必分清。

6. 枚举（Enums）

枚举（enum）是特殊的类，用于定义一组固定的常量。它们可以有构造函数、字段和方法，但语法有其独特性。

考试技巧 6.1：枚举声明的语法错误

⚠️ 关键点：

如果枚举包含方法或字段，枚举常量列表后必须加分号 ;
枚举的构造函数必须是 private（或包私有），不能是 public

public enum AnimalSpecies {
    MAMMAL(false), FISH(true), BIRD(false),
    REPTILE(false), AMPHIBIAN(true) // ❌ 这里缺少分号！

    boolean hasFins;

    public AnimalSpecies(boolean hasFins) { // ❌ 构造函数不能是 public
        this.hasFins = hasFins;
    }

    public boolean hasFins() {
        return hasFins;
    }
}

结果是？（多选）
A. 第2行编译错误
B. 第3行编译错误
C. 第7行编译错误
D. 第11行编译错误
E. 编译成功

✅ 正确答案：B, C

考试技巧 6.2：枚举中的抽象方法

⚠️ 如果枚举定义了抽象方法，那么每一个枚举常量都必须提供实现。

public enum AnimalSpecies {
    MAMMAL(false), 
    FISH(true){
        @Override
        boolean canFly() {
            return false;
        }
    }, 
    BIRD(false), // ❌ 未实现 canFly()
    REPTILE(false), 
    AMPHIBIAN(true); // ❌ 未实现 canFly()

    boolean hasFins;
    AnimalSpecies(boolean hasFins) {
        this.hasFins = hasFins;
    }
    public boolean hasFins() { return hasFins; }
    abstract boolean canFly(); // 抽象方法
}

public class Zookeeper {
    public static void main(String[] args) {
        AnimalSpecies.MAMMAL.canFly(); // 即使这里没执行，编译也会失败
    }
}

结果是？（多选）
A. 第2行编译错误
...
E. 无编译错误

因为 MAMMAL、BIRD 等常量没有实现 canFly()，编译失败。

✅ 正确答案：A

同理，如果 enum 实现了某个接口，每个常量也必须实现该接口的所有方法。

考试技巧 6.3：枚举值的遍历

✅ 方法： 使用 Enum.values() 静态方法获取所有常量的数组。

public enum AnimalSpecies {
    MAMMAL, FISH, BIRD, REPTILE, AMPHIBIAN
}

public class Zookeeper {
    public static void main(String[] args) {
        AnimalSpecies[] animals = AnimalSpecies.values(); // [MAMMAL, FISH, BIRD, ...]
        System.out.println(animals[2]); // 输出 BIRD
    }
}

结果是？
A. FISH
B. BIRD
...

animals[0] 是 MAMMAL，[1] 是 FISH，[2] 是 BIRD。

✅ 正确答案：B

7. Java 中的接口与 @Override 注解

接口定义行为契约。OCP 会考察多重继承、默认方法冲突、@Override 的正确使用等复杂场景。

考试技巧 7.1：非抽象类必须实现所有抽象方法

⚠️ 这是基本规则，但在复杂的继承链中容易被忽略。

class Bird implements Flyable {
    public void fly() { }
}
  
abstract class Catbirds extends Bird { } // ✅ 合法，抽象类
  
abstract class Flamingos extends Bird {
    public abstract String color(); // ✅ 合法，抽象方法
}
  
class GreaterFlamingo extends Flamingos {
    public String color() {
        System.out.println("The color is pink");
        return "pink"; // ⚠️ 注意：原代码缺少 return，也会编译错误，但题目假设合法
    }    
}
  
interface Flyable {
    void fly();
}

结果是？（多选）
A. 编译成功
...

GreaterFlamingo 通过继承 Flamingos 和 Bird，间接实现了 Flyable 的 fly() 方法，且 color() 提供了具体实现。

✅ 正确答案：A

额外提醒： 类可以 implements 多个接口，但只能 extends 一个类。implements 后的接口用逗号分隔。

考试技巧 7.2：同名默认方法的冲突

⚠️ 规则： 当一个类实现的多个接口包含同名同参的 default 方法时，该类必须重写此方法以解决冲突。

public interface Vegetarian {
    default void eat() {
        System.out.println("Eat Veg");
    }
}

public interface NonVegetarian {
    default void eat() {
        System.out.println("Eat NonVeg");
    }
}

public class Racoon implements Vegetarian, NonVegetarian {
    @Override
    void eat() { // ❌ 错误！重写方法必须是 public！
        System.out.println("Eat Something");
    }

    public static void main(String[] args) {
        new Racoon().eat();
    }
}

结果是？
...
E. 编译失败

虽然 Racoon 重写了 eat()，但访问级别是包私有（默认），低于接口中 default 方法的 public 级别。重写方法的访问权限不能比父类/接口方法更严格。

✅ 正确答案：E

考试技巧 7.3：@Override 注解的滥用

⚠️ @Override 的作用：

告诉编译器此方法意在重写父类/接口方法
如果父类没有此方法，编译器会报错，防止拼写错误

public abstract class Flamingo {
    public abstract String color();
    public abstract void fly();
}

public class GreaterFlamingo extends Flamingo {
    @Override
    public String color() { return "Pink"; }

    @Override
    public void fly() { System.out.println("Flying"); }

    @Override // ❌ 编译错误！Flamingo 类没有 eat() 方法
    public void eat() {
        System.out.println("Eating");
    }
    
    public static void main(String[] args) {
        System.out.println(new GreaterFlamingo().color());
    }
}

@Override 注解强制编译器检查。由于 Flamingo 没有 eat() 方法，这不是重写，而是新方法，使用 @Override 会导致编译失败。

✅ 正确答案：C（第19行，即 @Override 注解所在行）

8. 创建和使用 Lambda 表达式

Lambda 是函数式编程的核心，可作为实现函数式接口（只有一个抽象方法的接口）的简洁语法。

考试技巧 8.1：Lambda 中变量的访问限制

⚠️ 规则： Lambda 表达式可以访问外部的 final 或 实际上的 final 的变量。

List<String> birds = Arrays.asList("eagle", "seagull", "albatross", "buzzard", "goose");
int longest = 0;
birds.forEach(b -> {
    if (b.length() > longest){
        longest = b.length(); // ❌ 编译错误！尝试修改外部变量
    }
});
 
System.out.println("Longest bird name is length: " + longest);

结果是？
...
C. 第5行编译失败

longest 不是 final，且在 Lambda 内部被修改，不满足 effectively final 的条件。

✅ 正确答案：C

9. 总结

OCP 考试中，大部分编码题的陷阱都在于编译错误，而非运行时逻辑。很多题目通过复杂的继承、内部类、枚举语法来迷惑考生。

应试策略：

✅ 优先检查编译错误： 拿到代码题，先快速扫描是否有语法错误（访问修饰符、abstract/final 冲突、内部类实例化、变量访问等）。
✅ 理解核心规则： 牢记 abstract、final、static、private 等关键字的限制和组合规则。
✅ 善用 @Override： 它是你的语法检查工具，滥用会导致编译失败。
✅ 多练习： 理论知识需要通过大量高质量的模拟题来巩固。

本文覆盖了“高级 Java 类设计”中最常考、最容易出错的知识点。吃透这些，你就拿下了 OCP 这块硬骨头的一大半。祝你备考顺利！

Persistence

REST

Security

1. 概述

2. OCP Java 认证简介

3. 使用抽象类和方法的代码开发

考试技巧 3.1：抽象方法的访问修饰符陷阱

考试技巧 3.2：抽象类/方法的语法错误

考试技巧 3.3：子类未实现抽象方法

考试技巧 3.4：abstract 与 private/final/static 的非法组合

4. 使用 final 关键字的代码开发

考试技巧 4.1：final 方法的重写与 final 变量的修改

5. 内部类（Inner Classes）

考试技巧 5.1：非静态内部类的实例化方式

考试技巧 5.2：内部类中 this 关键字的用法

考试技巧 5.3：局部内部类访问局部变量

考试技巧 5.4：局部内部类的访问修饰符

考试技巧 5.5：静态内部类访问外部实例成员

考试技巧 5.6：匿名内部类的语法错误

考试技巧 5.7：接口的实例化

6. 枚举（Enums）

考试技巧 6.1：枚举声明的语法错误

考试技巧 6.2：枚举中的抽象方法

考试技巧 6.3：枚举值的遍历

7. Java 中的接口与 @Override 注解

考试技巧 7.1：非抽象类必须实现所有抽象方法

考试技巧 7.2：同名默认方法的冲突

考试技巧 7.3：@Override 注解的滥用

8. 创建和使用 Lambda 表达式

考试技巧 8.1：Lambda 中变量的访问限制

9. 总结