Empaquetado de objetos
El lenguaje Java le permite elegir los nombres de sus
objetos, tales como Account, Person o LizardMan. En ocasiones, puede que
termine usando el mismo nombre para expresar dos conceptos ligeramente
diferentes. Esto se llama una colisión de nombres y sucede con
frecuencia. El lenguaje Java usa paquetes para resolver estos
conflictos.
Un paquete Java es un mecanismo para proporcionar un espacio
de nombres: un área encapsulada en donde los nombres son únicos pero, fuera de
esa área, puede que no lo sean. Para identificar una construcción de manera
única, debe calificarla totalmente al incluir su espacio de nombres.
Los paquetes también le dan una buena forma para construir
aplicaciones más complejas en unidades diferenciadas de funcionalidad.
Definición de paquete
Para definir un paquete, use la palabra clave paquete
seguida por un nombre de paquete legal y termina con un punto y coma. A menudo,
los nombres de los paquetes se separan con puntos y siguen este plan de
facto:
package orgType.orgName.appName.compName;
Esta definición de paquete se divide de la siguiente manera:
- orgType es el tipo de organización, tales como com, org o net.
- orgName es el nombre del ámbito de la organización, tales como makotogroup, sun o ibm.
- appName es el nombre de la aplicación, abreviado.
- compName es el nombre del componente.
El lenguaje Java no lo obliga a seguir este convenio de
paquetes.
Sentencias de importación
Una sentencia de importación le comunica al compilador Java
dónde encontrar las clases a las que usted hace referencia dentro de su código.
Cualquier objeto no trivial usa otros objetos para alguna funcionalidad y la
sentencia de importación es cómo usted le comunica al compilador Java sobre
ellos.
Una sentencia de importación normalmente luce así:
import ClassNameToImport;
Especificando la palabra clave importación seguida de la
clase que quiere importar seguida de un punto y coma. El nombre de la clase
debería estar completamente calificado, es decir, debería incluir su paquete.
Para importar todas las clases dentro de un paquete, puede
poner .* después del nombre del paquete. Por ejemplo, esta sentencia importa
cada clase en el paquete com.makotogroup:
import com.makotogroup.*;
Sin embargo, importar todo un paquete puede hacer que su
código sea menos legible, por lo tanto recomiendo que importe solo las clases
que necesite.
Convenios de denominación de clases
Se puede denominar a las clases prácticamente como quiera
pero el convenio es usar bicapitalización: comenzar con una letra en
mayúscula, usar mayúscula en la primera letra de cada palabra concatenada y
dejar todas las otras letras en minúscula. Los nombres de las clases deberían
contener solo letras y números. Adherirse a estas guías asegurará que su código
sea más accesible para otros desarrolladores que siguen los mismos convenios.
Las clases pueden tener dos tipos de miembros: variables
y métodos.
Listado 3. Sintaxis de la declaración del constructor
accessSpecifier ClassName([argumentList]) {
constructorStatement(s)
}
Los constructores son opcionales
Los constructores le permiten especificar cómo crear una
instancia de una clase.
Si usted no proporciona un constructor, el compilador
proporcionará uno por usted, denominado el constructor predeterminado (o sin
argumento). Si usted proporciona un constructor que no sea un constructor
sin argumento (o no-arg), el compilador no generará uno por usted.
El accessSpecifier de un constructor es el mismo que
el de las variables. El nombre del constructor debe coincidir con el nombre de
la clase. Por lo tanto, si llama a su clase Person, entonces el nombre del
constructor también debe ser Person.
Para cualquier constructor que no sea el constructor
predeterminado, usted pasa una argumentList, que es una o más de:
argumentType argumentName
Los argumentos en una argumentList se separan con
comas y dos argumentos no pueden tener el mismo nombre. El argumentType
es un tipo primitivo u otro tipo de clase (lo mismo que sucede con los tipos de
variables).
Los constructores
son opcionales
Si usted no proporciona un constructor, el compilador
proporcionará uno por usted, denominado el constructor predeterminado (o sin
argumento). Si usted proporciona un constructor que no sea un constructor
sin argumento (o no-arg), el compilador no generará uno por usted.
Métodos estáticos y de instancia
Hay generalmente dos tipos de métodos (no constructores):
los métodos de instancia y los métodos estáticos. Los métodos de
instancia dependen del estado de una instancia de objeto específico por sus
comportamientos. Los métodos estáticos también se denominan a veces métodos
de clase porque sus comportamientos no dependen del estado de ningún objeto
en particular. El comportamiento de un método estático sucede al nivel de la
clase.
Los métodos estáticos se usan en gran medida por utilidad;
puede considerarlos como un modo de tener métodos globales (à la C)
mientras mantiene el código mismo agrupado con la clase que lo necesita.
Por ejemplo, en todo este tutorial usará la clase de Logger
JDK para enviar información a la consola. Para crear una instancia de clase de Logger,
no cree una instancia de clase de Logger; en cambio, invoque un método estático
llamado getLogger().
La sintaxis para invocar un método estático es diferente de
la sintaxis usada para invocar un método para una instancia de objeto. También
use el nombre de la clase que contiene el método estático, como se muestra en
esta invocación:
Logger l =
Logger.getLogger("NewLogger");
Por lo cual, para invocar un método estático, no necesita
una instancia de objeto, solo el nombre de la clase.
Registro incorporado
Antes de avanzar más en la codificación, necesita saber cómo
sus programas le dicen lo que están haciendo.
La plataforma Java incluye el paquete java.util.logging, un
mecanismo de registro incorporado para juntar información de programa en una
forma legible. Los registradores son entidades con nombres que usted crea por
medio de una llamada de método estático a la clase Logger, como la siguiente:
import
java.util.logging.Logger;
