7/5/18

Java: Declaración de clases, variables y métodos

Declarar clases

Una clase se declara con la siguiente estructura:

class NombreClase{
    // Campos, constructores y declaración de métodos.
}


Lo que aparece precedido por // son comentarios de una sóla línea. También hay comentarios de varias líneas /*Comentario...*/, y comentarios de documentación /**Comentario de documentación...*/.

El espacio entre llaves se llama cuerpo de la clase y contiene todo el código que proporciona el ciclo de vida de los objetos creados a partir de la clase: constructores para inicializar nuevos objetos, declaraciones de los campos que proporcionan el estado de la clase y sus objetos, y métodos para implementar el comportamiento de la clase y sus objetos.

Si la clase declarada es subclase de una superclase la declaración es algo similar a la siguiente:

class SubClase extendes SuperClase{
    ...
    ...
}

 

Si la clase declarada implementa una interfaz, la declaración es similar a la siguiente:

class MiClase implements MiInterfaz{
    ...
    ...
}


Y si la clase declarada es una sublcase de otra que además immplementa una unterfaz su declaración es similar a la siguinte:

class MiClase extends SuperClase implmenets MiInterfaz{

    ...
    ...
}

 
También se pueden agregar modificadores de acceso de forma tal que otras clases puedan o no acceder a la clase que se esta declarando.

La declaración de una clase puede contener una lista de componentes en orden, que es la siguiente:

- Modificadores de acceso.
- Nombre de la clase con la primera letra mayúscula por convención.
- El nombre de la superclase, si es el caso, que extiende la clase que se está declarando precedido de la palabra clave extends.
- Una lista de interfaces separadas por coma que la clase implementa, si es el caso, precedida por la palabra clave implements.
- El cuerpo de la clase delimitado por llaves {}.


La declaración de una clase puede ser más o menos simple dependiendo de la complejidad del modelo que representa y de la relación que tenga con otras clases.

Declarar variables

Hay varios tipos de variables en el lenguaje de programación Java y estos tipos están definidos por el lugar en donde se declara una variable:

- Variables declaradas como miembros de una clase, se llaman campos.
- Variables declaradas dentro de un método o boque de código, se llaman variables locales.
- Variables declaradas en la signatura de un método, se llaman parámetros.

Las declaraciones de campos se componen de tres componenetes, en orden:

1 - Cero o más modificadores de acceso (public, private, pretected).
2 - El tipo del campo (int, float, boolean, char, Object, etc).
3 - El nombre del campo.

 

Modificadores de acceso


Hay tres tipos de modificadores: public, private y pretected:

     public: el campo es accesible desde todas las clases.
     private: el campo es accesible solo dentro de su propia clase.
     protected: el campo es accesible dentro de su propia clase y por las clases derivadas de ésta.

Por principio de encapsulación, es común hacer que los campos sean privados. Esto significa que solo se puede acceder directamente desde la misma clase en que los campos están declarados. Sin embargo, es necesario acceder a los campos. Esto se puede hacer indirectamente agregando métodos públicos que obtienen los valores de campo para las demás clases.

Todas las variables deben ser de un tipo, pueden ser tipos primitivas (int, float, boolean, char, byte, etc.), O pueden ser de tipo referencia como cadenas, matrices y objetos.

Por convención se debe tener en cuanta que:

- La primera letra de un nombre de clase debe estar en mayúscula.
- La primera (o única) palabra en un nombre de método debe ser un verbo.

Declarar métodos

Una declaración de un método típica, en Java, es como la siguiente:

public int sumarEneteros(int num1, int num2){
   
    int resultado = 0;
    suma = num1 + num2;
    return suma;
}


Los únicos elementos necesarios de una declaración de método son el tipo de devolución del método(int en éste caso), el nombre(sumarEnteros), un par de paréntesis, ()(donde declarar parámentros de ser necesario, separadsos por coma si es más de uno) y un cuerpo entre llaves, {}(donde va el código del método).

De manera más general, las declaraciones de método tienen seis componentes, en orden:

Modificadores: públicos, privados o pretected.
El tipo de devolución: el tipo de datos del valor devuelto por el método, o nulo si el método no devuelve un valor.
El nombre del método: las reglas para los nombres de los campos también se aplican a los nombres de los métodos, pero la convención es un poco diferente.
La lista de parámetros entre paréntesis: una lista delimitada por comas de parámetros de entrada precedidos por sus tipos de datos, encerrados entre paréntesis, (). Si no hay parámetros, debe usar paréntesis vacíos.
Una lista de excepciones.
El cuerpo del método, encerrado entre llaves, el código del método, incluida la declaración de variables locales, va aquí.

 

Nombre de un método


El nombre de un método puede ser cualquier identificador legal, las convenciones de código restringen los nombres de los métodos. Por convención, los nombres de métodos deben ser un verbo en minúscula o un nombre de varias palabras que comienza con un verbo en minúscula, seguido de adjetivos, sustantivos, etc. En nombres de varias palabras, la primera letra de cada una de las palabras segunda y siguientes debe estar en mayúscula. Por ejemplo:

correr
caminar
caminarRapido
comer
dormir

 

Sobrecarga de métodos


El lenguaje de programación Java soporta sobrecarga de métodos, y puede distinguir entre métodos con distintas signaturas. Esto significa que varios métodos pueden tener el mismo nombre dentro de una clase siempre que tengan diferente lista de parámetros.

Supongamos que tiene una clase que puede usar caligrafía para dibujar varios tipos de datos (cadenas, enteros, etc.) y que contiene un método para dibujar cada tipo de datos. Es engorroso utilizar un nuevo nombre para cada método, por ejemplo, dibujarString, dibujarInteger, dibujarFloat, etc. En el lenguaje de programación Java, puede usar el mismo nombre para todos los métodos de dibujo, pero pasar una lista de argumentos diferente a cada método. Por lo tanto, la clase de dibujo de datos podría declarar cuatro métodos denominados dibujar, cada uno de los cuales tiene una lista de parámetros diferente.

public class DibujarDatos {
    ...
    public void dibujar(String s) {
        ...
    }
    public void dibujar(int i) {
        ...
    }
    public void dibujar(double f) {
        ...
    }
    public void dibujar(int i, double f) {
        ...
    }
}


Los métodos sobrecargados se diferencian por el número y el tipo de argumentos pasados al método. No puede declarar más de un método con el mismo nombre y el mismo número y tipo de argumentos, porque el compilador no puede diferenciarlos. El compilador no tiene en cuenta el tipo de devolución al diferenciar los métodos, por lo que no puede declarar dos métodos con la misma firma, incluso si tienen un tipo de devolución diferente.