Chemin de classe
La méthode de chemin et d'écriture du compilateur Java lors de la compilation des fichiers .java et des machines virtuelles Java exécuter les fichiers .class est différent.
Sans définir aucune variable d'environnement de ClassPath, Javac peut compiler des fichiers .java à chemin complet. Par exemple:
javac d: /myjava/heloworld.java
Après la compilation, générez des fichiers de classe dans le même répertoire path.
La machine virtuelle Java par défaut doit rechercher des fichiers de classe à partir du chemin d'accès à la variable d'environnement de ClassPath à exécuter. Pour Java Virtual Machine, ce n'est pas un fichier de classe, mais une classe. Il n'a que des chemins de classe, mais pas de chemins de système de fichiers. La variable d'environnement de ClassPath est l'environnement qui fournit un chemin de recherche de recherche pour les machines virtuelles Java. Notez que la machine virtuelle ne recherche pas récursivement des chemins définis par ClassPath.
C'est-à-dire que le fichier Java ci-dessus peut être compilé correctement, mais ne peut pas être exécuté. Mais si le CLASSPATH est défini sur ".; d: / myjava /", la machine virtuelle Java recherchera d'abord à partir du chemin actuel, puis recherchera le fichier de classe à partir de d: / myjava.
Ainsi, après la compilation de Helloworld.java, il peut être exécuté directement:
Java Helloworld
Ou passez au répertoire D: / Myjava et exécutez Java Helloworld.
Mais ce qui suit est le mauvais sens. En fin de compte, bien que newdir.java puisse être compilé correctement, lors de l'exécution, il recherchera si newdir.class est disponible dans le répertoire actuel (d: / myjava), puis recherchera si newdir.class est disponible dans le d: / myjava, mais il ne reviendra pas au sous-directory newdir pour rechercher des fichiers de classe.
d: / cd myjavajavac newdir / newdir.javajava newdir
Par exemple, sous d: / myjava / bonjour, il y a deux fichiers source Java, et leur contenu est le suivant:
D: / Myjava / Hello Cat.java Dog.javacat.java =================================================================================================================================================================================================================================================================================. Classe publique Dog {public static void main (String [] args) {Cat c = new Cat (); }}La classe de chien est directement nouveaux objets de la classe CAT dans un autre fichier. Qu'il soit compilé ou exécuté, cela peut réussir, car le compilateur Javac recherchera automatiquement Cat.Class à partir du chemin spécifié par le chemin de classe lors de la compilation de Dog.java. C'est juste le moyen de rechercher, et cette classe est une classe publique, donc la compilation est réussie.
En bref, il doit être clair que le compilateur Javac recherche des chemins de fichier, ce qui n'a rien à voir avec le chemin de classe de la variable d'environnement. La machine virtuelle Java recherche des fichiers de classe, à strictement parler, des classes et le chemin de recherche est déterminé par le chemin de classe de variable d'environnement et a une séquence.
Pour plus de descriptions de ClassPath, voir "Package" ci-dessous.
Emballer
Les packages sont des collections de classes. Écrivez le mot clé du package sur la première ligne du fichier source Java (à l'exclusion des lignes de commentaires ou des lignes vierges) et donnez le nom du package, vous pouvez mettre le fichier de classe dans le package.
Par exemple, le fichier d: /myjava/cat.java:
package com.longshuai.home; classe publique Cat {public static void main (String [] args) {System.out.println ("com.longshuai.home.cat"); }}Cela signifie mettre la classe de chat dans le package com.longshuai.home. Les packages doivent être nommés d'après le nom de domaine inversé pour empêcher les noms duplicataires du package en contradiction, bien sûr, ce n'est pas nécessaire.
Pour les fichiers source qui n'utilisent pas de directives de package, les classes qui en sont à l'intérieur seront considérées comme des «classes nues» par défaut pendant la compilation.
La méthode du package de gestion Java est gérée au niveau du répertoire correspondant au nom du package. Par exemple, le package com.longshuai.home ci-dessus doit être placé sous com / longhuai / home (s'il s'agit de fenêtres, barreaux arrière), c'est-à-dire com / longhuai / home / cat.class.
Javac recherche des fichiers à partir des chemins à l'heure de la compilation. Par exemple, mettez ce chat.java sous com / longhuai / home. Lors de l'exécution, la machine virtuelle Java recherche que le fichier de classe soit chargé à partir du chemin de classe, et la façon de charger la classe est d'utiliser "." pour connecter différents types de noms. Par conséquent, les méthodes de compilation de ce fichier et d'exécution de ce fichier par Java Virtual Machine sont:
javac com / longhuai / home / cat.javajava com.longshuai.home.cat
Notez qu'il n'y a pas de relation entre les packages imbriqués, tels que Java.util Package et Java.util.jar, les packages n'ont pas de dépendances.
Utilisez les classes dans le package et l'importation (import)
Dans un fichier source Java, les classes dans d'autres fichiers ne peuvent pas être utilisées directement, sauf si la classe que vous souhaitez utiliser peut être recherchée par le chemin de classe de classe. Pour référencer d'autres classes qui ne sont pas CLASSPATH, vous ne pouvez les ajouter qu'à ClassPath ou les charger dans des packages, puis vous référer aux classes du package.
Les références à la classe dans le package peuvent être référencées en spécifiant le nom du package. Par exemple:
com.longshuai.home.cat c = new com.longshuai.home.cat ();
Mais évidemment, ce n'est pas pratique. Vous pouvez utiliser la directive d'importation pour importer les classes dans le package que vous devez utiliser dans les premières lignes du fichier source Java (mais après la commande Package). Par exemple, importez la classe CAT, afin que vous puissiez utiliser directement la classe:
import com.longshuai.home.cat; chat c = new Cat ();
Lors de l'importation de packages, vous pouvez utiliser l'astérisque "*" à la fin pour correspondre sauvagement toutes les classes importées, et utiliser uniquement "*" à la fin, car "*" correspond au nom de classe, pas au nom du package. Par conséquent, le symbole "*" ne peut pas être utilisé dans les non-end pour indiquer des classes dans d'autres packages, tels que:
import com.longshuai.home. *; // importe toutes les classes dans le package com.longshuai.home Import com.longshuai. *; // importe toutes les classes du package com.longshuai, mais les classes de com.longshuai.home ne seront pas importées, // parce que bien qu'il y ait des nidification entre les niveaux, ces packages n'ont pas d'importation de relations com. *. *; // c'est la mauvaise façon de l'écrire
S'il y a une classe avec le même nom dans le package importé, une erreur conflictuelle se produira lors de la référence à la classe avec le même nom. Par exemple, il existe des classes de date dans les packages Java.util et Java.SQL.
import java.util. *; import java.sql. *; public class test {public static void main (String [] args) {date today = new Date (); }}Compilation:
javac test.javatest.java:11: Erreur: la référence à la date n'est pas claire de date aujourd'hui = new Date (); ^ La classe java.sql.date dans java.sql et la classe java.util.date dans java.util à la fois correspond à test.java:11: erreur: la référence à la date n'est pas claire dès aujourd'hui = new Date (); ^ La classe java.sql.date dans java.util et la classe java.util correspondent à 2 erreurs
Pour le moment, vous pouvez importer explicitement la classe de date ou spécifier le nom du package lorsque vous utilisez la classe de date. C'est-à-dire que les deux méthodes suivantes sont correctes:
// Méthode 1: import java.util. *; Import java.sql. *; Import java.util.date; // méthode 2: import java.util. *; Import java.sql. *; Public class test {public static void main (string [] args) {java.util.date aujourd'hui = new java.util.date (); }}En plus d'importer des classes dans des packages, vous pouvez également des méthodes statiques et des variables statiques dans les classes dans les packages. Ajoutez simplement le mot-clé statique et spécifiez quoi importer. Par exemple:
Importer statique java.lang.system. *; import static java.lang.system.out;
Après des méthodes d'importation statique, le préfixe peut être omis, par exemple:
import static java.lang.system.out; public class classname {public static void main () {out.println ("helloworld"); // équivalent à System.out.println ("helloworld"); }}Package d'archive dans le package JAR
La machine virtuelle Java peut reconnaître directement le package JAR. Vous pouvez archiver le chemin d'accès correspondant au nom du package dans un package JAR à l'aide de la commande jar. Les instructions pour l'utilisation de la commande jar sont les suivantes:
Utilisation du jar: jar {ctxui} [vfmn0pme] [jar-file] [manifeste-file] [entrée] [-c dir] Files ... Options: -c Créer un nouveau fichier -u répertoire le répertoire archive -x extraire les fichiers spécifiés (ou tous) Fichier manifeste spécifié -N Après avoir créé un nouveau fichier, effectuez Pack200 Normalisation -e Spécifiez le point d'entrée de l'application pour une application autonome regroupée dans un fichier JAR exécutable -0 Store uniquement; N'utilisez aucune compression zip -p conserver le composant '/' (chemin absolu) et ".." (répertoire parent) -M ne crée pas le fichier manifeste pour les entrées -I est le fichier de fichiers de jar spécifié Informations d'index index -c modifier le répertoire spécifié et contient les fichiers suivants si un fichier est un répertoire, il est traité en récursivement. L'ordre spécifié du nom de fichier manifeste, du nom du fichier d'archive et du nom du point d'entrée est le même que celui des balises «m», «f» et «e».Par exemple, package a.class et b.class dans le répertoire actuel dans Test.jar:
jar cvf test.jar a.class b.class
Vérifiez la liste des fichiers dans le package JAR et s'affichera récursivement:
jar -tf test.jarmeta-inf / meta-inf / manifest.mfjiecheng.class
Par exemple, archivez le répertoire com en d: /dp.jar.
JAR CVF d: /dp.jar com / ajouté manifeste est ajouté: com / (entrée = 0) (sortie = 0) (stockage 0%) Ajouté: com / longshuai / (entrée = 0) (sortie = 0) (stockage 0%) Ajouté: com / longshuai / home / (input = 0) (sortie = 0) (stockage 0%) Ajout: com / longshuai / home / bird.class.class. (compressé 30%) Ajouté: com / longshuai / home / oiseau.java (entrée = 136) (sortie = 100) (compressé 26%) Ajouté: com / longhuai / home / cat.class (input = 417) (output = 289) (compressé par 30%) Ajouter: com / longshuai / home / cat.java (entrée = 134) (Output = 99) (comprimé par 26%)
Avec le fichier JAR, vous pouvez définir directement le chemin d'accès de ClassPath sur le nom du fichier JAR, de sorte que lors de la recherche de fichiers de classe, vous rechercherez directement à partir du fichier JAR. Par exemple, le ClassPath est défini sur:
.; d: / myjava; d: /dp.jar
Mécanisme de recherche de classe
Lors de la recherche de fichiers de classe dans des machines virtuelles Java, en plus du chemin spécifié par la variable d'environnement de classe de classe, deux chemins par défaut seront recherchés en premier: JRE / LIB et JRE / LIB / EXT, les classes qui semblent être recherchées dans le fichier JAR sous JRE / LIB / EXT.
Par exemple, lorsque ClassPath est défini sur ".; d: / myjava; d: /myjar.jar", vous souhaitez rechercher le fichier de classe com.longshuai.com.cat:
(un). Recherchez d'abord les fichiers JAR sous JRE / LIB et JRE / LIB / EXT;
(b) .Rearger pour savoir s'il existe com / longshuai / com / cat.class dans le répertoire actuel;
(c) .search d: /myjava/cat.class à nouveau;
(D) .Reargez s'il existe une classe com.longshuai.com.cat dans le fichier d: /myjar.jar.
Si une classe est référencée dans un fichier source Java, au moment de la compilation, les méthodes suivantes seront utilisées pour déterminer si la classe est raisonnable et valide:
(1). Recherchez si la classe de package importée contient la classe.
(2). Recherchez un package Java.lang implicitement importé, qui est importé par défaut.
(3). Si cette classe est définie dans le fichier actuel.
(4). Recherchez si la classe est dedans selon les règles de recherche du ClassPath ((a) - (d)).
hériter
La logique sémantique de "ce qui est" peut être reflétée entre les classes, afin que l'héritage des classes puisse être réalisé. Par exemple, un chat est un animal, alors un chat peut hériter d'une classe animale, tandis qu'une classe de chat est appelée sous-classe et qu'une classe animale est appelée classe parent.
Une fois que la sous-classe a hérité de la classe parent, la sous-classe a tous les membres de la classe parent, y compris les variables et les méthodes membres. En fait, en mémoire, lorsque de nouveaux objets de sous-classe sont utilisés, une partie de la zone est divisée en tas pour stocker les attributs hérités de la classe parent. Par exemple, la zone A obtenue par le nouveau parent, la zone B obtenue par New Child, et la zone A se trouve dans la zone B.
La raison pour laquelle l'objet enfant contient un objet parent est que lorsque de nouveaux objets enfants, l'objet enfant est d'abord appelé pour construire l'objet enfant, et lors du début de la construction de l'objet enfant, le constructeur de classe parent est d'abord appelé pour construire l'objet parent. En d'autres termes, avant de former un objet enfant, l'objet parent est toujours formé en premier, puis compléter lentement les attributs dans l'objet enfant. Pour un contenu spécifique, voir "Réécrivez Super () de la méthode de construction pendant l'héritage".
Une sous-classe a non seulement des membres de la classe parent, mais a également ses propres membres uniques, tels que ses propres méthodes et ses propres variables de membres. Il est facile de comprendre que les noms des membres dans les sous-classes et les classes de parents sont différents, mais ils peuvent également être du même nom. S'il existe des méthodes du même nom héritées de la classe parent dans la sous-classe , comme la classe parent qui a la méthode EAT () et que la classe enfant a également la méthode EAT (), alors cela peut être une réécriture de la méthode (voir ci-dessous). Si les variables membre dans la sous-classe et les variables membre de la classe parent ont le même nom, elles sont indépendantes les unes des autres . Par exemple, la classe Parent a un attribut de nom, et la sous-classe définit également un attribut de nom lui-même, qui est autorisé car il peut être appelé en utilisant ceci et super respectivement.
L'utilisation étend le mot-clé lors de l'héritage de classes. En héritage, Java n'autorise que l'héritage d'une classe parent.
classe de classe {String name; en âge; void Eat () {System.out.println ("manger ...");} void sleep () {System.out.println ("Sleep ...");}} La classe Student étend la personne {int étudiantId; Étudiant (int id, nom de chaîne, int age) {this.name = name; this.age = âge; this.studentid = id; } void Study () {System.out.println ("Studing ...");}} public class hériter {public static void main (String [] args) {Student S1 = New Student (1, "Malongshuai", 23); System.out.println (S1.Studentid + "," + S1.name + "," + S1.age); s1.eat (); S1.Sleep (); S1.Study (); }}L'exemple d'exemple ci-dessus basé sur le Java ClassPath ClassPath et le package est tout le contenu que je partage avec vous. J'espère que vous pourrez vous faire référence et j'espère que vous pourrez soutenir Wulin.com plus.