Programación

Esta página es de solo lectura. Puedes ver la fuente pero no puedes cambiarla. Pregunta a tu administrador si crees que esto es incorrecto.
======Métodos estáticos======
Un  método  es  un  **bloque  de  instrucciones**  definidas  dentro  de  una  clase  que  realizan  una  determinada tarea y a las que podemos invocar (llamar) mediante un nombre ''identificador''.

Los métodos pueden ser de dos tipos:
  * Métodos estáticos: se definen como ''static''
  * Métodos de instancia

En este tema nos centramos en los __métodos estáticos__.

Algunos de los métodos estáticos que hemos usado hasta ahora:
<code java>
//Se ejecutan desde la clase
System.out.println("Introduce un valor");
Math.random();
</code>

También hemos usado métodos no estáticos (de instancia) a partir de algunos objetos:
<code java>
//Es necesario construir un objeto
String cadena = "Fernando";
Scanner input = new Scanner(System.in);

//se llama a sus métodos a partir del objeto creado
cadena.charAt(4);
input.nextLine();
</code>


Si usamos métodos:
  * Se modulariza el código
  * Se permite reutilizar el código, sin tener que volver a escribirlo.

===== Estructura de un método =====
<code java>
[modificadores] tipoRetorno identificadorMetodo([lista parametros])
{
   // instrucciones 
   [return valor;] 
}
</code>

  * **Modificadores**: public, private, static
  * **Tipo retorno**: Tipo de datos que devuelve el método. Puede devolver un tipo concreto, o no devolver nada: ''void''
  * **Identificador**: El identificador que usaremos para ejecutarlo, igual que el de una variable. Su forma de escribir el identificador de un método es ''lowerCamelCase''
  * **Lista de parámetros**: Los tipos de datos que necesita el método para operar.
  * **Return**: se usa para devolver el valor de retorno. El tipo retornado tiene que coincidir con el ''tipo retorno'' del método.

<code java>
static int sumar(int entero1, int entero2){ 
   int resultado; 
   resultado = entero1 + entero2; 
   return resultado; 
}
</code>

==== Tipo void ====
Definimos como ''void'' los métodos que no devuelven un valor. Harán cosas pero no devuelven un valor. Normalmente muestran datos por pantalla.

''void'' es una palabra reservada que se usa solo para indicar que un método no retorna nada. No se pueden crear variables de tipo ''void''.

<code java>
static void sumar(int entero1, int entero2){ 
   int resultado; 
   resultado = entero1 + entero2; 
   System.out.println("La suma es: " + resultado); 
}
</code>

Aunque no devuelva nada, podemos seguir usando la instrucción ''return'', si hay algún caso especial en el que queremos que el método termine.

==== Modificador static ====
Por ahora, la principal característica que nos interesa de la cláusula ''static'' es que para usar un método static  no necesitamos crear un objeto de la clase en la que se encuentra definido.

Por ejemplo: todos los métodos de la ''clase Math'', son estáticos, y no necesitamos crear una variable de tipo Math para ejecutarlos.

La ''clase String'' tiene algunos métodos que también son estáticos, pero otros que solo los puedo ejecutar desde una variable de tipo String.

==== Modificador public ====
Se indicará al comienzo de la definición de un método, cuando quiero poder usarlo desde clases que se encuentran en otros ''packages''.

<code java>
package metodos;

public class Metodo1{ 
   public static void main(String[] args) { 
      int num1 = 3, num2 = 5; 
      System.out.println("La suma es: " + sumar(num1, num2)); 
   } 

   public static int sumar(int entero1, int entero2){ 
      int resultado; 
      resultado = entero1 + entero2; 
      return resultado; 
   }
}
</code>

Y lo usamos desde una clase en otro ''package'':

<code java>
package ejercicios;

//Debo importar la clase que lo contiene
import metodos.Metodo1;

public class Ejercicio1 { 
   public static void main(String[] args) { 
      int num1 = 3;
      int num2 = 5; 
      //Lo uso poniendo delante el nombre de la clase
      System.out.println("La suma es: " + Metodo1.sumar(num1, num2)); 
   } 
}
</code>

===== Sobrecarga de Métodos =====
Java nos permite crear métodos dentro de la misma clase y con el mismo ''identificador''. Esto se conoce como sobrecarga ''overloading''.

Para que dos métodos puedan tener el mismo nombre debe haber alguna de estas diferencias entre ellos:
  * Diferencia en la cantidad de parámetros que reciben.
  * Diferencia en el tipo de parámetros que reciben.

Ejemplos de clases con sobrecarga de métodos son las clases Math o String:
{{ :bloque2:sobrecargamath.png?400 |}}
{{ :bloque2:sobrecargastring.png?400 |}}

Como vemos hay varios métodos repetidos, pero tienen alguna diferencia entre el __tipo del parámetro__ o __la cantidad de parámetros__ que reciben.

----

{{ vimeo>306490019?medium }}

----
===== Recursividad =====
Se conoce con el nombre de recursividad a la técnica en la que un método hace una llamada a sí mismo. Es una técnica muy potente, pero también muy pesada (consumo de recursos).

Ejemplo de método recursivo para obtener el valor factorial (1 x 2 x 3 x ... x N) de un entero positivo (N):

<code java>
static int factorial(int entero){ 

   //Condición de salida de recursividad
   if (entero == 0){
      return 1; 
   }    
   
   //LLamada recursiva
   return factorial(entero - 1) * entero; 
}
</code>

----

(c) {{date> %Y}} Fernando Valdeón