Java中的protected和default修饰符比较

Java 访问修饰符概述

在深入探讨 protected 和 default 修饰符之前，先简单回顾一下 Java 中的访问修饰符体系。Java 提供了四种访问修饰符，用于控制类、变量、方法以及构造函数的访问权限，它们分别是 public、protected、default（也称为包访问权限，当不写任何修饰符时即为 default）和 private。这些修饰符决定了代码的哪些部分可以访问特定的元素，从而在面向对象编程中实现封装、数据隐藏和模块化等重要特性。

public 修饰符表示最高的访问权限，被 public 修饰的元素可以从任何包中的任何类访问。private 修饰符则相反，它表示最低的访问权限，被 private 修饰的元素只能在声明它的类内部访问。而 protected 和 default 修饰符处于这两者之间，它们的访问权限规则相对复杂一些，也是我们接下来要重点比较的对象。

default 修饰符

default 修饰符的访问权限

当一个类、变量、方法或构造函数没有显式地使用任何访问修饰符时，它就具有 default 访问权限。具有 default 访问权限的元素只能在同一个包内的其他类中访问。这意味着，如果你有两个类在同一个包中，一个类中的 default 元素可以被另一个类访问；但如果这两个类位于不同的包中，即使它们存在继承关系，default 元素也无法被访问。

下面通过代码示例来演示 default 修饰符的访问权限：

// 包名 com.example.defaultdemo
package com.example.defaultdemo;

// 定义一个具有 default 访问权限的类
class DefaultClass {
    // default 访问权限的变量
    int defaultVariable;

    // default 访问权限的方法
    void defaultMethod() {
        System.out.println("This is a default method.");
    }
}

// 同一包内的另一个类
class AnotherClassInSamePackage {
    void accessDefaultElements() {
        DefaultClass obj = new DefaultClass();
        obj.defaultVariable = 10;
        obj.defaultMethod();
    }
}

在上述代码中，AnotherClassInSamePackage 类能够访问 DefaultClass 类中具有 default 访问权限的变量 defaultVariable 和方法 defaultMethod，因为它们在同一个包 com.example.defaultdemo 中。

现在假设我们有一个位于不同包的类来尝试访问 DefaultClass 的 default 元素：

// 包名 com.example.otherpackage
package com.example.otherpackage;

// 尝试访问 com.example.defaultdemo.DefaultClass 的 default 元素
class ClassInDifferentPackage {
    void tryAccess() {
        // 以下代码会报错，因为 DefaultClass 在不同包且具有 default 访问权限
        com.example.defaultdemo.DefaultClass obj = new com.example.defaultdemo.DefaultClass();
        obj.defaultVariable = 10;
        obj.defaultMethod();
    }
}

上述代码会在编译时报错，因为 ClassInDifferentPackage 位于不同的包 com.example.otherpackage，无法访问 com.example.defaultdemo.DefaultClass 中的 default 元素。

default 修饰符在类中的应用

对于类来说，default 访问权限意味着该类只能被同一个包内的其他类访问和继承。这在构建一些内部使用的类，不希望外部包随意访问时非常有用。例如，在一个大型项目中，可能有一些辅助类，它们只在特定的包内提供功能，使用 default 修饰类可以限制其访问范围，避免外部不必要的依赖和误用。

// 包名 com.example.internalutil
package com.example.internalutil;

// default 访问权限的类，只供本包内使用
class InternalHelper {
    void internalHelpMethod() {
        System.out.println("This is an internal help method.");
    }
}

在这个例子中，InternalHelper 类具有 default 访问权限，只有 com.example.internalutil 包内的其他类可以使用它。如果外部包的类尝试使用 InternalHelper，会导致编译错误。

default 修饰符在接口中的应用

在接口中，default 关键字有不同的含义。从 Java 8 开始，接口可以包含 default 方法。这些方法有方法体，允许接口为实现它的类提供一些默认的行为。接口中的 default 方法默认是 public 的，不能显式地声明为 private、protected 或 default（这里的 default 是访问修饰符意义上的，与接口 default 方法关键字区分）。

interface MyInterface {
    void regularMethod();

    // 接口中的 default 方法
    default void defaultMethodInInterface() {
        System.out.println("This is a default method in the interface.");
    }
}

class MyClass implements MyInterface {
    @Override
    public void regularMethod() {
        System.out.println("Implementing regular method.");
    }
}

在上述代码中，MyClass 实现了 MyInterface，由于 MyInterface 提供了 defaultMethodInInterface 的默认实现，MyClass 可以直接使用这个方法，也可以选择重写它。

protected 修饰符

protected 修饰符的访问权限

protected 修饰符的访问权限比 default 更宽泛一些。被 protected 修饰的元素不仅可以被同一个包内的其他类访问，还可以被不同包中的子类访问。这使得 protected 修饰符在继承体系中非常有用，它允许子类访问父类的某些成员，同时又限制了其他无关类的访问。

通过代码示例来看看 protected 修饰符的访问权限：

// 包名 com.example.protecteddemo
package com.example.protecteddemo;

// 定义一个父类，包含 protected 元素
class ParentClass {
    // protected 访问权限的变量
    protected int protectedVariable;

    // protected 访问权限的方法
    protected void protectedMethod() {
        System.out.println("This is a protected method.");
    }
}

// 同一包内的子类
class ChildClassInSamePackage extends ParentClass {
    void accessProtectedElements() {
        this.protectedVariable = 20;
        this.protectedMethod();
    }
}

// 不同包内的子类
package com.example.otherpackage;
import com.example.protecteddemo.ParentClass;

class ChildClassInDifferentPackage extends ParentClass {
    void accessProtectedElements() {
        this.protectedVariable = 30;
        this.protectedMethod();
    }
}

在上述代码中，ChildClassInSamePackage 和 ChildClassInDifferentPackage 都能访问 ParentClass 中 protected 修饰的变量 protectedVariable 和方法 protectedMethod。ChildClassInSamePackage 因为与 ParentClass 在同一个包 com.example.protecteddemo 中可以访问；ChildClassInDifferentPackage 虽然位于不同包 com.example.otherpackage，但作为 ParentClass 的子类同样可以访问 protected 元素。

然而，如果一个非子类且位于不同包的类尝试访问 ParentClass 的 protected 元素，就会报错：

// 包名 com.example.otherpackage
package com.example.otherpackage;
import com.example.protecteddemo.ParentClass;

class NonSubClassInDifferentPackage {
    void tryAccess() {
        // 以下代码会报错，因为 NonSubClassInDifferentPackage 不是子类且在不同包
        ParentClass obj = new ParentClass();
        obj.protectedVariable = 40;
        obj.protectedMethod();
    }
}

上述代码会在编译时报错，因为 NonSubClassInDifferentPackage 既不是 ParentClass 的子类，又与 ParentClass 不在同一个包中，无法访问 protected 元素。

protected 修饰符在类中的应用

通常情况下，类不会被直接声明为 protected。因为 protected 类的访问权限会导致它只能被同一个包内的类和不同包中的子类访问，这种限制对于类来说过于严格且不符合常规的类设计原则。一般我们使用 public 或 default 来修饰类，private 用于内部类。但在嵌套类的情况下，内部类可以被声明为 protected，这样可以限制内部类的访问范围，使其只能在外部类所在包以及外部类的子类中使用。

package com.example.nestedclass;

class OuterClass {
    // protected 修饰的内部类
    protected class InnerProtectedClass {
        void innerMethod() {
            System.out.println("This is an inner method of InnerProtectedClass.");
        }
    }
}

// 同一包内的类访问 InnerProtectedClass
class ClassInSamePackage {
    void accessInnerClass() {
        OuterClass outer = new OuterClass();
        OuterClass.InnerProtectedClass inner = outer.new InnerProtectedClass();
        inner.innerMethod();
    }
}

// 不同包内的子类访问 InnerProtectedClass
package com.example.otherpackage;
import com.example.nestedclass.OuterClass;

class SubClass extends OuterClass {
    void accessInnerClass() {
        InnerProtectedClass inner = new InnerProtectedClass();
        inner.innerMethod();
    }
}

在上述代码中，InnerProtectedClass 作为 OuterClass 的 protected 内部类，ClassInSamePackage 因为与 OuterClass 在同一个包可以访问它；SubClass 作为 OuterClass 的子类，即使位于不同包也能访问 InnerProtectedClass。

protected 修饰符在继承中的意义

在继承体系中，protected 修饰符扮演着重要的角色。它允许子类访问父类中需要继承但又不希望被外部无关类访问的成员。例如，在一个图形绘制的类库中，可能有一个 Shape 父类，其中定义了一些计算图形属性的方法，这些方法对于子类（如 Circle、Rectangle 等）来说是重要的实现基础，但不应该被外部随意调用。通过将这些方法声明为 protected，可以保证子类能够继承和使用这些方法，同时限制了外部类的访问。

package com.example.graphics;

class Shape {
    protected double area;

    protected void calculateArea() {
        // 这里只是示例，实际计算逻辑根据具体图形而定
        area = 0;
    }
}

class Circle extends Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    protected void calculateArea() {
        area = Math.PI * radius * radius;
    }
}

在上述代码中，Shape 类中的 area 变量和 calculateArea 方法被声明为 protected，Circle 类作为子类可以访问并根据自身需求重写 calculateArea 方法来计算圆的面积。

protected 和 default 修饰符的比较

访问权限范围比较

从访问权限范围来看，default 修饰符的范围局限于同一个包内。只要在同一个包中，任何类都可以访问具有 default 访问权限的元素。而 protected 修饰符不仅允许同一个包内的类访问，还允许不同包中的子类访问。这使得 protected 的访问范围比 default 更宽泛。

以之前的代码为例，default 修饰的 DefaultClass 中的元素只能被 com.example.defaultdemo 包内的类访问，而 protected 修饰的 ParentClass 中的元素除了被 com.example.protecteddemo 包内的类访问外，还能被 com.example.otherpackage 包中的 ChildClassInDifferentPackage 这样的子类访问。

适用场景比较

default 修饰符适用于那些只希望在同一个包内使用的元素。比如，在一个包中实现一些内部工具类、辅助方法或变量，这些内容不需要被外部包访问，使用 default 可以很好地隐藏实现细节，同时又能在包内共享。例如，在一个数据库操作包中，可能有一些 default 访问权限的工具方法，用于在包内处理数据库连接、SQL 语句构建等操作，外部包不需要关心这些细节。

protected 修饰符则更侧重于继承体系。当你希望父类的某些成员能够被子类访问，但又不想让外部无关类随意访问时，protected 是一个很好的选择。在构建框架或类库时，经常会使用 protected 来保护一些关键的实现细节，同时又允许子类进行扩展和定制。比如，在一个 Web 框架中，父类可能定义了一些 protected 的方法来处理请求、响应等操作，子类可以继承并根据具体业务需求进行重写。

对代码结构和维护的影响比较

使用 default 修饰符有助于保持包内代码的独立性和内聚性。由于 default 元素只能在包内访问，这使得包内的代码可以作为一个相对独立的模块进行开发和维护。如果需要对包内的实现进行修改，只要不改变包内接口（即 public 元素），对外部包的影响较小。

而 protected 修饰符在继承体系中对代码结构和维护有着重要影响。它在保证父类实现封装性的同时，为子类提供了扩展的能力。但也正是因为 protected 元素可以被子类在不同包中访问，在进行父类代码修改时需要更加谨慎，因为可能会影响到多个子类的行为。所以在使用 protected 时，需要对整个继承体系有清晰的认识，确保修改不会引发意外的问题。

示例综合分析

下面通过一个更复杂的示例来综合分析 protected 和 default 修饰符的使用和区别。

假设我们正在开发一个简单的游戏框架，其中有一个 GameEntity 类作为所有游戏实体的基类。

// 包名 com.example.gameframework
package com.example.gameframework;

public class GameEntity {
    // protected 变量，用于记录实体的生命值
    protected int health;

    // default 方法，用于在包内处理一些通用的初始化逻辑
    void initialize() {
        health = 100;
    }

    // protected 方法，用于实体受到伤害的逻辑
    protected void takeDamage(int damage) {
        health -= damage;
        if (health < 0) {
            health = 0;
        }
    }
}

在上述代码中，health 变量被声明为 protected，因为不同包中的子类（如 Player、Enemy 等）可能需要访问和修改这个生命值。initialize 方法被声明为 default，因为它是包内使用的初始化逻辑，外部包不需要关心。takeDamage 方法被声明为 protected，以便子类可以根据自身需求重写伤害处理逻辑。

接下来，我们在不同包中定义 Player 子类：

// 包名 com.example.game
package com.example.game;
import com.example.gameframework.GameEntity;

public class Player extends GameEntity {
    private String name;

    public Player(String name) {
        this.name = name;
        initialize();
    }

    @Override
    protected void takeDamage(int damage) {
        // 玩家可能有特殊的伤害减免逻辑
        super.takeDamage(damage / 2);
    }
}

在 Player 类中，由于继承自 GameEntity，可以访问 GameEntity 中的 protected 变量 health 和 protected 方法 takeDamage。同时，因为 Player 与 GameEntity 在不同包中，GameEntity 的 default 方法 initialize 不能直接从外部包访问，但 Player 类在其构造函数中可以调用 initialize 方法，因为 Player 类所在包 com.example.game 中的其他类无法直接访问 GameEntity 的 default 方法，这符合 default 修饰符的访问规则。

如果在 com.example.game 包中定义一个非子类的类来尝试访问 GameEntity 的元素：

// 包名 com.example.game
package com.example.game;
import com.example.gameframework.GameEntity;

public class GameUtil {
    void tryAccess() {
        GameEntity entity = new GameEntity();
        // 以下访问会报错，因为 GameUtil 不是子类且在不同包
        entity.health = 10;
        entity.takeDamage(5);
        // 以下访问也会报错，因为 initialize 是 default 方法且在不同包
        entity.initialize();
    }
}

上述 GameUtil 类尝试访问 GameEntity 的 protected 元素和 default 方法都会导致编译错误，这进一步体现了 protected 和 default 修饰符的访问限制规则。

总结与注意事项

在实际的 Java 编程中，正确选择 protected 和 default 修饰符对于代码的安全性、可维护性和可扩展性至关重要。当你希望限制访问范围在同一个包内时，优先考虑使用 default 修饰符；而当你需要在继承体系中允许子类访问某些成员，同时限制外部无关类的访问时，protected 修饰符是更好的选择。

需要注意的是，在使用 protected 修饰符时，要充分考虑到对整个继承体系的影响，因为父类 protected 成员的修改可能会影响到多个子类。同时，在设计包结构和类的继承关系时，要合理规划 default 和 protected 元素的使用，以确保代码结构清晰、易于维护。

通过深入理解 protected 和 default 修饰符的特性、访问权限和适用场景，并结合实际项目需求进行合理使用，可以编写出更加健壮、安全且易于维护的 Java 代码。在后续的开发过程中，不断实践和总结经验，能够更好地掌握这两个重要的访问修饰符，提升代码质量和开发效率。