Estructura de una Clase en Java
La estructura de una clase en Java está compuesta por la declaración del paquete, declaración de importación, comentarios, definición de la clase, constantes, variables / atributos, constructores y métodos. Usualmente, todos aparecen en el orden indicado, con excepción de los comentarios que pueden aparecer en cualquier lugar, donde son necesarios. A continuación podemos ver un esquema con esta estructura.
declaración del paquete
declaración de importación
comentarios
definición de la clase
constantes
variables / atributos
constructores
métodos
Declaración del Paquete
Hablaremos sobre paquetes en profundidad en otro artículo, de momento solo daremos una explicacieon simple para poder entender la declaración de plaquetes. El código Java está contenido en paquetes, un paquete puede verse como un directorio, y nosotros podemos tener una jerarquía de paquetes. La declaración de paquetes provee información de en cual paquete o jerarquía de paquetes está contenida una clase.
Si una clase no incluye una declaración de paquetes, significa que está dentro del paquete default. Ahora, imaginemos que tenemos nuestro proyecto ClassStructure, y tenemos el directorio llamado org, dentro de este directorio el directorio jduchess. Dentro del directorio jduchess tenemos la clase Structure, podemos verlo en la siguiente imagen:
La estructura de la declaración de un paquete es: palabra reservada package seguida de la ruta del paquete delimitada por puntos. Nuestra declaración del paquete se puede ver como la estructura del direcotrio. Por ejemplo, la declaración del paquete de nuestra clase Structure sería como se muestra a continuación:
package org.jduchessgt;
Declaración de Importación
Con la declaración de importación nosotros podemos incluir otras clases que están contenidas en otros paquetes de nuestro proyecto, o clases contenidas en librerías que vamos a utilizar en la clase actual. La estructura de la declaración de importación es: palabra reservada import seguida de la ruta del packete donde se encuentra la clase delimitado por punto, finalmente un punto extra seguido del nombre de la clase. Por ejemplo, imaginemos que tenemos la clase Library.java que se encuentra en el paquete org.libraries, la declaración de importación sería:
import org.libraries.Library;
También podemos importar todas las clases que se encuentran contenidas en un paquete. Para poder realizar esta acción en vez de indicar el nombre de la clase, como Library de nuestro ejemplo anterior, utilizamos el símbolo * (asterisco) para especificar que importaremos todas las clases contenidas en el paquete. El resultado se vería como el siguiente:
import org.libraries.*;
Comentarios
Los comentarios son parte de nuestro código, pero no son código ejecutable, eso significa que el compilador los ignorará. Los utilizamos para proveer explicaciones o información sobre nuestro código. Existen tres tipos de comentarios:
Comentarios de una Línea
Empiezan con dos barras oblicuas (//), son típicamente utilizadas en comentarios ubicados al final de la línea de código.
// This is single line comment
Comentarios de Multiples Líneas
Empiezan con una barra oblicua seguida de asterisco (/*) y terminan con un asterisco y una barra oblicua (*/). Los utilizamos para proveer explicaciones o información más extensa. Podemos ver comentarios de multiples líneas de la siguiente forma:
/* This is a multiple line comment We can have more than one line. */ /* * Sometimes multiple line comments use This * notation, to show them in a uniform way. */
Comentarios Javadoc
Son comentarios especiales que sirven para crear documentación de API en un conjunto de páginas HTML, que se pueden auto generar con IDEs como IntelliJ, Netbeans o eclipse. En ellos se describe información importante sobre clases, métodos o incluso constantes, como el autor, desde que versión fueron agregados, descripción de parámetros.
Los comentarios Javadoc lucen como un comentarios de multiples líneas, con la diferencia de que empiezan con diagonal oblicua seguida de dos asteríscos (/**), finalizancon con asterisco y diagonal oblicua (*/). Por el otro lado utilizan algunas anotaciones específicas dentro del comentario para indicar información o datos importantes para la documentación. A continuación un ejemplo de este tipo de comentarios:
/** * This is a Javadoc comment * @author Mercedes Wyss * @since version x.y.z * @param we declare as many params as a method has * @return used in methods that return a value */
Firma de Clase
Clases son parte del corazón principal de los pagramas Java ya que es un lenguaje de programación orientado a objetos. La firma de clase puede ser un poco compleja. Vamos a definir todos los elementos que pueden estar en ella, algnos son mandatorios y otros opcionales, la estructura completa es:
[Access Modifier] [Non-access Modifier] class ❮Class Name❯ [extends ❮Super Class Name❯]
[implements ❮Interface1 Name❯, ❮Interface2 Name❯, ... ❮InterfaceN Name❯] { }
La estructura base se conforma de los elementos obligatorios, que son: palabra reservada class seguida del nombre de la clase y las llaves, como se muestra a continuación:
class ❮Class Name❯ { }
En java, nuestro código está en archivo .java, y almenos una clase está contenida en esos archivos .java, pero un archivo .java puede contener más de una definición de clase. Cuando uno de esos archivos .java representa una clase, es mandatorio establecer el modificador de acceso de esa clase. Continuando con el ejemplo de la clase Structure, esta estará contenida en nuestro archivo Structure.java que al mismo tiempo está en el paquete org.jduchessgt, vamos a establecer el modificador de acceso como public, lo que nos dejaría una firma de clase de la siguiente forma:
public class Structure { }
Variables / Atributos
Variables o atributos son utilizados para almacenar información que puede cambiar a lo largo de la ejecucieon de nuestro programa. Como en la firma de una clase, tenemos algunos elementos opcionales y otros obligatorios en su definición. La estructura completa es:
[Access Modifier] ❮Data Type❯ ❮Identifier❯ [Initialization]
La definición básica de una variable o atributo está compuesta por el tipo de dato y el nombre de la misma.
double notInitialized;
Podemos declarar varias variables o atributos al mismo tiempo, siempre que sean del mismo tipo de dato.
int var1, var2, var3;
Como la estructura define, también podemos inicializar una variable o atributo al momento de definirla.
String initialized = "Var/field Definition";
Constantes
Constantes son variables cuyo valor nunca cambia. Cuando declaramos una constante de una vez debemos inicializarla. En la definición de una contante también tenemos elementos que son obligatorios y otros opcionales, la estructura completa es:
[Access Modifier] final ❮Data Type❯ ❮Identifier❯ ❮Initialization❯
La declaración de una constante sería:
final int CONSTANT = 10;
Métodos
En otros lenguajes de programación se les conoce como procedimientos y/o funcines. Dado que Java es un lenguaje de programación orientado a objetos, lo que tenemos son métodos, ya que estos definen el comportamiento de un objeto. La interacción entre los métodos define la funcionalidad de toda la aplicación. Al igual que en los demás componentes de la estructura de una clase, en su definición tenemos elementos opcionales y obligatorios. La estructura completa sería la siguiente:
[Access Modifier] [Non-access Modifier | Specifier] ❮Return Type❯ ❮Identifier❯ (❮Parameters list❯)
[throws ❮Exception 1❯, ❮Exception 2❯, ... ❮Exception N❯] { ❮Method Body❯ }
Todas las siguiente son declaraciones válidas de un método:
double getValue(){
return value;
}
public void setValue(double value){
this.value = value;
}
public void withException() throws Exception {
throw new Exception();
}
Constructores
Los constructores son métodos especiales que se ejecutan al momento de crear una instancia. Conservan la misma definición de un método, solo que estos no llevan tipo de dato de retorno, ni un Non-access Modifier. Una característica principal es que deben llamarse igual que la clase. Lo que nos dejaría con una declaración como la siguiente:
[Access Modifier] ❮Class Name❯ (❮Parameters list❯) [throws ❮Exception 1❯,
❮Exception 2❯, ... ❮Exception N❯] { ❮Method Body❯ }
Siguiendo con el ejemplo de la clase Structure, algunas definiciones válidas para los constructores podrían ser:
public Structure() throws Exception {
this.value = value;
throw new Exception();
}
pubic Structure(double value){
this.value = value;
}