Nombramiento del paquete
Los nombres de los paquetes deben evitar conflictos con otros paquetes, por lo que elegir un nombre que sea significativo y único es un aspecto importante del diseño de paquetes. Sin embargo, los programadores de todo el mundo están desarrollando paquetes, y no hay forma de saber quién usó qué nombre del paquete, por lo que elegir el único nombre del paquete es un problema. Si determinamos que un paquete solo se usa dentro de nuestra organización, podemos tener un árbitro interno para garantizar que no haya conflicto de nombre entre los proyectos.
Pero para todo el mundo, este enfoque no es práctico. Los identificadores de paquetes son todos nombres simples y una mejor manera de garantizar que el nombre del paquete sea usar un nombre de dominio de Internet. Si la empresa en la que estamos trabajando es Magic.lnc y el nombre de dominio de la compañía es Magic C.com, entonces la declaración del paquete de atributos debería ser:
paquete com.magic.attr; Tenga en cuenta que los elementos constituyentes del nombre de dominio aquí están organizados en orden inverso del nombre de dominio convencional.
Si adoptamos este idioma, los nombres de los paquetes que usamos no entrarán en conflicto con los de nadie más, excepto por el posible conflicto dentro de nuestra organización. Si de hecho hay un conflicto dentro de nuestra organización (probablemente una gran empresa), entonces podemos usar nombres de dominio más específicos para calificar aún más. Muchas grandes empresas tienen subdominios internos, como East y Europa, que pueden usarse para calificar aún más el nombre del paquete:
paquete de maíz.magic.japan.attr;
El uso de esta solución puede hacer que el nombre del paquete sea muy largo, pero es relativamente seguro. Los programadores que usan esta técnica no elegirán el mismo nombre del paquete, y los programadores que no usan esta técnica no elegirán el nombre que usamos.
Acceso al paquete
Al declarar la accesibilidad de las clases de nivel superior y las interfaces de nivel superior en los paquetes, hay dos opciones: acceso al paquete (paquete) y acceso público (público). Se puede acceder a las clases o interfaces modificadas con público mediante un código fuera de paquete, mientras que los tipos no decorados con público tienen alcance del paquete: se puede acceder a ellos por otros códigos en el mismo paquete; Pero están ocultos para códigos fuera de paquete, incluso en códigos de subpackage. Al declarar tipos, solo debemos declarar aquellos tipos que otros programadores deben usar como público y ocultar aquellos tipos que pertenecen a los detalles de implementación del paquete. Esta tecnología nos proporciona una gran flexibilidad, y dado que los programadores no confían en este tipo de detalles de implementación a los que no pueden acceder, podemos cambiarlos libremente cuando queremos cambiar los detalles de implementación.
Los miembros de la clase que no se declaran como públicos, protegidos o privados pueden acceder directamente a cualquier código dentro del paquete, pero que están ocultos desde fuera del paquete. En otras palabras, el modificador de acceso predeterminado es el "paquete", con la excepción de los miembros de la interfaz, y su modificador de acceso predeterminado es "público".
Los campos o métodos que no se declaran privados dentro de un paquete pueden acceder a todos los demás código en ese paquete, por lo que las clases en el mismo paquete se consideran "amigables" o "confiables". Esto nos permite definir un marco de aplicación que combina código predefinido y código de marcador de posición, donde el código del marcador de posición se anula por una subclase de la clase Framework. Los códigos predefinidos pueden usar modificadores de acceso al paquete para que otros códigos de colaboración dentro del paquete puedan acceder directamente a ellos, pero para los usuarios fuera de paquete, estos códigos son inaccesibles. Sin embargo, los subpackages de los paquetes donde se encuentran estos códigos no son confiables y viceversa. Por ejemplo, el código modificado con el modificador de acceso al paquete en el paquete DIT no se puede acceder por el código en su paquete infantil dit.dat, y viceversa.
Por lo tanto, cada tipo define tres contratos diferentes:
Accesibilidad y método de cobertura
Solo los métodos accesibles en las superclase se pueden sobrescribir en subclases. Si no se puede acceder a un método en la superclase, el método no se puede anular en la subclase incluso si el método en la subclase tiene el mismo nombre que el método. Cuando se llama a un método en tiempo de ejecución, el sistema considera su accesibilidad y, por lo tanto, determina qué implementación se está ejecutando.
El siguiente ejemplo especialmente construido se explica más claramente. Supongamos que declaramos una clase de base abstracta en el paquete P1:
Paquete P1; {Ab abab abab clase abstract abstractbase private void pri () {print ("stractbase.pri ()"):} void pac () {print ("stractbase.pac ()");} protegido void pro () {print ("stractbase.pro ()");} public void pub () {print ("stractBase.pub (); show () pri (); pac (); pro(); pub(); }}En esta clase, definimos 4 métodos, cada uno con un modificador de acceso diferente, y el cuerpo del método solo se identifica. El método muestra estos 4 métodos en el objeto actual a su vez. Al aplicar este método a diferentes objetos de subclase, puede explicar qué implementación de estos métodos se llama.
Ahora, definimos la clase de concretel, que extiende la clase de base de abstracto, pero se encuentra en el paquete P2:
Paquete P2; import p1.Abstractbase public class Concretel extiende AbstractBase {public void pri () {print ("Concretel.pri ()");} public void pac () {print ("concretel.pac ()");} public void pro () {print ("Concretel.pro ()");} public void pub () {print ("Concretel.pub ()");}}Los 4 métodos en la superclase se redeclaron en esta clase y sus implementaciones se cambian, lo que informa que pertenecen a la clase Con-Cretel. Al mismo tiempo, sus derechos de acceso se han cambiado a público para que otro código acceda. Ejecutar el siguiente código
nuevo concretel (). show ():
Se generará la siguiente salida:
AbstractBase.pri () AbstractBase.pac () Concretel.pro () Concretel.pub ()
Debido a que no se puede acceder al método privado PRI mediante subclases (u otras clases), el método de exposición siempre llama a la implementación del método PRI en la clase de base Abstract. No se puede acceder al método PAC con permisos de acceso al paquete en la clase Abstract Base por concretel, por lo que la implementación del método PAC en la clase de concretel no puede anular la definición en la clase AbstractBase, por lo que el método de exposición llama al método abstractSbase.pac. El método Pro y el método PUB son accesibles en la clase de concretel y también se pueden sobrescribir, por lo que el método de exposición llama a la implementación de estos dos métodos en la clase de concretel.
Siga nuestra clase de significado de pie concrete2 para extender el concretel de clase, y luego lo colocamos en el mismo paquete P1 que la clase de base de resúmenes ':
Paquete P1; import p2.Concretel public class Concrete2 extiende Concretel {public void pri () {print ("concrete2.pri ()");} public void pac () {print ("concrete2.pac ()");} public void pro () {print ("Concrete2.pro ()");} Public Void Void Void Void Pub () {print ("" ConcRete ("); }Debido a que los métodos en el concretel tienen derechos de acceso público, se puede acceder en concreto2, y cada método en concrete2 cubre sus métodos correspondientes por separado. Además, dado que Concrete2 y AbstractBase están en el mismo paquete, también se puede acceder al método AbstractBase.pac en concrete2, y el método concrete2.pac se puede anular. Llame al método de programa en el objeto Concrete2, y el resultado de impresión es el siguiente:
AbstractBase.pri () concrete2.pac () concrete2.pro () concrete2.pub ()
Finalmente, definimos la clase Concrete3 para extender la clase Concrete2 y lo colocamos en el paquete P3:
Paquete P3 Importación P1.Concrete2; public class Concrete3 extiende Concrete2 {public void pri () {print ("concrete3.pri ()");} public void pac q {print ("concrete3.pac ()");} public void pro () {print ("concrete3.pro ()");} public void pub () {print ("Concrete3.pub ()"); Objeto Concrete3, y el resultado de impresión es el siguiente: AbstractBase.pri () Concrete3.pac () Concrete3.pro () Concrete3.pub ()Aquí el método concrete3.pac parece que anula el método inaccesible abstractBase.pac, pero de hecho, el método concrete3.pac anula el método concrete2.pac, y el método concrete2.pac anula el método abstractBase.pac, SO método.pac anula indirectamente el método abstractBase.pac. Al redecar el método PAC en clase Concrete2 como que tiene permisos de acceso público, cualquier subclase puede acceder y sobrescribirse. '