Dénomination du package
Les noms de packages doivent éviter les conflits avec d'autres packages, donc choisir un nom à la fois significatif et unique est un aspect important de la conception des packages. Cependant, les programmeurs du monde entier développent des packages, et il n'y a aucun moyen de savoir qui a utilisé le nom du package, donc choisir le seul nom de package est un problème. Si nous déterminons qu'un package n'est utilisé que dans notre organisation, nous pouvons avoir un arbitre interne pour garantir qu'il n'y a pas de conflit de nom entre les projets.
Mais pour le monde entier, cette approche n'est pas pratique. Les identifiants de package sont tous des noms simples et une meilleure façon de s'assurer que le nom du package consiste à utiliser un nom de domaine Internet. Si l'entreprise dans laquelle nous travaillons est Magic.lnc et que le nom de domaine de l'entreprise est Magic C.com, alors la déclaration du package d'attribut devrait être:
package com.magic.attr; Notez que les éléments constituants du nom de domaine ici sont organisés dans l'ordre inverse du nom de domaine conventionnel.
Si nous adoptons cet idiome, les noms de packages que nous utilisons ne seront en conflit avec personne d'autre que pour le conflit possible au sein de notre organisation. S'il existe en effet un conflit au sein de notre organisation (probablement une grande entreprise), nous pouvons utiliser des noms de domaine plus spécifiques pour être qualifiés. De nombreuses grandes entreprises ont des sous-domaines internes, comme l'Est et l'Europe, qui peuvent être utilisés pour qualifier davantage le nom du package:
Package Corn.magic.japan.attr;
L'utilisation de cette solution peut rendre le nom du package très long, mais il est relativement sûr. Les programmeurs utilisant cette technique ne choisiront pas le même nom de package, et les programmeurs qui n'utiliseront pas cette technique ne choisiront pas le nom que nous utilisons.
Accès aux forfaits
Lorsque vous déclarez l'accessibilité des classes de haut niveau et des interfaces de niveau supérieur dans les packages, il existe deux options: l'accès à package (package) et l'accès public (public). Les classes ou les interfaces modifiées avec le public sont accessibles par code hors package, tandis que les types non décorés avec le public ont une portée du package: ils sont accessibles par d'autres codes dans le même package; Mais ils sont cachés pour les codes hors package, même dans les codes de sous-package. Lors de la déclaration des types, nous ne devons déclarer ces types que les autres programmeurs doivent utiliser en tant que public et masquer ces types qui appartiennent aux détails d'implémentation du package. Cette technologie nous offre une grande flexibilité, et comme les programmeurs ne s'appuient pas sur ces types de détails d'implémentation auxquels ils ne peuvent pas accéder, nous pouvons les modifier librement lorsque nous voulons modifier les détails de l'implémentation.
Les membres de la classe qui ne sont pas déclarés publics, protégés ou privés sont accessibles directement par un code à l'intérieur du package, mais sont cachés de l'extérieur du package. En d'autres termes, le modificateur d'accès par défaut est "package", à l'exception des membres de l'interface, et leur modificateur d'accès par défaut est "public".
Les champs ou méthodes qui ne sont pas déclarés privés dans un package sont accessibles par tous les autres code de ce package, de sorte que les classes du même package sont considérées comme "amicales" ou "de confiance". Cela nous permet de définir un cadre d'application qui combine le code prédéfini et le code d'espace réservé, où le code d'espace réservé est remplacé par une sous-classe de la classe Framework. Les codes prédéfinis peuvent utiliser les modificateurs d'accès des packages afin que d'autres codes collaboratifs dans le package puissent y accéder directement, mais pour les utilisateurs hors package, ces codes sont inaccessibles. Cependant, les sous-packages des packages où se trouvent ces codes ne sont pas fiables et vice versa. Par exemple, le code modifié avec le modificateur d'accès à package dans le package DIT ne peut pas être accessible par le code dans son package enfant Dit.dat, et vice versa.
Par conséquent, chaque type définit trois contrats différents:
Méthode d'accessibilité et de couverture
Seules les méthodes accessibles dans les superclasses peuvent être écrasées dans les sous-classes. Si une méthode dans la superclasse ne peut pas être accessible, la méthode ne peut pas être remplacée dans la sous-classe même si la méthode de la sous-classe a le même nom que la méthode. Lorsqu'une méthode est appelée lors de l'exécution, le système considère son accessibilité et détermine ainsi la mise en œuvre de celui-ci.
L'exemple spécialement construit suivant s'explique plus clairement. Supposons que nous déclarons une classe de base abstraite dans le package P1:
Package P1; {Ab ab Abab Public Résumé Classe AbstractBase Private Void Pri () {print ("StractBase.pri ()"):} void Pac () {print ("StractBase.pac ()");} Protected Void Pro () {print ("Stractbase.pro ()");} public Void pub () {print ("" StractBase.););) void show () pri (); Pac (); pro(); pub(); }}Dans cette classe, nous définissons 4 méthodes, chacune avec un modificateur d'accès différent, et le corps de la méthode ne s'identifie que. La méthode montre à son tour ces 4 méthodes sur l'objet actuel. Lors de l'application de cette méthode à différents objets de sous-classe, il peut expliquer quelle implémentation de ces méthodes est appelée.
Maintenant, nous définissons le Class Concretel, qui étend la classe AbstractBase, mais se trouve dans le package P2:
Package P2; Import p1.abstractbase classe publique CHASSE CONCRETEL étend AbstractBase {public void pri () {print ("Concretel.pri ()");} public void pac () {print ("concretel.pac ()");} public void pro () {print ("concretel.pro ()");} public Void public pub () {print ("Concretel.pub ()");}}Les 4 méthodes de la superclasse sont reclatées dans cette classe et leurs implémentations sont modifiées, qui rapportent qu'elles appartiennent à la classe Con-Cretel. Dans le même temps, leurs droits d'accès ont été transformés en public pour un autre code pour accéder. Exécuter le code suivant
New Concretel (). Show ():
La sortie suivante sera générée:
AbstractBase.pri () AbstractBase.Pac () Concretel.Pro () CONCRETEL.PUB ()
Étant donné que la méthode privée PRI ne peut pas être accessible par des sous-classes (ou d'autres classes), la méthode Show appelle toujours l'implémentation de la méthode PRI dans la classe AbstractBase. La méthode PAC avec les autorisations d'accès à package dans la classe AbstractBase ne peut pas être accessible par Concretel, de sorte que l'implémentation de la méthode PAC dans la classe Concretel ne peut pas remplacer la définition dans la classe AbstractBase, de sorte que la méthode Show appelle la méthode AbstractBase.pac. La méthode Pro et la méthode Pub sont toutes deux accessibles dans la classe Concretel et peuvent également être écrasées, de sorte que la méthode Show appelle la mise en œuvre de ces deux méthodes dans la classe Concretel.
Suivez notre classe Foot Signification Concrete2 pour étendre le Class Concretel, puis nous le mettons dans le même package P1 que la classe AbstractBase ':
Package P1; Import P2.Concretel public class public btete2 étend le concrète {public void pri () {print ("Concrete2.pri ()");} public void pac () {print ("Concrete2.pac ()");} public void pro () {print ("Concrete2.pro ()");} public void pub () {imprime }Étant donné que les méthodes de Concretel ont des droits d'accès public, ils sont accessibles dans Concrete2, et chaque méthode dans Concrete2 couvre ses méthodes correspondantes séparément. De plus, puisque Concrete2 et AbstractBase sont dans le même package, la méthode abstractBase.pac est également accessible dans Concrete2, et la méthode Concrete2.pac peut être remplacée. Appelez la méthode Show sur l'objet Concrete2, et le résultat d'impression est le suivant:
AbstractBase.pri () Concrete2.pac () Concrete2.pro () Concrete2.pub ()
Enfin, nous définissons la classe Concrete3 pour étendre la classe Concrete2 et la mettons dans le package P3:
package P3 Importer P1.Concrete2; classe publique Concrete3 étend le béton2 {public void pri () {print ("concret3.pri ()");} public void pac q {print ("concrete3.pac ()");} public void pro () {print3.pre3.pro () ");} public void pub () {imprimer (" concret3.pub ();); Concrete3 Objet, et le résultat de l'impression est le suivant: abstractBase.pri () Concrete3.pac () Concrete3.pro () Concrete3.pub ()Ici, la méthode Concrete3.pac semble remplacer la méthode inaccessible abstractbase.pac, mais en fait, la méthode Concrete3.pac remplace la méthode concrete2.pac, et la méthode Concrete2.pac remplace la méthode abstractbase.pac, donc la méthode concrete3.pac remplace indirectement la méthode abstractbase.pac. En redémarrant la méthode PAC dans la classe Concrete2 comme ayant des autorisations d'accès public, il peut être accessible et écrasé par toute sous-classe. '