JAVA - Abstracción, Clases internas, Conjunto Hash, Entrada usuario, Enumeraciones, Fecha y hora, Lista arrays, Lista enlazada, Mapa hash, Polimorfismo

Signed-off-by: diwes-gh <alejandro@alejandroalsa.es>

Author: alejandroalsa

_posts/2024-01-04-java-abstraccion.md

@@ -0,0 +1,66 @@
+---
+title: Abstracción
+date: 2024-01-04 10:00:00 +0800
+categories: [Programación, Java]
+tags: [Java]
+---
+
+# Clases y métodos abstractos
+
+La abstracción de datos es el proceso de ocultar ciertos detalles y mostrar solo información esencial al usuario. La abstracción se puede lograr con **clases abstractas** o **interfaces de usuario** (más adelante las trataremos).
+
+La palabra clave `abstract` es un modificador sin acceso, utilizado para clases y métodos:
+
+* **Clase abstracta** Es una clase restringida que no se puede utilizar para crear objetos.
+* **Clase abstracto** Solo se puede utilizar en una clase abstracta y no tiene cuerpo. El cuerpo lo proporciona la subclase heradada de él.
+
+Una clase abstracta puede tener métodos tanto abstractos como regulares:
+
+```java
+abstract class animal{
+  public abstract void sonidoAnimal();
+  public void dormir(){
+    System.out.println("Zzz");
+  }
+}
+```
+
+Segun el ejemplo anterior, no es posible crear un objeto de la clase `animal`.
+
+```java
+animal miObjeto = new animal(); // Error
+```
+
+Para acceder a la clase abstracta, tendremos que heredar de otra clase. En el siguiente ejemplo convertiremos la clase `animal` del post anterior en una clase abstracta.
+
+```java
+// Clase abstracta
+abstract class animal{
+  // El método abstracto no tiene cuerpo
+  public abstract void sonidoAnimal();
+  // Método regular
+  public void dormir(){
+    System.out.println("Zzz");
+  }
+}
+
+// Subclase
+class gato extends animal {
+  public void sonidoAnimal(){
+    // El cuerpo de sonidoAnimal() es privado
+    System.out.println("El gato maulla: miau miau");
+  }
+}
+
+class main{
+  public static void main(String[] args){
+    gato miGato = new gato(); // Creamos el objeto gato
+    miGato.sonidoAnimal();
+    miGato.dormir();
+  }
+}
+```
+
+## ¿Por qué y cuándo utilizar clases y métodos abstractos?
+
+Para lograr seguridad: Ocultar ciertos detalles y mostrar solo los detalles importantes de un objeto. 

_posts/2024-01-04-java-clases-internas.md

@@ -0,0 +1,108 @@
+---
+title: Clases internas
+date: 2024-01-04 9:00:00 +0800
+categories: [Programación, Java]
+tags: [Java]
+---
+
+# Clases internas
+
+En Java, también es posible anidar clases (una clase dentro de una clase). El propósito de clases anidadas es agrupar clases que pertenecen juntas, lo que hace que nuestro código se más legible y fácil de mantener.
+
+Para acceder a la clase internar, crearemos un objeto de la clase externa y luego crearemos un objeto de la clase interna:
+
+```java
+class claseExterna{
+  int x = 10;
+
+  class claseInterna{
+    int y = 20;
+  }
+}
+
+public class main{
+  public static void main(String[] args){
+    claseExterna miExterna = new claseExterna();
+    claseExterna.claseInterna miInterior = miExterna.new claseInterna();
+    System.out.println(miExterna.x + miInterior.y);
+  }
+}
+```
+
+## Clase privada
+
+A diferencia de una clase normal, una clase interna puede ser `private` o `protected`. Si queremos que los objetos externos no accedan a la clase interna, esta tendremos que declararla como `private`.
+
+```java
+class claseExterna{
+  int x = 10;
+
+  private class claseInterna{
+    int y = 20;
+  }
+}
+
+
+public class main{
+  public static void main(String[] args){
+    claseExterna miExterna = new claseExterna();
+    claseExterna.claseInterna miInterior = miExterna.new claseInterna(); // Error
+    System.out.println(miExterna.x + miInterior.y); // Error
+  }
+}
+```
+
+Si intentamos compilar, no dará un error indicándonos que se intenta acceder a una clase interna privada desde una clase externa.
+
+## Clase interna estática
+
+Una clase interna también puede ser `static`, lo que significa que podemos acceder a ella creando simplemente un objeto de la clase externa
+
+```java
+class claseExterna{
+  int x = 10;
+
+  static class claseInterna{
+    int y = 20;
+  }
+}
+
+public class main{
+  public static void main(String[] args){
+    claseExterna.claseInterna miInterior = new claseExterna.claseInterna();
+    System.out.println(miInterior.y);
+  }
+}
+```
+
+Salida: 
+
+```txt
+20
+```
+
+> NOTA: Al igual que los atributos y métodos estáticos, una clase interna estática no tiene acceso a los miembros de la clase externa.
+
+## Acceder a la clase exterior desde la clase interior
+
+Una ventaja de las clases internas es que pueden acceder a atributos y métodos de la clase externa.
+
+```java
+class claseExterna{
+  int x = 10;
+  
+  class claseInterna{
+    public int miMetodoInterno(){
+      return x;
+    }
+  }
+}
+
+public class main{
+  public static void main(String[] args){
+    claseExterna miExterna = new claseExterna();
+    claseExterna.claseInterna miInterior = miExterna.new claseInterna();
+    System.out.println(miInterior.miMetodoInterno());
+  }
+}
+```

_posts/2024-01-04-java-conjunto-hash .md

@@ -0,0 +1,123 @@
+---
+title: Conjunto de Hash
+date: 2024-01-04 17:00:00 +0800
+categories: [Programación, Java]
+tags: [Java]
+---
+
+# Conjunto de hash
+
+Un HashSet es una colección de elementos donde cada elemento es único y se encuentra en el paquete `java.util`
+
+```java
+// Crear un HashSet objeto llamado coches que almacenará cadenas
+
+import java.util.HashSet;
+
+HashSet<String> coches = new HashSet<String>();
+```
+
+## Agregar elementos 
+
+La clase `HashSet` tiene muchos métodos útiles. Por ejemplo, el método `add()`
+
+```java
+import java.util.HashSet;
+
+public class main {
+  public static void main(String[] args) {
+    HashSet<String> coches = new HashSet<String>();
+    coches.add("Jaguar");
+    coches.add("Ford");
+    coches.add("BMW");
+    coches.add("BMW");
+    coches.add("Ferrari");
+
+    System.out.println(coches);
+  }
+}
+```
+
+> NOTA: En el ejemplo anterior, aunque BMW se agrega dos veces, solo aparece una vez en el conjunto, porque cada elemento de un conjunto tiene que ser único. 
+
+## Comprobar si existe un elementos 
+
+Para verificar si un elemento existe en un HashSet, utiliza el método `contains()`
+
+```java
+import java.util.HashSet;
+
+public class main {
+  public static void main(String[] args) {
+    HashSet<String> coches = new HashSet<String>();
+    coches.add("Jaguar");
+    coches.add("Ford");
+    coches.add("BMW");
+    coches.add("BMW");
+    coches.add("Ferrari");
+
+    coches.contains("Porche");
+  }
+}
+```
+
+## Eliminar un artículo 
+
+Para eliminar un elemento, utiliza el método `remove()`
+
+```java
+coches.remove("Ferrari");
+```
+
+Para eliminar todos los elementos, utiliza el método `clear()`
+
+```java
+coches.clear();
+```
+
+## Tamaño del conjunto de hash 
+
+Para saber cuántos elementos hay, utiliza el método `size()`:
+
+```java
+coches.size();
+```
+
+## Recorrer un HashSet 
+
+Recorre los elementos de un HashSet con un bucle para cada
+
+```java
+for (String i : coches){
+  System.out.println(i)
+}
+```
+
+## Otros tipos 
+
+Los elementos de un `HashSet` son en realidad objetos. En los ejemplos anteriores, hemos creado elementos (objetos) de tipo `String`. Recuerda que un `String` en Java es un objeto (no un tipo primitivo). Para utilizar otros tipos, como `int`, debes especificar una clase envolvente equivalente: `Integer`. Para otros tipos primitivos, utiliza: `Boolean` para booleanos, `Character` para caracteres, etc
+
+```java
+// Usar una HashSet que almacena Integer objetos
+
+import java.util.HashSet;
+
+public class Main {
+  public static void main(String[] args) {
+
+    HashSet<Integer> numeros = new HashSet<Integer>();
+
+    numeros.add(4);
+    numeros.add(7);
+    numeros.add(8);
+
+    for (int i = 0; i <= 10; i ++ ){
+      if (numeros.contains(i)) {
+        System.out.println(i + " en el conjunto.");
+      } else {
+        System.out.println(i + " no se encontró en el conjunto.");
+      }
+    }
+  }
+}
+```

_posts/2024-01-04-java-entrada-usuario.md

@@ -0,0 +1,64 @@
+---
+title: Entrada de usuario (Scanner)
+date: 2024-01-04 14:00:00 +0800
+categories: [Programación, Java]
+tags: [Java]
+---
+
+# Entrada de usuario (Scanner)
+
+La clase `scanner`, se utiliza para obtener datos de entrada de usuario y se encuentra en el paquete `java.util`
+
+En el siguiente ejemplos creare un objeto de la clase `Scanner` y utilizare el método `nextLine()` disponibles en `Scanner` para leer toda una linea.
+
+```java
+import java.util.Scanner;
+
+public class main{
+  public static void main(String[] args){
+    Scanner miObjeto = new Scanner(System.in);
+    System.out.println("Nombre de usuario: ");
+
+    String nombreUsuario = miObjeto.nextLine();
+    System.out.println("Nombre de usuario tecleado: " + nombreUsuario);
+  }
+}
+```
+
+## Tipos de entrada
+
+En el ejemplo anterior, utilizamos `nextLine()` método, que se utiliza para leer cadenas. Para leer otros tipos, consulta la siguiente tabla:
+
+| Método             | Descripción                               |
+|--------------------|-------------------------------------------|
+| `nextBoolean()`    | Lee un valor booleano del usuario         |
+| `nextByte()`       | Lee un valor byte del usuario             |
+| `nextDouble()`     | Lee un valor double del usuario           |
+| `nextFloat()`      | Lee un valor float del usuario            |
+| `nextInt()`        | Lee un valor int del usuario              |
+| `nextLine()`       | Lee un valor String del usuario           |
+| `nextLong()`       | Lee un valor long del usuario             |
+| `nextShort()`      | Lee un valor short del usuario            |
+
+En el siguiente ejemplo, utilizamos diferentes métodos para leer datos de varios tipos:
+
+```java
+import java.util.Scanner;
+
+class main{
+  public static void main(String[] args){
+    Scanner miObjeto = new Scanner(System.in);
+    System.out.println("Introduce tu nombre, apellidos y edad: ");
+
+    String nombre = miObjeto.nextLine();
+    String apellidos = miObjeto.nextLine();
+    int edad = miObjeto.nextInt();
+
+    System.out.println("Nombre: " + nombre);
+    System.out.println("Apellidos: " + apellidos);
+    System.out.println("Edad: " + edad);
+  }
+}
+```
+
+> NOTA: Si introduces un tipo de dato que no corresponde con el establecido, por ejemplo en edad pones "veinte", recibirás una mensaje de excepción/error (como "InputMismatchException").