Buenas mis queridos fieles,
Si bien en el anterior tema vimos teóricamente y por encima las definiciones de clase y objeto, hoy toca definir y mostrar la sintaxis de los elementos mas fundamentales de las clases; los métodos y atributos. Ademas, crearemos una clase con varios métodos para materializar todos los conceptos.
Atributos
Estos son los datos que conforman la clase. Estos datos se representan en variables, ya sea de datos primitivos o de otros objetos.
No tiene mayor misterio. En un par de temas veremos como controlar la visibilidad y ostros aspectos de estos.
Métodos
Los métodos son estructuras pertenecientes a una clase que nos permiten modularizar las funcionalidades de la clase en bloques de código reutilizables.
Ademas de funcionar como bloques de código, los métodos pueden recibir parapetos (datos) y devolver un único dato.
Sintaxis de declaración
[modificador de acceso*] [static**] [tipo que devuelve] [nombre]([parametro(s)])
{
// Bloque de código.
}
*Los modificadores de acceso básicamente permiten encapsular diferentes elementos para que el programador decida desde donde son accesibles. En los métodos, por defecto (si no se expresa modificador) es public. Nos centraremos en esto en el tema #12.
**static lo veremos también en el tema #12. Por ahora solo creo que es importante aclarar que se puede poner o no.
- Recibir parámetros
Los parámetros que se recibirán se declaran en las paréntesis, y, también se pasaran utilizando las mismas cuando un método sea llamado. Ahora veremos ejemplos.
Antes que nada, aclarar que un método no tiene porque recibir parámetros, se puede llamar vacío, ejemplo de ello es el métodonextInt()de la claseScannerel cual ya hemos utilizado antes.
Declarar método con parámetros
static void printCaracteristicas(String nombre, int edad)
{
System.out.println("Nombre: " + nombre + ", edad: " + edad + " años.");
}
Obviar static y void por ahora.
Llamar método con parámetros
printCaracteristicas("Samuel", 36); // Llama al método y le pasa los valores que pide como parámetro.
- Devolver valores
Los métodos pueden devolver (o no) un único valor el cual puede ser desde un dato primitivo hasta un objeto. Siempre se deberá manifestar el tipo de dato que devolverá el método en la declaración del mismo. En caso de que el método no devuelva ningún dato, se pondrá la palabra clavevoid.
Para devolver el valor usamosreturn, como vimos un poco por encima en el tema de los elementos de control,returnsirve para terminar un método y devolver (o no) un valor al llamador del mismo.
Declarar método y devolver valor
static int suma(int num1, int num2)
{
int resultado = num1 + num2;
return resultado; // El método termina y devuelve el valor de resultado.
}
Como se devuelve un valor int, en la declaración del método se pone int.
Llamar / utilizar el valor que devuelve un método
suma(5, 2); // Devuelve 7.
Este valor se puede utilizar de las siguientes maneras:
int resultado = suma(5, 2); // Guarda el valor que devuelve el método en resultado.
System.out.println("5 + 2 = " + suma(5, 2)); // Imprimir el valor que devuelve un método (pasar a un método el resultado de otro).
También se puede no utilizar el valor que devuelve, en algunos casos nos puede interesar.
Metodo que no devuelve nada
Como ya he mencionado, en la declaración se usa void en vez de el tipo de dato que devuelva.
static void printLogo()
{
System.out.println(" _______. __ __ _______ ______ __ __ __ _____ ");
System.out.println(" / || | | | / _____| / __ \ | | | | /_ | | ____| ");
System.out.println(" | (----`| | | | | | __ | | | | | | | | | | | |__ ");
System.out.println(" \ \ | | | | | | |_ | | | | | | | | | | | |___ \ ");
System.out.println(".----) | | `--' | | |__| | | `--' | | `----.| | | | ___) | ");
System.out.println("|_______/ \______/ \______| \______/ |_______||__| |_| |____/ ");
}
}
Por si a alguien le interesa crear frases en arte ascii: Text to ASCII Art Generator (TAAG) .
Y para llamarlo, simplemente:
printLogo();
Método main
A propósito, ¿Alguien se ha preguntado porque hasta ahora hemos creado todos nuestros programas dentro de un método llamado main que recoge el parámetro String args[]?
El método main es el método principal de una (o mas) clases. Cuando tu ejecutas una clase (~$ java MiClase) lo que se ejecuta es el método main de la misma, los demás métodos solo podrán ejecutarse si son llamados desde el método principal.
Vale, ¿Y lo de String args[]?
Pues este parámetro no es mas que un array de objetos String. Esto sirve por si a la hora de ejecutar por comandos la clase queremos pasar algún parámetro. Por ejemplo:
~$ java MiClase [param1] [param2] ... [param]
Los parametros se separan con espacios.
Si queremos pasar como parametro una cadena que contiene espacios, usamos comillas dobles:
~$ java MiClase "Hola mundo" 1 dos
Los parametros se guardaran en el array args[] de la siguente manera:
args[0] // Devuelve "Hola mundo".
args[1] // Devuelve "1".
args[2] // Devuelve "dos".
Ejemplo practico de uso de métodos
Operaciones.java
/**
* Clase para probar metodos.
* Desde el método principal (main) se llama a los demás métodos.
*/
public class Operaciones
{
/*Método principal*/
public static void main(String[] args)
{
// Declarar e inicializar los números que se usaran para las operaciones.
int num1 = 10;
int num2 = 5;
int suma = sumar(num1, num2); // Utiliza el método sumar() para conseguir la suma entre num1 y num2.
System.out.println(num1 + " + " + num2 + " = " + suma); // Imprime la suma.
System.out.println(num1 + " - " + num2 + " = " + restar(num1, num2)); // Utiliza el metodo restar() para conseguir la resta entre num1 y num2 e imprime el resultado.
System.out.println(num1 + " x " + num2 + " = " + multiplicar(num1, num2)); // Utiliza el metodo multiplicar() para conseguir la multiplicación entre num1 y num2 e imprime el resultado.
System.out.println(num1 + " / " + num2 + " = " + dividir(num1, num2)); // Utiliza el metodo dividir() para conseguir la división entre num1 y num2 e imprime el resultado.
// Utiliza el valor booleano que devuelve el método esPar() para imprimir si num1 es o no es par.
if (esPar(num1))
{
System.out.println(num1 + " es par.");
}
else
{
System.out.println(num1 + " es impar.");
}
}
/**
* Suma dos números enteros.
* @param a (int), el primer numero.
* @param b (int), el segundo numero.
* @return (int), el resultado de la operación.
*/
public static int sumar(int a, int b)
{
return a + b;
}
/**
* Resta el segundo número al primero.
* @param a (int), el primer numero.
* @param b (int), el segundo numero.
* @return (int), el resultado de la operación.
*/
public static int restar(int a, int b)
{
return a - b;
}
/**
* Multiplica dos números enteros.
* @param a (int), el primer numero.
* @param b (int), el segundo numero.
* @return (int), el resultado de la operación.
*/
public static int multiplicar(int a, int b)
{
return a * b;
}
/**
* Divide el primer número entre el segundo.
* @param a (int), el primer numero.
* @param b (int), el segundo numero.
* @return (boolean), el resultado de la operación. Si b es 0 devuelve 0.
*/
public static double dividir(int a, int b)
{
if (b == 0)
{
System.out.println("No se puede dividir por cero.");
return 0;
}
return (double) a / b;
}
/**
* Comprueba si el valor recibido es par.
* @param num (int), numero que se comprobara.
* @return (boolean), true si el numero es par, false si es impar.
*/
public static boolean esPar(int num)
{
return num % 2 == 0;
}
}
Output
10 + 5 = 15
10 - 5 = 5
10 x 5 = 50
10 / 5 = 2.0
10 es par.
En el siguiente tema seguiremos con mas conceptos de POO, veremos los métodos constructores y crearemos una clase de ejemplo de la cual poder instanciar objetos.