Eine Zusammenfassung der Pakete in Java

Ein Paket in Java kann als Ordner verstanden werden, , weil es sich um einen baumstrukturierten Pfad handelt Um ein Paket unter einem bestimmten Paket zu platzieren, müssen wir seine .class auch in dem nach dem Paket benannten Verzeichnis ablegen, sonst wird die Klasse nicht gefunden.

Um eine Klasse in ein Paket einzufügen, müssen Sie die Paketanweisung verwenden. Wenn wir die Paketanweisung nicht verwenden, werden unsere Klassen tatsächlich in ein Standardpaket eingefügt Dies ist auch der Grund, warum es beim Ausführen eines Java-Programms keine .class-Datei mit demselben Namen im laufenden Verzeichnis geben darf.

Darüber hinaus Ein vollständiger Klassenname ist der Paketname + Klassenname Wenn Sie eine Klasse ohne Import verwenden, müssen Sie den vollständigen Klassennamen angeben, z. B. java.util.Date . Der Einfachheit halber importiert Java automatisch die beiden Pakete java.lang und das Standardpaket der aktuellen Datei, das heißt: (1) Java schreibt vor, dass andere Pakete nicht den vollständigen Klassennamen angeben müssen, wenn Klassen in Java verwendet werden. lang-Paket; (2) ) Klassen im Standardpaket können untereinander (oder unter demselben Paket) verwendet werden, ohne den vollständigen Klassennamen anzugeben.

Es gibt die folgenden Regeln für den gegenseitigen Zugriff zwischen gepackten und nicht gepackten Klassen: (1) Ungepackte Klassen können auf gepackte Klassen zugreifen, die direkt importiert werden Ja (2 ) Klassen mit Paketen können nicht auf Klassen ohne Pakete zugreifen, da verschiedene Pakete importiert werden müssen. (3) Beim Definieren einer Klasse können andere diese verwenden. Stellen Sie daher sicher, dass Sie ein Paket definieren.

Java-Pakete scheinen hierarchisch zu sein (aus der Pfadsicht), tatsächlich sind sie es aber nicht. Beispielsweise sind java.awt und java.awt.color zwei Pakete mit demselben Status. java.awt.color gehört nicht zu java.awt.

Wenn Sie eine Klasse anhand des Klassennamens verwenden, prüfen Sie zunächst, ob die Klasse im aktuellen Paket vorhanden ist. Wenn nicht, suchen Sie im importierten Paket danach.

Mitglieder des Pakets

Einige zugehörige Klassen, Schnittstellen, Aufzählungen, Anmerkungstypen, von Klassen im Paket verwendete Ressourcendateien wie Bilder usw.

Die Rolle von das Paket

(1) Sammeln Sie verwandte Schnittstellen und Klassen

Fügen Sie beispielsweise Grafikverarbeitungsmodule zusammen

(2) Vermeiden Sie Namenskonflikte zwischen Typen : Als eine Art Kapselung stellen Pakete mehrschichtige Namespaces für Klassen bereit.

(3) Implementierung einer externen Zugriffskontrolle auf Pakete

Verwendung von Paketen (Deklaration und Import von Paketen)

Im Allgemeinen kann die Verwendung von Paketen in drei Schritten zusammengefasst werden : wie man Klassen und Schnittstellen in einem Paket bündelt, wie man die Klassen im Paket verwendet und wie man das Dateisystem so anordnet, dass der Compiler die Quelldateien finden kann.

1. Definieren Sie das Paket

1. Deklaration mit Paketklasse

Verwenden Sie das Paketschlüsselwort in der ersten Zeile des Quellcodes. Der Paketname lautet normalerweise nur in Kleinbuchstaben, mit „.“ getrennt.

Die Namenskonvention des Pakets finden Sie unter dem Link: https://segmentfault.com/a/1190000008711718

Die Deklaration des HTML-

-Pakets folgt wie folgt Grundsätze: (1) Die Paketanweisung muss am Anfang der Quelldatei stehen. (2) Eine Quelldatei darf nur eine Paketanweisung haben. (3) Paketnamen sind alle in Kleinbuchstaben geschrieben, um Verwechslungen mit Klassen und Schnittstellennamenkonflikten zu vermeiden.

2. Kompilieren Sie die Klasse mit dem Paket

javac -d Verzeichnis Quelldateiname.java

3. Führen Sie die Klasse mit dem Paket

java-Paketname aus .Klassenname

2. Verwendung von Paketen

Der Zugriff zwischen Klassen im selben Paket ist relativ einfach und kann direkt mit dem Klassennamen im Code verwendet werden, während der Zugriff zwischen verschiedenen Paketen a erfüllen muss Bedingung: Wenn Klassen in anderen Paketen auf eine Klasse zugreifen möchten, muss sie mit public geändert werden (Hinweis: Die mit public geänderte Klasse muss denselben Namen wie der Dateiname haben). Normalerweise gibt es drei Möglichkeiten zur Verwendung zwischen verschiedenen Paketen: (1) Verwenden Sie den vollständigen Namen, um auf die Klasse zuzugreifen. (3) Importieren Sie das gesamte Paket, das die Klasse enthält Vollständiger Name

Angenommen, es gibt ein Grafikpaket mit einer Circle-Klasse (öffentliche Modifikation), dann erfolgt die Auslagerung des Zugriffs darauf wie folgt:

graphics.Circle cir = new graphics.Circle();

2. Importieren Sie die Klasse

oben Die Methode zur Verwendung des vollständigen Namens ist etwas umständlich. Wenn Sie diese Klasse abkürzen oder häufig verwenden möchten, können Sie Folgendes tun:

import graphics.Circle;

public class PackageTest {
    public static void main(String[] args) {
        Circle cir = new Circle();
    }
}

3. Importieren Sie das gesamte Paket Wenn Sie weitere Klassen dieses Pakets verwenden möchten, können Sie beispielsweise für die Line-Klasse alle Klassen im Paket importieren:

import graphics.*;

public class PackageTest {
    public static void main(String[] args) {
        Circle cir = new Circle();
        Line line = new Line();
    }
}

三、管理文件系统

许多Java平台的实现依赖于文件系统的等级制度 来管理源文件和class文件。我们一般把类、接口、枚举、注释类型放在可以反映包名的目录中，比如，Rectangle.java属于graphics类，我们就放在.....\graphics\Rectangle.java的路径上。同样，我们对其进行编译产生的class文件也要放在类似的目录上（这个目录最好不要和源文件放在一起），这样的好处是当我们要复用某个类时，就知道到哪去找了，JVM在运行程序时也知道去哪里找类。

比如，源文件放在：\sources\com\example\graphics\Rectangle.java

class文件放在：\classes\com\example\graphics\Rectangle.class，其中，\classes是类路径（class path），由CLASSPATH系统变量进行设置，而包名是com.example.graphics。编译器、JVM通过将包名称添加到类路径来构造.class文件的路径。

所以编译器、JVM在路径\classes\com\example\graphics中查找类文件。class path可以有好几条，由分号（Windows）或冒号（UNIX）分隔。 默认情况下，编译器、JVM搜索当前目录和包含Java平台类的JAR文件，所以这些目录自动位于类路径中。

CLASSPATH是JVM或Java编译器中的一个参数，它指定用户定义的类和包的位置。 可以在命令行上或通过环境变量设置。默认情况下，我们访问JDK标准API和扩展包时，无需设置查找位置。 而用户自定义的包和库，则必须设置。由于JVM会在当前目录下搜索，所以当我们的文件都在运行目录下时，也可以不设置CLASSPATH。

有关CLASSPATH可以参考：

https://en.wikipedia.org/wiki/Classpath_%28Java%29

https://en.wikipedia.org/wiki/Java_Classloader

关于Import

关于import，有三个注意的地方。

1、

首先是，Java的包表面上的等级问题。从路径上看，包似乎是分层的，但它们不是。 例如，Java API包括java.awt包，java.awt.color包，java.awt.font包等等。但是，java.awt.color包、java.awt.font包和其他java.awt.xxxx包并不属于java.awt。 前缀java.awt（The Java abstract window toolkit）的作用只是告诉开发者——和窗口有关的包都在这里面。但是包和包之间并不是包含关系。

当你导入java.awt.*时，会导入java.awt包中的所有类型，但它不会导入java.awt.color，java.awt.font或任何其他java.awt.xxxx包的所有类型。 如果你要使用java.awt.color中的类以及java.awt中的类，则必须同时导入导入这两个包：

import java.awt.*;
import java.awt.color.*;

2、

其次是名字含糊不清的问题。当你导入的两个包中有一个类名字相同时，如果你继续采用缩写，就会出现一些问题。这时，你就要使用这个类的全名。比如，java.util、java.sql包中都有Date类，程序又同时导入了这两个包中的Date类。

import java.sql.*;
import java.date.*;

3、static import

当我们需要频繁访问某个类的常量和静态方法，反复写它们的前缀（全名）可能不利于代码阅读。 静态import语句就提供了一种导入要使用的常量和静态方法的方法，这样您就不需要为其名称添加前缀。比如java.lang.Math类定义PI常量和许多静态方法，包括计算正弦，余弦，切线，平方根，最大值，最小值，指数等。

import static java.lang.Math.PI;
import static java.lang.Math.cos;

public class ImportTest {
    public static void main(String[] args) {
        double r = Math.cos(Math.PI * 2);
		double r1 = Math.cos(PI * 2);
		double r2 = cos(PI * 2);
		System.out.println(r+" "+r1+" "+r2);    
    }
}

当然，你也可以直接全部导入：

import static java.lang.Math.*;

应该注意的是，使用静态导入时要非常谨慎。 过度使用静态导入会导致代码难以阅读和维护，因为阅读者不知道某个特定的静态对象是哪个类的。 不过，当我们恰当地使用静态导入时，代码可以因为不用繁琐地写全名而更具可读性。

 【推荐课程：Java视频教程】   

Das obige ist der detaillierte Inhalt vonEine Zusammenfassung der Pakete in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!