JAVA-Alcance + Métodos + Recursividad

Signed-off-by: Alejandro Alfaro Sánchez <alejandro@alejandroalsa.es>

_posts/2023-12-15-java-alcance.md

@@ -0,0 +1,52 @@
+---
+title: Alcance de Java
+date: 2023-12-15 12:00:00 +0800
+categories: [Programación, Java]
+tags: [Java]
+---
+
+## Alcance de Java
+
+En Java, solo se pueden acceder a las variables dentro de la region donde se crean, a esto se le llama alcance.
+
+Veamos los dos tipos de alcance de Java:
+
+### Alcance de método
+
+Las variable declaradas directamente dentro de un método están disponibles en cualquier parte del métodos después de la linea de código en la que fueron declaradas.
+
+```java
+public class main{
+    public static void main(String[] args){
+
+        // No podemos utilizar la variable x
+        int x = 10;
+
+        // Podemos utilizar la variable x
+        System.out.println(x);
+    }
+}
+```
+
+## Alcance de bloque
+
+Un bloque de código se refiere a todo el código entre llaves `{}`
+
+```java
+public class main{
+    public static void main(String[] args){
+
+        // No podemos utilizar la variable x
+
+        { // Esto es un bloque
+            // No podemos utilizar la variable x
+            int x = 100;
+
+            // Podemos utilizar la variable x
+            System.out.println("x");
+        } // Fin del bloque
+
+        // No podemos utilizar la variable x
+    }
+}
+```

_posts/2023-12-15-java-metodos.md

@@ -0,0 +1,134 @@
+---
+title: Métodos
+date: 2023-12-15 12:00:00 +0800
+categories: [Programación, Java]
+tags: [Java]
+---
+
+## Métodos
+
+Un método es un bloque de código que solo se ejecuta cuando se le llama, estos se utilizan para realizar ciertas acciones y también son conocidos como funciones. Uno de los principales objetivos de los métodos es ahorrarnos lineas de código ya que podemos programar ciertas acciones en ello y luego ir llamándolas según nos hagan falta.
+
+Los métodos deben ser declarados dentro de una clase. Se define como nombre del método, seguido de un paréntesis `()`. Java proporciona algunos métodos ya predefinidos como `System.out.println()`, vemos ahora como crear los nuestros propios:
+
+```java
+public class main{
+  static void mimétodo(){
+    // Bloque de codigo del método
+  }
+}
+```
+
+`mimétodo` es el nombre del método
+`static` significa que el método pertenece a la clase principal `main` y no un objeto de la clase principal. Mas adelante trataremos los objetos
+`void` significa que este método no tiene valor de retorno. Mas adelante trataremos los valores de retorno.
+
+```java
+public class main{
+  static void mimétodo(){
+    System.out.println("Hola Mundo!");
+  }
+
+  public static void main(String[] args){
+    mimétodo();
+  }
+}
+```
+
+Como vemos en el ejemplo la forma que tenemos de llamar a un método es muy simple, es solo poner su nombre.
+
+## Parámetros y argumentos
+
+La información se puede pasar a método como parámetro, estos actúan como variables dentro del método.
+
+Para especificar a estos parámetros sera necesario que los declaremos dentro justo después de declarar el nombre del método y dentro del paréntesis.
+
+En el siguiente ejemplo vemos que el método tiene una variable de tipo `String` llamada `nombre` o lo que es lo mismo un **parámetro**, cuando llamemos al método completaremos la variable poniendo un valor dentro de los paréntesis justo después de llamar al método.
+
+```java
+public class main{
+  static void mimétodo(String nombre){
+    System.out.println("Mi nombre es: " + nombre);
+  }
+
+  public static void main(String[] args){
+    mimétodo("Alejandro");
+  }
+}
+```
+
+Cuando se pasa un parámetro al método se le llama argumento. En el ejemplo anterior `nombre` es un parámetro mientras que `Alejandro` es un argumento. De igual forma podemos introducir varios parámetros y argumentos:
+
+```java
+public class main{
+  static void mimétodo(String nombre, int edad){
+    System.out.println("Mi nombre es " + nombre + " y tengo " + edad + " años");
+  }
+
+  public static void main(String[] args){
+    mimétodo("Alejandro", 20);
+  }
+}
+```
+
+> Nota: Tenemos que tener en cuenta que cuando trabajamos con múltiples parámetros, a la hora de declarar el método principal tenemos que declarar el mismo numero de argumentos que parámetros.
+
+La palabra clave `void`, utilizada en los ejemplos anteriores, indica que el método no debe devolver un valor. Si necesitamos que el método devuelva un valor, podemos utilizar un tipo de datos primitivo (`int`, `char`, etc.)
+
+```java
+public class main{
+  static int mimétodo(int x, int y){
+    return x + y;
+  }
+
+  public static void main(String[] args){
+    int z = mimétodo(10, 10);
+    System.out.println(z);
+  }
+}
+```
+
+También como hemos podido ver en el ejemplos podemos guardar el valor del método en una variable (acción muy recomendada).
+
+## Un método con `if...else`
+
+Es muy comun utilizar `if...else` dentro de un método:
+
+```java
+public class main{
+  static void mimétodo(int edad){
+
+    if (edad >= 18){
+      System.out.println("Eres mayor de edad en España");
+    } else {
+      System.out.println("Eres menor de edad en España");
+    }
+  }
+
+  public static void main(String[] args){
+    mimétodo(20);
+  }
+}
+```
+
+## Sobrecarga del método
+
+Con la sobrecarga de métodos, varios métodos pueden tener el mismo nombre con diferentes parámetros. En el siguiente ejemplos sobrecargamos el método `suma` para poder trabajar con datos de tipo `int` y `double`.
+
+```java
+public class main{
+  static int suma(int x, int y){
+    return x + y;
+  }
+  static double suma(double x, double y){
+    return x + y;
+  }
+
+  public static void main(String[] args){
+    int sumaInt = suma(10, 10);
+    double sumaDouble = suma(10.25, 10.25);
+    System.out.println(sumaInt);
+    System.out.println(sumaDouble);
+  }
+}
+```

_posts/2023-12-15-java-recursividad.md

@@ -0,0 +1,76 @@
+---
+title: Recursividad
+date: 2023-12-15 12:00:00 +0800
+categories: [Programación, Java]
+tags: [Java]
+---
+
+## Recursividad
+
+La recursividad es la técnica de hacer que una función se llame a si misma. Esta técnica proporciona una manera de descomponer problemas complicados en problemas simples que sean mas fáciles de resolver.
+
+La recursividad puede ser un poco difícil de entender. La mejora manera de entenderla es ver como funciona con un ejemplo.
+
+Sumar dos números es fácil de hacer, pero sumar un rango de números es mas complicado. En el siguiente ejemplo, la recursividad se utiliza para sumar un rango de números juntos, dividiéndolo en la simple tarea de sumar dos números.
+
+```java
+// Utilizando la recursividad suma todos los números hasta el 10. (0,1,2,3,4,5,6,7,8,9,10)
+public class main{
+
+  public static int suma(int k){
+    if (k > 0){
+      return k + suma(k - 1);
+    } else{
+      return 0;
+    }
+  }
+
+  public static void main(String[] args){
+    int resultado = suma(10);
+    System.out.println(resultado);
+  }
+}
+```
+
+Salida:
+
+```text
+55
+```
+
+Vamos paso a paso la ejecución. Lo primero que hacemos es declarar un método en el que creamos una variable `k`, después introducimos un `if` con la condición de ejecución de si `k` es mayor que `0` devuelve una suma, vemos con detenimiento la suma ya que hay esta la calve del código, si nos damos cuenta estamos haciendo dos operaciones en mismo `return` primero la resta del valor `k` menos `1` y después la suma del valor `k` (10 + (10 - 9)), lo interesante de esto es que para hacer la suma estamos llamando a la función `suma` dentro de la misma función `suma` (recursividad), esto lo hacemos para poder seguir metiendo paréntesis dentro de `return` como vemos abajo
+
+```text
+10 + suma(9)
+10 + ( 9 + suma(8) )
+10 + ( 9 + ( 8 + suma(7) ) )
+...
+10 + 9 + 8 + 7 + 6 + 5 + 4 + 3 + 2 + 1 + suma(0)
+10 + 9 + 8 + 7 + 6 + 5 + 4 + 3 + 2 + 1 + 0 
+```
+
+Si nos fijamos lo que estamos haciendo cuando ponemos `suma(k - 1)` es volver a ejecutar la función de nuevo y desde 0 es decir desde `if (k > 0)....` pero esta vez con el valor de `k` mas pequeño, con esto lo que hemos creado es un "bucle" de la misma función (recursividad) lo que nos permite resolver el problema.
+
+## Condición de detención
+
+Al igual que en los bucles podemos encontrarnos con el problema de la bucles infinitos, en las funciones de recursividad también nos podemos encontrar con este problema, por ello es necesario cuando creamos un función de recursividad darle una condición de parada, en el ejemplos anterior la condición de parada es cuando el parámetro `k` se convierte en `0`
+
+Veamos ahora otro ejemplo de función de recursividad para entenderlo mejor:
+
+```java
+// Utilizando la recursividad suma todos los números entre 5 y 10
+public class main{
+  public static int suma(int ini, int fin){
+    if (fin > ini){
+      return fin + suma(ini, fin - 1);
+    } else{
+      return fin;
+    }
+  }
+
+  public static void main(String[] args){
+    int resultado = suma(5, 10);
+    System.out.println(resultado);
+  }
+}
+```