Los métodos nos permiten realizar acciones con los objetos de una clase, también se dice que representan el comportamiento que pueden tener los objetos.
En general, podemos mencionar que existen los siguientes tipos de métodos:
- Recuperación del estado del objeto (información guardada en los atributos).
- Modificación del estado del objeto (información guardada en los atributos).
- Mensajes enviados al objeto para solicitar que realicen determinada acción (comportamiento del objeto).
- Creación, construcción o instanciación de un objeto de una clase en la memoria de la computadora.
Hay que tener en cuenta que hay métodos que regresan algún valor que puede utilizarse para realizar cálculos (conocidos como funciones en otros lenguajes o aplicaciones como una hoja de cálculo) y algunos que simplemente se ejecutan sin tener un valor de retorno (también conocidos como funciones sin valor de retorno, procedimientos, subprocesos o subrutinas en otros lenguajes).
Los identificadores de los métodos siguen las mismas reglas de los atributos: se escriben con minúscula y si tienen varias palabras se ocupará la nomenclatura de capitalización (cada palabra inicia con mayúscula, excepto el primer carácter del identificador).
A diferencia de los atributos, a los métodos debe agregarse una lista de parámetros al final que es el medio de comunicación con el exterior, los paréntesis se escriben aunque no haya parámetros. Otra diferencia respecto a los atributos que son generalmente «sustantivos» en el caso de los métodos se usan «verbos» para indicar acciones.
Las sugerencias de nomenclatura anteriores pueden expresarse con el siguiente diagrama sintáctico para la escritura de los identificadores. Puede observarse que lleva las mismas reglas de un identificador de atributo, sin embargo siempre aparecerán paréntesis de apertura y cierre después del identificador.
Algunos ejemplos pueden ser: obtenerPromedio(), asignarUnNuevoValor(), dibujar(), avanzar(), detener(), terminar(), etc.
En Java, la firma o encabezado (como comúnmente se conoce en otros lenguajes) está integrado por las siguientes partes:
- modificador de acceso,
- otros modificadores,
- tipo de dato de retorno,
- el identificador, y
- • el tipo de dato de los parámetros o argumentos de la función.
El diagrama sintáctico que define el encabezado o firma de la función es el siguiente. Aunque el tipo de acceso puede omitirse en la declaración de una clase y se consideraría como público, en general se sugiere siempre escribirlo para que sea clara la visibilidad del método.
Los dos últimas partes de la firma son muy importantes (el identificador de método y los tipos de datos de los argumentos) al considerar que pueden existir métodos que tengan el mismo nombre o identificador. Las siguientes declaraciones son válidas para tener dos métodos con el mismo identificador en una misma clase:
public class vehiculo {
public void acelerar () { /* _ */ }
public void acelerar ( double velocidad ) { /* _ */ }
}
Aunque ambos métodos tienen el mismo nombre o identificador, se entiende claramente a qué método te refieres por el tipo de argumentos al hacer cualquiera de las siguientes llamadas:
//...
vehiculo miLambourghini = new Vehiculo();
//...
miLambourghini.acelerar(); // aceleración sin argumentos
miLambourghini.acelerar( 20.0 ); // aceleración con argumento tipo double
}
A esta propiedad se llama overloading o sobrecarga.
Aunque ambos métodos tienen el mismo nombre o identificador, se entiende claramente a qué método te refieres por el tipo de argumentos al hacer cualquiera de las siguientes llamadas:
El cuerpo del método puede ser una sentencia nula (no hace nada), una sentencia simple o varias sentencias. Recuerda que en Java el punto y coma ; es un terminador de sentencia, por lo que si la sentencia es nula no se escribe el punto y coma.
public void caminar() {
// aquí se escribirá el cuerpo del método
public void calcularArea() {
// aquí se escribirá el cuerpo del método
}
Sin embargo, cuando el encabezado incluye un tipo de retorno, la última sentencia que se incluye en el método (para cada rama de ejecución si hay estructuras de control) debe ser la sentencia return:
Algunos ejemplos de métodos con tipo con su sentencia return son:
public double obtenerPromedio() {
// algunas instrucciones por acá
return promedio; // la última sentencia regresa un valor del tipo double
}
public double obtenerArea() {
// algunas instrucciones por acá
return base*altura/2; // la última sentencia regresa un valor del tipo double
}
Getters
Por el principio de encapsulamiento, los datos que se encuentran almacenados en una instancia u objeto de una clase están protegidos del acceso desde el mundo exterior. El mecanismo de acceso para recuperar la información de un atributo almacenado es a partir de un método que responde al verbo “recuperar” u “obtener” en español. Como tiene muchas letras suele utilizarse el verbo en inglés: “get”.
Todas las variables de salida que se implementen en atributos dentro de la clase deben tener un método get, también se le llama «getter». Este verbo get se escribe previo al nombre del atributo, el cual debe capitalizarse (poner la primera letra en mayúsculas). La visibilidad normalmente se define pública (public) para el método, a diferencia del atributo que se mantiene privado (private). El tipo de retorno del método es el mismo que tiene el atributo, ya que el getter permite recuperar el valor del atributo y por ello debe coincidir el tipo de dato regresado con la sentencia return.
Observa la siguiente línea de tiempo para ver cómo se construyen estos métodos en forma general.
1 | Diagrama de clase
2 | Clase en Java
3 | Ubicar atributos
4 | Identificadores
5 | Visibilidad
La función de un getter es proporcionar el valor del atributo al exterior del objeto de forma ordenada, por lo cual la visibilidad es generalmente public. A menos que por la naturaleza del atributo no deba ser expuesto, como por ejemplo una contraseña o un NIP de cajero automático estos se mantendrán ocultos y no será necesario programar un getter.
6 | Tipo de retorno
Se copia el tipo de dato de cada atributo como tipo de retorno de la función:
7 | Cuerpo del método
Se copia el tipo de dato de cada atributo como tipo de retorno de la función:
Para los getters que regresan valores booleanos, en algunos métodos estándar de Java se sustituye el verbo «get» por el verbo «is» para preguntar si es verdadero (true) por cuestiones de darle una mejor lectura al programa.
class ControlDeUsuario {
// Atributos: ------------------------
private boolean visible;
// Métodos: ------------------------
public boolean isVisible() { // getter pero con palabra «is»
return visible;
}
}
Por ejemplo
if( cuadroDeTexto.isVisible() ) // si el control es visible (cuando true)
// ...
if( unPersona.isMayorDeEdad() ) // si es mayor de edad (cuando true)
// ...
Completa los espacios en blanco para completar los getters de las variables de salida.
Ejemplo
public class Triangulo {
// atributos: -----------------------
private double base; // entrada
private double altura; // entrada
private double area; // salida
// métodos: -----------------------
public double getArea() {
return area;
}
}
Atributos calculados
El (segundo) principio de encapsulamiento indica que todos los atributos, y opcionalmente algunos métodos, deben permanecer ocultos al exterior, es decir, deben ser public) para el método, a diferencia del atributo que se mantiene privado (private. En este sentido, cómo colocan los atributos en la definición de la clase pudiera parecer irrelevante para el programador que utiliza una clase desde el exterior, ya que el único medio de comunicación son los métodos (principalmente getters y setters).
Por cuestiones de optimización de espacios en la memoria a veces no es necesario colocar un atributo dentro de la estructura, pero si pudiera darse el caso de “aparentar” que existe ya que es parte de la información que se tiene modelada por el (primer) principio de abstracción de la programación orientada a objetos.
Observa los siguientes códigos que implementan la clase Círculo, y presta especial atención el resaltado en amarillo que se muestra en ambos códigos:
public class Circulo {
private double radio; // entrada
private double area; // salida
public double getRadio() {
return radio;
}
public double getArea() {
return area;
}
public void asignarRadio( doble r ) {
radio = r;
área = Math.PI * Math.pow( radio );
}
}
public class Circulo {
private double radio; // entrada
public double getRadio() {
return radio;
}
public double getArea() {
return Math.PI * Math.pow( radio );
}
public void asignarRadio( doble r ) {
radio = r;
}
}
Si tuvieras el siguiente fragmento de código:
Circulo miCirculo = new Circulo();
miCirculo.asignarRadio( 10 );
System.out.println( miCirculo.getArea() );
Contesta las siguientes preguntas y verifica tus respuestas.
Recomendaciones generales para los getters
Cuando se desea obtener una optimización de espacio de almacenamiento (memoria) o no se requiere tener todos los campos calculados en todo momento por cuestiones de rendimiento (velocidad) o porque se usa poco un atributo, se recomienda colocar campos «calculados» y generar un getter que devuelva el valor de un cálculo dando la apariencia de tener un atributo.
Otra recomendación que es útil atender es generar getters para todos los atributos: entradas, salidas y valores intermedios, siempre que sea posible. Hay algunos atributos que por su naturaleza deben mantenerse siempre ocultos como las contraseñas, serían los únicos casos en los que no habría que colocar getters, en todo los demás considera tener un getter por cada atributo de instancia.
Los getters son generalmente públicos ya que, por el principio de encapsulamiento, todos los atributos deben ser privados. Sin embargo, las constantes de clase se utilizan en muchos casos y no puede modificarse su valor desde el exterior, así que podría convenir tenerlos como públicos sin generar getters.
Setters
De manera análoga a los getters, por el principio de encapsulamiento, los datos que se encuentran almacenados en una instancia u objeto de una clase están protegidos del acceso desde el mundo exterior. El mecanismo de acceso para modificar la información de un atributo almacenado es a partir de un método que responde al verbo “asignar” en español. Como tiene muchas letras suele utilizarse el verbo en inglés: “set”. Coincidentemente, get y set son de tres letras.
Todas las variables de entrada que se implementen con atributos dentro de una clase deben tener un método set, también se le llama «setter». Este verbo set se escribe previo al nombre del atributo, el cual debe capitalizarse (poner la primera letra en mayúsculas). La visibilidad normalmente se define pública (public) para el método, a diferencia del atributo que se mantiene privado (private). Los setters no tienen tipo de retorno y se coloca en su ligar la palabra void.
Los setters pueden tener tres partes:
- Se verifica que el valor que se intenta asignar sea correcto, en términos matemáticos que cumplan con el rango de valores válido para el dato.
- Si se cumple el primer paso, se realiza la modificación del atributo.
- Si se cumplen los pasos anteriores, se verifica y en su caso se modifican atributos interrelacionados con el atributo modificado. Por ejemplo, en un círculo, si se modifica el radio como consecuencia se podrían modificar el perímetro y el área.
Es decir, la función principal de los setters es modificar el valor de un atributo, sin embargo es necesario verificar que los datos asignados sean correctos, y que la modificación del atributo corrija otros atributos en el estado del objeto que garanticen que el objeto se encuentra en un estado consistente, es decir, que la información almacenada en el objeto sea correcta y mantenga el principio de abstracción donde el objeto almacena lo que debe representar.
Observa la siguiente línea de tiempo para ver cómo se construyen estos métodos en forma general.
1 | Diagrama de clase
2 | Clase en Java
3 | Ubicar atributos
4 | Identificadores
Para cada atributo, agrega la palabra set como prefijo, y el nombre del atributo capitalizado. Al menos las variables o atributos de entrada debieran tener un setter para que desde el exterior se pueda proporcionar información al objeto.
No es necesario definir setters para los atributos de salida, sobre todo si no existe una relación directa con los atributos que pudieran afectarse.
5 | Visibilidad
La función de un getter es proporcionar el valor del atributo al exterior del objeto de forma ordenada, por lo cual la visibilidad es generalmente public. A menos que por la naturaleza del atributo no deba ser expuesto, como por ejemplo una contraseña o un NIP de cajero automático estos se mantendrán ocultos y no será necesario programar un getter.
6 | Tipo de retorno y de argumentos
Se copia el tipo de dato de cada atributo como tipo de retorno de la función:
7 | Cuerpo del método
Se copia el tipo de dato de cada atributo como tipo de retorno de la función:
La parte de la verificación la puedes consultar en Verificación de excepciones con estructuras condicionales
Completa los setters para las variables de entrada. No es necesario hacer validaciones antes de modificar o posteriores a haber hecho el cambio del atributo.
Mensaje y comportamiento
Una vez que se garantiza como recuperar información (getters) y cómo modificar los atributos (setters) de un objeto se procede a realizar la codificación del comportamiento del objeto. Los métodos se programan con verbos y suele no incluirse el nombre de la clase. Por ejemplo, en la clase Computadora:
public class Computadora {
public void encenderComputadora();
public void apagarComputadora();
public void ejecutarPrograma( String programa );
}
Debería quedar de esta manera, ya que debe ser obvio que encender() y apagar() se refieren a la Computadora; hay que dejar los identificadores lo más simples que se pueda sin que dejen de ser entendibles:
public class Computadora {
public void encender();
public void apagar();
public void ejecutar( String programa);
}
Fuera de los getters y los setters, se colocan otros métodos dentro del dominio del problema. La primera aproximación como se puede ver en la Codificación a partir del diagrama de clases . Otro tipo de métodos nos permiten comunicarnos con un objeto a partir de mensajes explícitos que el programador le envíe a los objetos o bien que se programen ante eventos de la interfaz de usuario como pasar el mouse encima del objeto o hacer un click (presionar un botón) sobre el mismo.
Hace muchos años, existió un lenguaje de programación llamado LOGO que permitía mover una “tortuga” en un tablero para dibujar. En esta versión reducida las tortugas en un tablero pueden moverse. Como programador, escriba las sentencias necesarias para enviar mensajes a unaTortuga de tipo Tortuga de la posición A a la posición B, evitando tocar la zona de las piedras. Como se puede observar, la tortuga ya se ubica en la posición (4,11) y está viendo hacia la izquierda.