<think>我们正在讨论的是如何在面向对象编程中调用
protected构造函数。
protected访问修饰符意味着该
构造函数只能被以下代码访问：
1. 同一个包中的其他类
2. 子类（无论子类位于哪个包中）
因此，调用
protected构造函数的主要方式有两种：
方式一：在同一个包中的类直接调用
方式二：在子类中通过super()调用（即使子类位于不同包）
注意：
protected构造函数不能在其他无关的类（非同一个包且非子类）中直接调用。
下面通过Java代码示例说明：
示例1：同一个包中的类直接调用
```java
package pkg1;
public class Parent {
protected Parent() { //
protected构造函数
System.out.println("Parent
protected constructor");
}
}
// 同一个包中的另一个类
class AnotherClassInSamePackage {
public void createInstance() {
// 允许：同一个包中的类可以调用
protected构造函数
Parent p = new Parent();
}
}
```
示例2：在子类中调用（子类可以在不同包）
```java
package pkg2; // 不同包
import pkg1.Parent;
public class Child extends Parent {
public Child() {
super(); // 允许：子类通过super()调用父类的
protected构造函数
System.out.println("Child constructor");
}
}
```
示例3：在非同一个包且非子类中调用（不允许）
```java
package pkg3; // 不同包
import pkg1.Parent;
public class OtherClass {
public void createInstance() {
// 编译错误：OtherClass不是Parent的子类，且不在同一个包中
// Parent p = new Parent();
}
}
```
注意事项：
1. 在子类中调用父类的
protected构造函数时，必须使用super()，且必须是子类
构造函数的第一条语句。
2. 如果父类没有提供无参
构造函数（而只有
protected的有参
构造函数），那么子类必须在
构造函数中显式调用super(参数)。
示例：调用父类
protected的有参
构造函数
```java
package pkg1;
public class Parent {
protected Parent(int value) { //
protected有参构造
System.out.println("Parent
protected constructor with value: " + value);
}
}
package pkg2;
import pkg1.Parent;
public class Child extends Parent {
public Child() {
super(10); // 必须显式调用，并传递参数
}
}
```
总结：调用
protected构造函数的合法途径
- 在同一个包内，任何类都可以直接通过new调用。
- 在子类中，通过super()调用（无论是否在同一个包）。
注意：在子类中，不能通过new Parent()来创建父类实例（除非在同一个包），因为子类虽然可以访问
protected成员，但只能在子类内部通过继承关系（即通过super()）来调用父类的
protected构造函数，而不能在子类中直接实例化父类（除非在同一个包）。这是因为在子类中，通过new Parent()来创建父类实例时，会被视为在外部创建，而
protected构造函数不允许外部包的非子类直接访问。
例如，在子类Child中（位于不同包）：
```java
public class Child extends Parent {
public void method() {
// 以下代码在pkg2.Child中（pkg2与pkg1不同包）会编译错误
// Parent p = new Parent(); // 错误：因为Parent的
protected构造函数在pkg1中，而Child在pkg2，虽然Child是子类，但这里不是通过继承关系（即不是通过super()）来调用，而是直接实例化父类，这被视为外部访问，因此不允许。
}
}
```
但是，有一种情况例外：如果子类与父类在同一个包，那么子类中可以直接通过new Parent()来创建实例，因为同一个包内允许。
因此，在跨包继承时，子类只能通过super()调用父类的
protected构造函数，而不能在子类中直接使用new Parent()。
结论：在面向对象编程中，调用
protected构造函数的最常见场景是在子类的
构造函数中使用super()进行调用。如果需要在同一个包的其他类中创建实例，也可以直接使用new。
相关问题：
1.
protected访问修饰符在
构造函数和方法中的区别？
2. 如何在子类中调用父类的
protected方法？
3. 为什么不同包的子类不能直接通过new创建父类实例（父类有
protected构造函数）？
4. 如何设计一个类，使其只能被继承而不可被直接实例化（除了子类）？</think>### 在面向对象编程中调用
protected构造方法
在面向对象编程中，`
protected`
构造方法的调用遵循特定规则。`
protected`访问修饰符允许以下调用方式：
#### 1. **在子类中直接调用（最常见方式）**
```java
class Parent {
protected Parent(String param) { //
protected构造方法
System.out.println("Parent
构造方法：" + param);
}
}
class Child extends Parent {
public Child() {
super("子类传递的参数"); // 子类直接调用父类
protected构造方法
System.out.println("Child
构造方法");
}
}
// 使用示例
new Child();
/* 输出：
Parent
构造方法：子类传递的参数
Child
构造方法
*/
```
**关键点**：
- 必须使用`super()`关键字
- `super()`必须是子类
构造方法中的**第一条语句**[^1]
- 子类和父类可以在不同包中
#### 2. **在同一个包内的其他类中调用**
```java
package com.example;
public class Parent {
protected Parent() { //
protected构造方法
System.out.println("Parent
构造方法");
}
}
class SamePackageClass {
public void createInstance() {
Parent p = new Parent(); // 允许：同一个包内调用
}
}
```
**规则**：同一个包内的所有类都可以调用`
protected`
构造方法
#### 3. **通过静态工厂方法调用（设计模式）**
```java
public class
ProtectedConstructorClass {
protected ProtectedConstructorClass() {} //
protected构造方法
// 静态工厂方法
public static
ProtectedConstructorClass create() {
return new
ProtectedConstructorClass(); // 类内部可以访问
protected构造
}
}
// 外部调用
ProtectedConstructorClass instance =
ProtectedConstructorClass.create();
```
#### 4. **在子类中通过匿名内部类调用**
```java
class Parent {
protected Parent(int x) {
System.out.println("Parent构造: " + x);
}
}
public class Main {
public static void main(String[] args) {
Parent p = new Parent(10) { // 匿名子类调用
protected构造
// 匿名类实现
};
}
}
```
### ⚠️ 重要限制
1. **跨包非子类禁止访问**
不同包的非子类无法调用`
protected`
构造方法：
```java
package packageA;
public class A {
protected A() {} //
protected构造
}
package packageB;
import packageA.A;
public class B {
public void tryCreate() {
// A a = new A(); // 编译错误：不同包的非子类
}
}
```
2. **反射调用限制**
即使通过反射，也会受访问规则限制：
```java
Constructor<Parent> constructor = Parent.class.getDeclaredConstructor();
constructor.setAccessible(true); // 尝试突破访问限制
Parent p = constructor.newInstance(); // 可能抛出IllegalAccessException
```
### 设计建议
1. 使用`
protected`
构造方法表示：**该类主要设计为被继承**
2. 配合工厂方法模式提供更灵活的实例创建方式
3. 在框架开发中常见此模式（如Spring的Bean初始化）
4. 当需要限制直接实例化但允许子类化时使用
> 合理使用`
protected`
构造方法可以实现"**白盒复用**"，允许子类定制初始化过程，同时对外隐藏实现细节[^2]。
本文详细解析了Java中使用protected构造方法的意义及其工作原理。介绍了如何通过子类继承来利用这种构造方法，并解释了为什么即使构造方法是受保护的也可以通过创建子类的方式实例化对象。
扫一扫
5364
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
