Está en la página 1de 8

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
explicación simple para poder entender la declaración de paquetes. 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 directorio. 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 múltiples 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 comentario de múltiples líneas, con la diferencia
de que empiezan con diagonal oblicua seguida de dos asteriscos (/**), finalizan 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 programas 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, algunos 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 al menos 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 ejecución 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 funciones.
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;

También podría gustarte