Diario de un programador.- Día 95
Métodos en Java
En el
capítulo 39 se hizo una introducción a los métodos al separar el trabajo en
distintos archivos. En esta ocasión mostraré de que forma un método puede estar
en el archivo principal (algo no tan común, ya que es costumbre dejarlos en
archivos separados, pero si uno busca ejemplos de códigos en la web, la mayoría
están de esta forma), luego de este ejemplo, todos los métodos estarán en
archivos separados (para acostumbrarse)
El
siguiente ejemplo, utiliza un método que muestra un mensaje por pantalla, algo
bastante sencillo pero que servirá para el ejemplo.
public class Saludo{
public static
void main(String[]args){
mensaje();
}//fin main
public static void mensaje(){
System.out.println("Soy un simple
metodo");
}
}//fin class
Escribir
métodos de esta forma, es algo similar a lo que se hacía con las subrutinas en
small basic. El o los métodos deben ser ubicados después del cierre del método
"main", además de que deben ser métodos estáticos (static), ya se
explicará en su momento que es eso del "static". En programación
orientada a objetos, a los métodos se les considera "acciones del
objeto" y las variables son consideradas "atributos o características
del objeto". Esto es así, porque en la programación orientada a objetos,
todo programa se considera un objeto o un conjunto de objetos. Por ejemplo, si
quisiera programar un televisor. Se sabe que un televisor tiene como atributo o
característica ser de color negro. Color negro puede ser una variable y esta se
considera como atributo de ese objeto, también puede ser de marca Samsung.
Samsung puede ser otra variable. El televisor también ejecuta acciones, esas
acciones pueden ser encender, apagar o cambiar canales. Las acciones son los
métodos del objeto. Esto de entender la programación orientada a objetos puede
ser algo confusa al principio y hay mucho más que explicar, pero lo iré
explicando de a poco. Por ahora, se debe tener claro que cada objeto tiene
atributos y métodos (características y acciones)
Voy a
mostrar otro ejemplo, pero como dije, de ahora en adelante serán en archivos
separados. El siguiente ejemplo mostrará el área de un cuadrado.
Lo
primero en crear, será la clase "Metodos" la cual contendrá el método
que llamaré desde la clase "Principal"
public class Metodos{
public void area(){
System.out.println("El
area de 5 es 25");
}//fin metodo
}//fin class
Ahora crearé la clase
principal para llamar a este método.
public class Principal{
public static
void main(String [] args){
Metodos
metodo = new Metodos();
metodo.area();
}//fin main
}//fin class
Al ejecutar el programa,
muestra el siguiente resultado
Mmm, está
bien, ¿pero no sería mejor si el programa me pregunte por el área a calcular?
Una
solución sería que el método pida un valor y luego calcule el resultado
import
java.util.Scanner;
public class Metodos{
public void
area(){
Scanner ingreso = new Scanner(System.in);
int valor, areaC;
System.out.print("Ingresa un numero: ");
valor = ingreso.nextInt();
areaC = valor * valor;
System.out.printf("El
area de %d es %d\n", valor, areaC);
}//fin
metodo
}//fin class
Esto muestra el siguiente
resultado:
Funciona,
¿pero qué pasaría si necesito el resultado de esta operación para realizar otro
calculo, como por ejemplo calcular si el
resultado fue un número par o cualquier otra operación?. Si bien, esto se
podría implementar dentro del mismo método, a la larga no sería bueno, ya que
una de las características de la programación orientada a objetos (y otros
paradigmas) es la reutilización del código, esto es para no tener que escribir
algo una y otra vez. Para poder reutilizar código, lo ideal es que los métodos
contengan el menor número de instrucciones u operaciones a realizar. Lo ideal
es que un método realice una sola tarea, ya que esa única tarea puede servir
para una infinidad de proyectos.
Siguiendo
esta línea de minimizar el trabajo o tareas que debe realizar el método, se
puede observar que el método anterior ya realiza demasiadas tareas, en primer
lugar solicita un número, en segundo lugar realiza una operación y por último
muestra un resultado por pantalla. Tres operaciones en un método y lo ideal es
que sea solamente una.
Lo que
voy a tratar de hacer es que el método solamente realice la operación y me
devuelva o entregue un resultado de aquella operación.
Para ello
es necesario ingresar un valor al método para que este trabaje con él. Antes de
enviarle un valor o dato al método, lo primero que haré será solicitarlo. Lo
voy a solicitar desde la clase principal. Esto es lo que tengo ahora, con esto
ya estoy solicitando un valor al usuario, el cual se guardará en la variable
"valor"
import
java.util.Scanner;
public class Principal{
public static
void main(String [] args){
Scanner ingreso = new Scanner(System.in);
int valor;
System.out.println("Ingresa un numero:
");
valor = ingreso.nextInt();
Metodos metodo = new Metodos();
metodo.area();
}//fin main
}//fin class
Ahora que
ya tengo un dato guardado en una variable, necesito llevar esa información
hasta el método "area" para que realice la operación correspondiente.
Para poder realizar esto, al objeto que se creó anteriormente le entregará el
parámetro de la variable, quedando de esta forma: metodo.area(valor) De esta forma
yo "envío" un valor a ese método. Lo que hay que hacer ahora es
preparar al método para recibir el valor que estoy enviando.
Para
poder recibir el valor, el método debo modificarlo de la siguiente manera:
public class Metodos{
//atributos
int resultado;
public
int area(int valor){
resultado = valor * valor;
return resultado;
}//fin metodo
}//fin class
Lo
primero que declaro son los atributos que tendrá este método (Recordar que los
atributos se refieren a las variables)
En la
primera línea del método se puede observar "public int" esto quiere
decir que este método va a devolver o regresar un resultado de tipo entero, el
resultado que regresará será el resultado de la operación. En los paréntesis
aparece una variable de tipo entero. Lo que se encuentra entre los paréntesis
en un método se llama parámetro o argumento. Este parámetro indica que el valor
que recibe es un valor o dato de tipo entero, el valor que recibe este método,
es el número entero que ingresa el usuario desde la clase principal.
En la
siguiente línea la variable "resultado" almacenará el resultado de la multiplicación.
Por último, la instrucción "return" la cual es obligatoria ya que en
la primera línea se mencionó que este método debe devolver un resultado (public
int), devuelve o regresa el valor o dato entregado por el método. Ahora, para
poder ocupar el resultado devuelto por el método, simplemente lo llamo desde la
clase principal.
import java.util.Scanner;
public class Principal{
public static
void main(String [] args){
Scanner
ingreso = new Scanner(System.in);
int
valor;
System.out.print("Ingresa el lado del
cuadrado: ");
valor = ingreso.nextInt();
Metodos metodo = new Metodos();
metodo.area(valor);//envio
y recupero los datos
System.out.printf("El area es
%d\n", metodo.area(valor));
}//fin main
}//fin class
Un método
puede tener varios argumentos, por ejemplo, voy a modificar el método del
programa anterior para que permita
calcular el área de un rectángulo. Para calcular el área de un rectángulo se
necesita el valor del alto y del ancho. Como el método solicita dos valores,
entonces el método tendrá dos argumentos.
La clase
Metodos, quedó de la siguiente manera:
public class Metodos{
//atributos
int resultado;
public int area(int lado, int
ancho){
resultado
= lado * ancho;
return resultado;
}//fin metodo
}//fin class
La clase principal, quedó de
la siguiente manera:
import java.util.Scanner;
public class Principal{
public static
void main(String [] args){
Scanner
ingreso = new Scanner(System.in);
int lado,
ancho;
System.out.print("Ingresa el lado: ");
lado = ingreso.nextInt();
System.out.print("Ingresa el ancho:
");
ancho = ingreso.nextInt();
Metodos metodo = new Metodos();
metodo.area(lado,ancho);
System.out.printf("El area es
%d\n", metodo.area(lado,ancho));
}//fin main
}//fin class
Al ejecutar el programa esto
es lo que muestra:
Eso es
todo por ahora, solamente queda practicar y practicar hasta que esto de los
métodos con o sin return resulte familiar. Hasta la próxima clase.
Gustavo J. Cerda Nilo
Febrero 2016, última actualización Julio 2016
No hay comentarios:
Publicar un comentario