Definiciones.

Paquete.

Un paquete es un espacio de nombre que organiza un conjunto de clases e interfaces relacionadas. Puede pensar en los paquetes como algo similar a las diferentes carpetas de su ordenador. Puede tener guardadas páginas HTML en una carpeta, imágenes en otra y scripts y aplicaciones en otra distinta. Puesto que un software escrito en el lenguaje de programación Java puede llegar a consistir de cientos o miles de clases individuales, tiene sentido que se organicen las clases e interfaces relacionadas en 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;
import com.makotogroup.*;

Especifique 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:

Convenios de Denominación.

La palabra objetoa menudo se usa como sinónimo de la palabra clase. En sentido estricto, una clase define la estructura de algo de lo cual el objeto es una instancia.

El Listado 1 incluye esta declaración de clase:

accessSpecifier class ClassName {
  accessSpecifier dataType variableName [= initialValue];
  accessSpecifier ClassName([argumentList]) {
    constructorStatement(s)
  }
  accessSpecifier returnType methodName([argumentList]) {
    methodStatement(s)
  }
}

Un accessSpecifier de una clase podría tener varios valores pero, por lo general, es público. Observará otros valores deaccessSpecifier pronto.

Convenios de denominación de clases

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.

Métodos Constructores.

Los constructores le permiten especificar cómo crear una instancia de una clase. 

accessSpecifier ClassName([argumentList]) {
  constructorStatement(s)
}

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.

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.

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 claseporque 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 deLogger, 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. 

Adición de Variables de Clase.

Ahora formalmente definiré cómo agregar variables de clases.

Recuerde que una variable tiene un accessSpecifier, un dataType, un variableName y, opcionalmente, un initialValue. Anteriormente, observó brevemente cómo definir el accessSpecifier y variableName. Ahora verá el dataType que una variable puede tener.

Un dataType puede ser un tipo primitivo o una referencia a otro objeto. Por ejemplo, observe que Age es un int (un tipo primitivo) y Name es una String (un objeto). El JDK viene empaquetado lleno de clases útiles como java.lang.String y aquellos en el paquete java.lang no necesitan ser importados (una cortesía taquigráfica del compilador Java). Pero ya sea que el dataType sea una clase JDK como String o una clase definida por el usuario, la sintaxis es esencialmente la misma.

La Tabla 1 muestra los ocho tipos de datos primitivos que es probable que usted vea regularmente, incluidos los valores predeterminados que los primitivos adquieren si usted no inicializa explícitamente el valor de una variable miembro:

Tabla 1. Tipos de datos primitivos

Tipo	Tamaño	Valor predeterminado	Rango de valores
booleano	n/d	falso	verdadero o falso
byte	8 bits	0	-128 a 127
caract.	16 bits	(sin firmar)	\u0000' \u0000' a \uffff' o 0 a 65535
corto	16 bits	0	-32768 a 32767
int	32 bits	0	-2147483648 a 2147483647
largo	64 bits	0	-9223372036854775808 a 9223372036854775807
flotante	32 bits	0,0	1.17549435e-38 a 3.4028235e+38
doble	64 bits	0,0	4.9e-324 a 1.7976931348623157e+308

Registro Incorporado.

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;
//. . .
Logger l = Logger.getLogger(getClass().getName());

Cuando se llama al método getLogger(), usted pase una String. Por ahora, solo acostúmbrese a pasar al nombre de la clase el código en el que su escritura se encuentra. Desde cualquier método regular (es decir, no estático), el código anterior siempre hará referencia al nombre de la clase y lo pasará al Logger.

Si usted está haciendo una llamada de Logger dentro de un método estático, solo haga referencia al nombre de la clase en la que se encuentre:

Logger l = Logger.getLogger(Person.class.getName());