Java 中 `protected` 关键字的深入解析

简介

在 Java 编程中，访问修饰符是控制类、方法和变量访问权限的重要工具。protected 作为其中一种访问修饰符，扮演着独特的角色。它提供了比 private 更宽松但比 public 更严格的访问控制，允许子类和同一包内的类访问受保护的成员。本文将详细介绍 protected 关键字的基础概念、使用方法、常见实践以及最佳实践，帮助读者深入理解并高效使用它。

基础概念

在 Java 中，protected 是一种访问修饰符，可用于修饰类的成员（字段和方法）。使用 protected 修饰的成员具有以下访问规则： - 同一包内：同一包内的任何类都可以访问 protected 成员。 - 不同包的子类：不同包中的子类可以访问其超类的 protected 成员，但只能通过子类对象来访问，不能通过超类对象访问。

与其他访问修饰符对比： - private：只有类内部可以访问。 - default（无修饰符）：同一包内可以访问。 - public：任何地方都可以访问。

使用方法

同一包内访问 `protected` 成员

// 包名：com.example.demo
package com.example.demo;

// 定义一个基类
class BaseClass {
    protected int protectedField = 10;

    protected void protectedMethod() {
        System.out.println("This is a protected method.");
    }
}

// 同一包内的另一个类
class AnotherClass {
    public static void main(String[] args) {
        BaseClass base = new BaseClass();
        // 同一包内可以访问 protected 字段
        System.out.println(base.protectedField);
        // 同一包内可以访问 protected 方法
        base.protectedMethod();
    }
}

不同包的子类访问 `protected` 成员

// 包名：com.example.base
package com.example.base;

// 基类
public class Base {
    protected int protectedField = 20;

    protected void protectedMethod() {
        System.out.println("This is a protected method in Base class.");
    }
}

// 包名：com.example.sub
package com.example.sub;

import com.example.base.Base;

// 子类
public class SubClass extends Base {
    public void accessProtectedMembers() {
        // 子类可以访问基类的 protected 字段
        System.out.println(protectedField);
        // 子类可以访问基类的 protected 方法
        protectedMethod();
    }

    public static void main(String[] args) {
        SubClass sub = new SubClass();
        sub.accessProtectedMembers();
    }
}

常见实践

封装和继承的结合

protected 关键字常用于实现封装和继承的结合。通过将某些成员声明为 protected，可以在一定程度上隐藏类的内部实现细节，同时允许子类扩展和定制这些成员。

// 基类
class Animal {
    protected String name;

    protected Animal(String name) {
        this.name = name;
    }

    protected void makeSound() {
        System.out.println("Animal makes a sound.");
    }
}

// 子类
class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }

    @Override
    protected void makeSound() {
        System.out.println(name + " barks.");
    }
}

框架开发中的使用

在框架开发中，protected 可以用于提供一些供子类扩展的方法或字段，同时限制外部类的直接访问。例如，Java 的抽象类和接口中，protected 方法可以作为模板方法，供子类实现具体逻辑。

// 抽象类
abstract class AbstractService {
    protected abstract void init();

    public final void start() {
        init();
        System.out.println("Service started.");
    }
}

// 具体子类
class ConcreteService extends AbstractService {
    @Override
    protected void init() {
        System.out.println("Initializing concrete service...");
    }
}

最佳实践

遵循最小权限原则

只将必要的成员声明为 protected，避免过度暴露类的内部实现。如果一个成员只需要在类内部使用，应使用 private 修饰符；如果需要在不同包的子类中使用，才考虑使用 protected。

文档注释

对于 protected 成员，应提供详细的文档注释，说明其用途和使用限制，帮助子类开发者正确使用这些成员。

/**
 * Represents a person.
 */
class Person {
    /**
     * The person's age.
     * This field is protected to allow subclasses to access and modify it.
     */
    protected int age;

    /**
     * Constructs a new Person with the given age.
     * @param age the person's age
     */
    protected Person(int age) {
        this.age = age;
    }

    /**
     * Gets the person's age.
     * @return the person's age
     */
    protected int getAge() {
        return age;
    }
}

小结

protected 关键字在 Java 中提供了一种灵活的访问控制机制，它允许同一包内的类和不同包的子类访问受保护的成员。通过合理使用 protected，可以实现封装和继承的有效结合，提高代码的可维护性和可扩展性。在使用 protected 时，应遵循最小权限原则，并提供详细的文档注释，以确保代码的正确性和可读性。

参考资料

《Effective Java》

Java 中 protected 关键字的深入解析

简介

目录