Un résumé des packages en Java

Un package en Java peut être compris comme un dossier , car il s'agit d'un chemin arborescent lorsque nous utilisons package lors de la déclaration. un package sous un certain package, nous devons également mettre son .class dans le répertoire nommé d'après le package, sinon la classe ne sera pas trouvée.

Pour mettre une classe dans un package, vous devez utiliser l'instruction package. En fait, lorsque nous n'utilisons pas l'instruction package, nos classes sont placées dans un package par défaut. C'est également pourquoi lorsque nous exécutons un programme Java, il ne peut pas y avoir de fichier .class portant le même nom dans le répertoire en cours d'exécution.

De plus, Un nom de classe complet est le nom du package + le nom de la classe Lorsque vous utilisez une classe sans importation, vous devez donner le nom complet de la classe, par exemple java.util.Date. . Pour plus de commodité, Java importe automatiquement les deux packages java.lang et le package par défaut du fichier actuel, c'est-à-dire : (1) Java stipule que les autres packages n'ont pas besoin de donner le nom complet de la classe lors de l'utilisation des classes dans Java. lang package; (2) ) Les classes du package par défaut peuvent être utilisées entre elles (ou sous le même package) sans donner le nom complet de la classe.

Il existe les règles suivantes pour l'accès mutuel entre les classes packagées et non packagées : (1) Les classes non packagées peuvent accéder aux classes packagées, qui sont directement importées Oui (2) ) Les classes avec packages ne peuvent pas accéder aux classes sans packages. L'accès direct se fait à partir du même package. Étant donné que différents packages doivent être importés, les classes sans packages ne peuvent pas être importées (3) Lors de la définition d'une classe, afin que d'autres puissent l'utiliser. vous devez donc définir un package.

Les packages Java semblent hiérarchiques (du point de vue du chemin), mais en fait ils ne le sont pas. Par exemple, java.awt et java.awt.color sont deux packages avec le même statut. java.awt.color n'appartient pas à java.awt.

Lorsque vous utilisez une classe par nom de classe, vérifiez d'abord si la classe existe dans le package actuel, et sinon, recherchez-la dans le package importé.

Membres du package

Certaines classes associées, interfaces, énumérations, types d'annotations, fichiers de ressources utilisés par les classes du package comme les images, etc.

Le rôle de le package

(1) Rassemblez les interfaces et les classes associées

Par exemple, emballez les graphiques ; rassemblez les modules liés au traitement graphique

(2) Évitez Élimine les conflits de noms entre les types : en tant que sorte d'encapsulation, les packages fournissent des espaces de noms multicouches pour les classes.

(3) Implémentation du contrôle d'accès externe aux packages

Utilisation des packages (déclaration et importation des packages)

En général, l'utilisation des packages peut être résumée en Trois étapes : comment regrouper les classes et les interfaces dans un package, comment utiliser les classes du package et comment organiser le système de fichiers afin que le compilateur puisse trouver les fichiers sources.

1. Définir le package

1. Déclaration avec la classe package

Utilisez le mot-clé package dans la première ligne du code source pour définir le nom du package. généralement en minuscules, avec "."

Pour la convention de dénomination du package, veuillez consulter le lien : https://segmentfault.com/a/1190000008711718

La déclaration du package html

suit ce qui suit principes : (1) L'instruction package doit être placée au début du fichier source ; (2) Un fichier source ne peut avoir qu'une seule instruction package ; (3) Les noms de package sont tous en minuscules pour éviter toute confusion avec les classes et les conflits de noms d'interface.

2. Compilez la classe avec le package

javac -d directory source file name.java

3. Exécutez la classe avec le package

java package name. .Nom de la classe

2. Utilisation des packages

L'accès entre les classes d'un même package est relativement simple et peut être utilisé directement avec le nom de la classe dans le code tandis que l'accès entre les différents packages doit satisfaire un ; Condition : Si une classe veut être accessible aux classes d'autres packages, elle doit être modifiée avec public (remarque : la classe modifiée avec public doit avoir le même nom que le nom du fichier). Il existe généralement trois façons d'utiliser différents packages : (1) utiliser le nom complet pour accéder à la classe ; (2) importer la classe (3) importer l'intégralité du package contenant la classe

1. nom complet

Supposons qu'il existe un package graphique avec une classe Circle (modification publique), alors l'externalisation de l'accès à celui-ci est la suivante :

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

Importez la classe

<.>La méthode ci-dessus pour utiliser le nom complet est un peu lourde. Si vous souhaitez abréger ou utiliser cette classe fréquemment, vous pouvez le faire :

import graphics.Circle;

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

3. 🎜>Quand on veut utiliser le package Pour plus de classes, comme la classe Line, vous pouvez importer toutes les classes du package :

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在运行程序时也知道去哪里找类。

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

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

所以编译器、JVM在路径1c88c48f018631bbf99e30d7795bbcba\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视频教程】   

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!