Programación orientada a objetos: métodos
Ya hemos hablado de los tipos en Java y en nuestro ejemplo de la Granja hemos creado una clase con tres atributos, pero saltándonos todas las reglas de un buen diseño orientado a objetos no le hemos añadido funcionalidad alguna a la clase. Seguimos con nuestro curso de programación, en este artículo vamos a implementar la funcionalidad de nuestra clase Granja.
En Java la funcionalidad se implementa a través de los denominados métodos, aunque muchas veces llamados funciones. Para crear un método debemos primero antes de meternos en cómo se hace pensar que es lo que va hacer, para ello simplemente empezamos poniéndole un nombre descriptivo, que nos indique simplemente con su nombre que es lo que hace.
Para introducirlo mediante un ejemplo vamos a crear un método que saque por consola el nombre de la Granja, es decir, que imprima por pantalla el contenido del atributo “nombre”. Creamos el método añadiendo:
void imprimirNombre(){
System.out.println("El nombre de la granja es: "+nombre);
}
Estructura de un método
Vamos a describir que es lo que hemos hecho. Primero tenemos que saber cómo se estructura de un método. Se divide en dos partes: cabecera y cuerpo, por ahora nos centraremos en la cabecera. Podemos analizar el método de la siguiente forma:
tipo de elemento devuelto , nombre del método (parámetros) {
acciones que realizará el método, cuerpo del método
}
En el ejemplo vemos que el tipo es “void” el método void se asigna cuando, y lo explico de forma sencilla aunque no sea del todo correcto, el método no queremos que devuelva nada, simplemente que haga unas operaciones. Si queremos que un método los devuelva algo a la hora de invocarlo se debe guardar en algún sitio la información que nos devuelve casi siempre en una variable o atributo de igual tipo que lo que devuelva. Por ejemplo:
int devuelve0(){
return 0;
}
Este método tan sencillo nos devolverá un 0 al invocarlo y debemos declarar una variable donde recoger la información que nos devuelve:
int cero = devuelve0();
Parámetros
Los parámetros sirven para enviarle información adicional al método para que realice las operaciones. Por ejemplo este método saca por consola el nombre pasado por parámetro:
void nombre(String nombre){
System.out.println(nombre);
}
Tenemos que tener en cuenta que por convenio los métodos que escribamos en Java los escribimos con un nombre que sea representativo y la primera letra en minúsculas.
Implementación de un método
La implementación de un método consiste en desarrollar el algoritmo y escribirlo utilizando operadores y reglas matemáticas además de unas estructuras donde guardar esa información. En Java estas reglas matemáticas están basadas en la lógica condicional y los bucles así como operadores aritméticos y lógicos.
Operadores de Java
En la siguiente tabla podemos ver un resumen de los operadores mas habituales en Java:
Lógica condicional
La lógica condicional simplemente se basa en comprobar si una condición es cierta, ejemplos:
if (5 > 4)
System.out.println("5 es mayor que 4 ¡Que novedad!");
La anterior es la expresión más sencilla, si se cumple, se hace algo, si no se cumple no se hace nada.
if (5 < 3)
System.out.println("5 es menor que 3 ¿De verdad?");
else {
System.out.println("5 es mayor que 4 ¡Que novedad!");
}
La expresión anterior es como la otra, evalúa la expresión, pero si es falsa se hace otra cosa. En esta expresión siempre se realizará una de las dos opciones, o bien ... si no se cumple entonces .... .
Por último podemos anidar las condiciones:
if (5 > 4)
if (5 < 6) {
System.out.println("5 es mayor que 4 y menor que 6 ¡Que novedad!");
} else {
System.out.println("mmmmm ¿De verdad?");
}
o bien podemos añadir una expresión conjunta:
if (5 > 4 && 5 < 6)
System.out.println("5 es mayor que 4 y menor que 6 ¡Que novedad!");
else
System.out.println("mmmmm ¿De verdad?");
Este última caso puede no ser posible si queremos que entre las dos comprobaciones se haga algo:
if (5 > 4) {
System.out.println("5 es mayor que 4 ¡Que novedad!");
if (5 < 6) {
System.out.println("5 es mayor que 4 y menor que 6 ¡Que novedad!");
} else {
System.out.println("mmmmm ¿De verdad?");
}
}
Bucles
Los bucles sirven realizar una operación hasta que una condición se cumpla, por ejemplo recorrer una estructura hasta que leer y hacer algo con todos los datos almacenados en la estructura. Vamos a distinguir podemos distinguir:
Bucle for
for (inicialización, expresionBooleana, incremento){
cuerpo;
}
Por ejemplo: el siguiente método saca por pantalla el valor de i que va desde 0 hasta 9.
for (int i= 0; i <10; i++){
System.out.println("el valor de i es: " + i);
}
Bucle while
while (expresionBooleana) {
cuerpo;
}
Por ejemplo: el siguiente método saca por pantalla el valor de i que va desde 0 hasta 9.
int i=10;
while ( i < 10 ) {
System.out.println("el valor de i es: " + i);
i++;
}
Bucle do-while
Se comporta igual que el bucle while y for solo que se evalúa la condición al final, lo que implica que al menos se ejecutará una vez.
do {
cuerpo
}while (expresionBooleana);
Por ejemplo: el siguiente método saca por pantalla el valor de i que va desde 0 hasta 9.
int i=10;
do {
System.out.println("el valor de i es: " + i);
i++;
}while ( i < 10 );
Aquí podéis encontrar el codigo código fuente de estos ejemplos.
Ya hemos hablado de las herramientas con las que diseñar nuestro primer método, pero necesitamos una estructura donde guardar la información que generemos para después poder interpretarla. Hay multitud de estructuras en las que guardar información, pero por ahora solo vamos a utilizar una: a lista.
Ejemplo de métodos
Vamos a realizar más métodos para añadirle funcionalidad a nuestra granja. Vamos a crear las siguientes clases y métodos:
Una nueva clase Animal
public class Animal {
String nombre;
int edad;
double peso;
}
Un método para añadir los animales a nuestra lista
Lo primero es crear una lista de animales en nuestra clase Granja, para ello: Importamos la lista que vamos a usar añadiendo al principio del todo el código, antes de declarar la propia clase:
import java.util.ArrayList;
Una vez importado declaramos un nuevo atributo de nuestra clase como:
ArrayList<Animal> animales = new ArrayList<Animal>();
Ya explicaremos más adelante porque le indicamos el tipo Animal al ArrayList, ahora lo que nos interesa es declarar el método:
void añadirAnimal(Animal animal){
animales.add(animal);
}
Cada vez que llamemos a este método y le pasemos un objeto de tipo Animal añadiremos un nuevo objeto de tipo Animal a nuestra lista que estará incluida dentro de nuestro objeto de tipo Granja.
Un método que nos saque por pantalla los animales de la lista
Una vez tenemos animales en nuestra granja debemos tener implementada alguna funcionalidad en nuestra granja que nos permita interactuar con nuestros objetos Animal dentro de nuestro objeto Granja, es decir, tenemos que diseñar un método que nos permita hacer algo con estos animales. Como es un ejemplo sencillo vamos a simplemente sacar los animales de nuestra granja por pantalla.
void muestraAnimales() {
for (int i = 0; i < animales.size(); i++)
System.out.println(animales.get(i).nombre + " con peso "
+ animales.get(i).edad);
}
Con esto ya podemos añadir animales a nuestra granja, el siguiente paso es instanciar nuestra aplicación e incorporar niveles de acceso a nuestra aplicación además de mejorar este clase, por desde el punto de vista del diseño existen numerosos problemas que debemos solucionar.
Para probarlo vosotros mismos podéis usar el código fuente que hemos utilizado para la ocasión.