Java | 顶层类 Top-Level Class


顶层类

前言


本文内容根据 Java 官方教程中的《课程:类和对象》编写而成。

本文提供的是 JDK 14 的示例代码。

 

定义


顶层类(Top-Level Class),是 Java 中对类的一种定义方式。在 .java 文件中,处于最外层的类就称为顶层类,在其外部不存在将其包围起来的任何代码块。下面的示例就是一个典型的顶层类:

 1 /**
 2  * 定义一个公共的顶层类。
 3  */
 4 public class MyClass {
 5     public static void main(String[] args) {
 6         System.out.println("Hello World!");
 7     }
 8 }
 9 /* 输出结果:
10 Hello World!
11 
12  */

 

概述


顶层类可声明为 public,如前面示例中的 MyClass 类,也可声明为包私有的,如下:

 1 /**
 2  * 定义一个包私有的顶层类。
 3  */
 4 class PackagePrivateClass {
 5     public static void main(String[] args) {
 6         System.out.println("PackagePrivateClass:这是一个包私有的顶层类。");
 7     }
 8 }
 9 /* 输出结果:
10 PackagePrivateClass:这是一个包私有的顶层类。
11 
12  */
  • 提示:在定义一个类时,如果在 class 关键字前不加 publicprivateprotected 关键字,那么这个类就声明为包私有的(Package-Private),即它是类的默认声明。包私有的类可在其所在的包内共享,但不能跨包共享。

不允许将顶层类声明为 privateprotected,因为顶层类在本质上不属于私密类。如果将一个顶层类用 privateprotected 关键字隐藏起来(即不对外共享),那就无法创建这个类的实例,等同于没有定义这个类。

此外,不允许将顶层类声明为 static,因为顶层类在本质上是非静态的,只有在创建其实例时,才会将其加载到内存中。否则,Java 编译器将会生成一条类似于“此处不允许使用修饰符 static”的错误消息。

并列多个顶层类

.java 文件中,允许多个顶层类并列存在,但只能有一个与其文件名同名的、声明为 public 的顶层类。这个与文件名同名的顶层类可声明为包私有的,但在这个文件中的其他顶层类只能声明为包私有的

 1 /**
 2  * 定义一个顶层类。
 3  */
 4 public class TopLevelClass {
 5     public static void main(String[] args) {
 6         System.out.println("TopLevelClass:这是与 TopLevelClass.java 文件同名的顶层类。");
 7         System.out.println(new AnotherClass().toString());
 8     }
 9 }
10 
11 /**
12  * 定义另一个顶层类。
13  */
14 class AnotherClass {
15     public AnotherClass() {
16     }
17 
18     @Override
19     public String toString() {
20         return "AnotherClass:这是在 TopLevelClass.java 文件中的另一个顶层类。";
21     }
22 }
23 /* 输出结果:
24 TopLevelClass:这是与 TopLevelClass.java 文件同名的顶层类。
25 AnotherClass:这是在 TopLevelClass.java 文件中的另一个顶层类。
26 
27  */

在上述示例中,若将 AnotherClass 类声明为 public,则 Java 编译器将会生成一条类似于“类 AnotherClass 是公共的,应在名为 AnotherClass.java 的文件中声明”的错误消息。

声明抽象类

可使用 abstract 关键字,将顶层类声明为抽象类,如下:

 1 public class AbstractClassDemo {
 2     public static void main(String[] args) {
 3         new Subclass().printName();
 4     }
 5 }
 6 
 7 /**
 8  * 定义一个抽象类。
 9  */
10 abstract class AbstractClass {
11     private final String name;
12 
13     // 定义抽象类的构造方法。
14     public AbstractClass() {
15         name = "AbstractClass:这是一个抽象类。";
16     }
17 
18     // 定义一个非抽象方法。
19     public String getName() {
20         return name;
21     }
22 
23     // 定义一个抽象方法。
24     public abstract void printName();
25 }
26 
27 /**
28  * 定义一个子类。
29  */
30 class Subclass extends AbstractClass {
31     private final String name;
32 
33     // 定义子类的构造方法。
34     public Subclass() {
35         super();
36         name = "Subclass:这是一个抽象类的子类。";
37     }
38 
39     // 实现父类的抽象方法。
40     @Override
41     public void printName() {
42         System.out.println(super.getName());
43         System.out.println(name);
44     }
45 }
46 /* 输出结果:
47 AbstractClass:这是一个抽象类。
48 Subclass:这是一个抽象类的子类。
49 
50  */

想要了解有关抽象类的更多信息,请参阅《抽象类》。


作者:Blume,发布于:2020/06/27
原文:https://www.cnblogs.com/blume/p/13196499.html