为什么类不能被定义为受保护的？

Question

为什么我们不能将类定义为protected？

我知道我们不能，但为什么呢？应该有一些具体的原因。

Answer 1

因为这没有意义。

受保护的类成员（方法或变量）就像包私有（默认可见性）一样，只不过它也可以从子类访问。
由于 Java 中没有“子包”或“包继承”这样的概念，因此声明类 protected 或 package-private 是一样的。

不过，您可以将嵌套类和内部类声明为受保护的或私有的。

Answer 2

如您所知，默认值用于包级别访问，受保护用于包级别加上非包类，但它扩展了此类（这里要注意的一点是，只有在该类可见时才可以扩展该类！）。
让我们这样说：

• 受保护的顶级类对其包中的类是可见的。
• 现在使其在包（子类）外部可见有点令人困惑和棘手。哪些类应该被允许继承我们的受保护类？
• 如果所有类都允许子类化，那么它将类似于公共访问说明符。
• 如果没有，则与默认类似。

由于无法限制此类仅由少数类子类化（我们无法限制类仅由包内/包外的所有可用类中的少数类继承），因此不使用受保护的访问说明符为顶级课程。因此这是不允许的。

Answer 3

public class A
{
    protected class B
    {
    }
}

Answer 4

定义受保护的字段使得该字段只能通过继承在包内部和包外部访问（仅在子类内部）。

因此，如果我们允许对一个类进行保护，那么我们可以很容易地在包内访问它，但是为了在包外访问该类，我们首先需要扩展定义该类的实体，即它的包。

由于包不能扩展（可以导入），定义一个受保护的类将再次使其成为包私有，这类似于我们已经可以将其定义为默认值。
因此，将类定义为私有没有任何好处，它只会使事情变得模糊。

有关更多信息，请阅读 为什么外部 Java 类不能是私有的或受保护的

Answer 5

@Nikita Rybak 的回答有很好的观点，但缺乏细节，我无法在不深入思考的情况下简单地理解这个想法，以下是我的想法，现在我应该完全理解原因了。

四个访问修饰符，假设第一级是公共的，第四级是私有的（基于此 表 按顺序）。首先我们应该知道的是为什么类不能在顶层定义为私有的。

因此，如果“private class foo”（定义的私有成员，即类本身是成员）允许，那么外部（包含该成员）是什么？ 文件范围？不，文件外部是没有意义的，因为即使单个文件中的多个类也会被编译成单独的类文件。 所以外部是包装。但是第三级默认访问修饰符已经意味着“package-private”。因此，将不会使用/允许第四级私有访问修饰符。

但是嵌套私有类是允许的，因为直接外部是类，而不是包，eg：

class PrivateNestedMain {
    private static class Inner {
        public static void main(String[] args) {
            System.out.println("Hello from Inner!");
        }
    }
}

现在如果“受保护的类 foo”允许怎么办？ protected 主要特征是子类，因此外部（包）应该（由于范围有限，但仍然是可选的）提供子类的样式，即子包，或者包 A 扩展了包 B，但我们不知道这样的事情。因此，protected 不能在外部是包的顶层（即没有这样的子包）使用全部潜力（主范围是子类范围），但 protected 可以在外部是嵌套类的嵌套类中使用全部潜力是类（即可以是子类）：

class ProtectedNestedMain {
    protected static class Inner {
        public static void main(String[] args) {
            System.out.println("Hello from Inner!");
        }
    }
}

请注意，上面所说的“不能充分利用潜力”，因为它不能达到子类范围，仅仅因为没有外部子类，这意味着实际上受保护可以允许，这只是一个选择问题，以避免重复包私有的工作（如果外部不可子类化），请参见下文。

我的困惑主要是由 https://docs 中著名的表格引起的。 oracle.com/javase/tutorial/java/javaOO/accesscontrol.html：

如果允许第一级（公共）和第三级（包私有），那么到底如何-不允许在第二级（受保护）之间？

公共支持子类所以容易误导。阅读此表的正确方法是

如果外部具有子类功能，则公共支持子类。

同样的误导也适用于 package-private，package-private 不支持子类（单元格中的 N）并不意味着子类概念适用于外部。

这意味着如果子类功能在外部不可用，我们应该忽略 Subclass 列：

正如我们现在所看到的，protected 和 package-private 现在都是同一级别（ YYN），不再困惑为什么不允许中间级别。总的来说，Java只选择package-private而不是protected以避免混淆（这只是一个选择问题，但protected主要特征是子类，所以package-private更优越），和结果，top-中只允许使用2个访问修饰符等级：

在顶层 - 公共或包私有（无显式修饰符）。

Answer 6

protected 与 public 不同。 Protected 既具有包级别访问权限，又只能通过继承在包外部访问。如果一个类在包外部 A 继承了其他包中的一个类（通过使用 INHERITANCE 来保护方法），它可以访问该类 B 的方法有受保护的方法，但从该类派生的子类，即 A 无法访问受保护的方法.. public 的情况相反..

示例：

package 2;
class B
{
protected void method1()
{
}
}
package 1;
import 2.B;
class A extends B
{
//can access protected method
}
class C extends A
{
//can't access the protected method
}

Answer 7

受保护：仅在包级别可见*。

类被定义保护 --->它无法从外部包扩展（不可见）。

如果它无法扩展，那么将其保持为受保护是没有意义的，因为这样它将成为允许的默认访问。

这同样适用于私有定义的类。

注意：嵌套类或内部类可以定义为受保护或私有。

*：探索受保护的关键字，对于这个答案，我做得很简洁。

Answer 8

如果外部类由 protected 声明，我认为您希望该类只能从同一包及其子类但不同的包访问。但是，不可能为受保护的类创建子类，因为当您编写“class Dog extends Animal”时，由于受保护的“Animal”只能被其子类访问，显然“Dog”不是“Animal”子类。

所以受保护的外部类与（默认）外部类相同！

Answer 9

内部类允许使用 protected 修饰符。但仍然无法从扩展外部类的类内部构造该内部类的实例。只有当构造代码位于同一个包内时，编译器才允许。但是 protected 修饰符对于默认的可访问性有什么区别呢？
因此，从我的角度来看，顶级类上根本不允许使用 protected 修饰符，并且它对于嵌入式类没有意义。

Answer 10

“受保护”的行为=“默认”的行为+“在任何包的任何子类中使用它”。

无论如何，我们有类的默认访问修饰符，我们可以从 protected 访问修饰符获得的唯一优点是： - 通过子类化在任何包中使用它。但对于子类，父“受保护”类的可见性将是私有的。所以无法访问。基本上，如果您有一个受保护的顶级类，则任何外部类都无法通过子类化它来获得访问权限。所以保护一个顶级类是没有意义的。

Answer 11

@Akash5288 的答案对我来说毫无意义：

如果所有类都允许子类化，那么它将类似于公共访问说明符。

由于没有办法限制此类仅被少数类子类化（我们不能限制类仅被包内/包外的所有可用类中的少数类继承），因此无法使用顶级类的受保护访问说明符。因此这是不允许的。

然后，您可以将相同的逻辑应用于受保护的方法和变量，它们也“类似于公共”。包外部的所有类都可以扩展我们的公共类并使用其受保护的方法。为什么将方法和变量限制在扩展类中可以，但限制整个类就不行？ “与公众相似”不是“与公众相同”。我的解释是，允许受保护的类是完全可以的，就像允许受保护的方法是很好的一样。

答案“您不能扩展您无法访问/查看的类”更合乎逻辑。

Answer 12

这个问题的意义在于，JVM 是用 C（Sun JVM）和 C++（oracle JVM）编写的，因此在编译期间，我们将从 java 文件中创建 .class 文件，并且如果我们使用 Protected 关键字声明一个类那么它就不会被JVM访问。

受保护的类不会被 JVM 访问的原因是，受保护的字段只能通过继承在同一个包内或不同的包中访问，而 JVM 并没有以继承类的方式编写。
希望这能满足这个问题:)

同样，顶级类不能是私有的。解释如下：

那么，如果我们定义一个私有类，该类只能在定义它的实体（在我们的例子中是它的包）中访问，会发生什么？

因此，定义对类的私有访问将使其可以在同一个包内进行访问，而默认关键字已经为我们做到了这一点，因此定义私有类没有任何好处，它只会使事情变得模糊。

Answer 13

protected 表示该成员可以被同一个包中的任何类访问
以及子类，即使它们位于另一个包中。

例子：

package a;
class parent{
 protected void p();
}
package b;
import a.p;
class child extends parent{
  //you can access method which is protected in the parent in the child 
}
class another extends child {
 //here you can not access the protected method 
}