sábado, 9 de julio de 2016

Capítulo 50. Java: Métodos


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

C++ El apuntador This

El apuntador This En C++, cada objeto tiene acceso a su propia dirección a través de un puntero o apuntador denominado This. Lo...