intro_java.txt

//Sintaxis básica
public static void main(String[] args) {
   // Declaraciones y sentencias aquí
}

// Este es un comentario de una sola línea

/* 
Este es un comentario 
de varias líneas
*/

//Tipos de datos

Los tipos de datos primitivos son inmutables

boolean: representa un valor verdadero o falso.
byte: representa un número entero de 8 bits.
short: representa un número entero de 16 bits.
int: representa un número entero de 32 bits.
long: representa un número entero de 64 bits.
float: representa un número de punto flotante de 32 bits.
double: representa un número de punto flotante de 64 bits.
char: representa un carácter Unicode de 16 bits.

Los tipos de datos de referencia, se utilizan para representar objetos y clases. Estos tipos de datos son mutables

String: representa una cadena de caracteres.
Arrays: representa una colección de valores del mismo tipo de datos.
Classes: representa una clase definida por el usuario.
Interfaces: representa una interfaz definida por el usuario.
Enumerations: representa un conjunto fijo de valores nombrados.

int edad = 25;
double salario = 2000.50;
String nombre = "Juan";
boolean esCasado = false;

//Estructuras condicionales:
int edad = 20;

if (edad >= 18) {
   System.out.println("Eres mayor de edad");
} else {
   System.out.println("Eres menor de edad");
}

int diaSemana = 3;
switch (diaSemana) {
   case 1:
      System.out.println("Lunes");
      break;
   case 2:
      System.out.println("Martes");
      break;
   case 3:
      System.out.println("Miércoles");
      break;
   // ...
   default:
      System.out.println("Día no válido");
}

//Estructuras de bucle
for (int i = 0; i < 5; i++) {
   System.out.println(i);
}

int i = 0;
while (i < 5) {
   System.out.println(i);
   i++;
}

int i = 0;
do {
   System.out.println(i);
   i++;
} while (i < 5);

//Vectores
// Crear un vector de enteros de tamaño 5
int[] vector = new int[5];

// Asignar valores al vector
vector[0] = 10;
vector[1] = 20;
vector[2] = 30;
vector[3] = 40;
vector[4] = 50;

// Acceder a los valores del vector
System.out.println(vector[0]); // Imprime 10
System.out.println(vector[2]); // Imprime 30

// Iterar a través de los valores del vector
for (int i = 0; i < vector.length; i++) {
    System.out.println(vector[i]);
}

//Matrices
// Crear una matriz de enteros de tamaño 2x2
int[][] matriz = new int[2][2];

// Asignar valores a la matriz
matriz[0][0] = 1;
matriz[0][1] = 2;
matriz[1][0] = 3;
matriz[1][1] = 4;

// Acceder a los valores de la matriz
System.out.println(matriz[0][0]); // Imprime 1
System.out.println(matriz[1][1]); // Imprime 4

// Iterar a través de los valores de la matriz
for (int i = 0; i < matriz.length; i++) {
    for (int j = 0; j < matriz[i].length; j++) {
        System.out.println(matriz[i][j]);
    }
}
//Manejo de Strings

//Declaracion
String str1 = new String("Hola Mundo");
String str2 = "Hola Mundo";

//Concatenacion
String str1 = "Hola";
String str2 = "Mundo";
String str3 = str1 + " " + str2; // El resultado es "Hola Mundo"

//Comparación
String str1 = "Hola Mundo";
String str2 = "Hola mundo";
boolean resultado1 = str1.equals(str2); // El resultado es false
boolean resultado2 = str1.equalsIgnoreCase(str2); // El resultado es true

//Extracción
String str1 = "Hola Mundo";
String subcadena1 = str1.substring(0, 4); // El resultado es "Hola"
String subcadena2 = str1.substring(5); // El resultado es "Mundo"

//Conversión
String str1 = "true";
boolean b = Boolean.parseBoolean(str1); // El resultado es true
String str2 = "123";
int i = Integer.parseInt(str2); // El resultado es 123

//StringBuilders

//Crea
StringBuilder sb = new StringBuilder();
sb.append("Hola ");
sb.append("Mundo");
String resultado = sb.toString();
System.out.println(resultado); // Imprime "Hola Mundo"

//Inserta
StringBuilder sb = new StringBuilder("Hola Mundo");
sb.insert(4, ", ");
String resultado = sb.toString();
System.out.println(resultado); // Imprime "Hola, Mundo"

//Borra
StringBuilder sb = new StringBuilder("Hola Mundo");
sb.delete(4, 6);
String resultado = sb.toString();
System.out.println(resultado); // Imprime "Ho Mundo"

//Reemplaza
StringBuilder sb = new StringBuilder("Hola Mundo");
sb.replace(0, 4, "Adiós");
String resultado = sb.toString();
System.out.println(resultado); // Imprime "Adiós Mundo"

//Estructuras de Datos

//ArrayList

import java.util.ArrayList;

public class EjemploArrayList {
    public static void main(String[] args) {
        // Crear un ArrayList de tipo String
        ArrayList<String> nombres = new ArrayList<String>();

        // Agregar elementos al ArrayList
        nombres.add("Ana");
        nombres.add("Carlos");
        nombres.add("Luisa");

        // Obtener el tamaño del ArrayList
        int tamano = nombres.size();
        System.out.println("Tamaño del ArrayList: " + tamano);

        // Obtener un elemento del ArrayList
        String nombre = nombres.get(1);
        System.out.println("Elemento en la posición 1: " + nombre);

        // Reemplazar un elemento del ArrayList
        nombres.set(1, "María");

        // Eliminar un elemento del ArrayList
        nombres.remove(0);

        // Verificar si un elemento existe en el ArrayList
        boolean existe = nombres.contains("Luisa");
        System.out.println("¿Luisa existe en el ArrayList? " + existe);

        // Recorrer el ArrayList con un for-each loop
        System.out.println("Elementos del ArrayList:");
        for (String elemento : nombres) {
            System.out.println(elemento);
        }

        // Limpiar el ArrayList
        nombres.clear();
        System.out.println("Tamaño del ArrayList después de limpiarlo: " + nombres.size());
    }
}

//Fila 

import java.util.LinkedList;
import java.util.Queue;

public class EjemploQueue {

    public static void main(String[] args) {

        // Crear una Queue vacía
        Queue<String> fila = new LinkedList<>();

        // Agregar elementos a la Queue
        fila.add("elemento1");
        fila.add("elemento2");
        fila.add("elemento3");

        // Obtener el primer elemento de la Queue (sin eliminarlo)
        String primerElemento = fila.peek();
        System.out.println("Primer elemento: " + primerElemento);

        // Eliminar el primer elemento de la Queue y obtenerlo
        String primerElementoEliminado = fila.poll();
        System.out.println("Primer elemento eliminado: " + primerElementoEliminado);

        // Obtener el nuevo primer elemento de la Queue (el siguiente después del eliminado)
        String nuevoPrimerElemento = fila.peek();
        System.out.println("Nuevo primer elemento: " + nuevoPrimerElemento);

        // Verificar si la Queue contiene un elemento determinado
        boolean contieneElemento2 = fila.contains("elemento2");
        System.out.println("La Queue contiene el elemento2? " + contieneElemento2);

        // Obtener el tamaño de la Queue
        int tamanoQueue = fila.size();
        System.out.println("Tamaño de la Queue: " + tamanoQueue);

        // Vaciar la Queue
        fila.clear();
        System.out.println("Queue vacía? " + fila.isEmpty());
    }
}

//Pila

import java.util.Stack;

public class EjemploStack {

    public static void main(String[] args) {

        // Crear un Stack vacío
        Stack<String> pila = new Stack<>();

        // Agregar elementos a la pila
        pila.push("elemento1");
        pila.push("elemento2");
        pila.push("elemento3");

        // Obtener el último elemento agregado (sin eliminarlo)
        String ultimoElemento = pila.peek();
        System.out.println("Último elemento: " + ultimoElemento);

        // Eliminar el último elemento agregado y obtenerlo
        String ultimoElementoEliminado = pila.pop();
        System.out.println("Último elemento eliminado: " + ultimoElementoEliminado);

        // Obtener el nuevo último elemento de la pila (el anterior al eliminado)
        String nuevoUltimoElemento = pila.peek();
        System.out.println("Nuevo último elemento: " + nuevoUltimoElemento);

        // Verificar si la pila contiene un elemento determinado
        boolean contieneElemento2 = pila.contains("elemento2");
        System.out.println("La pila contiene el elemento2? " + contieneElemento2);

        // Obtener el tamaño de la pila
        int tamanoPila = pila.size();
        System.out.println("Tamaño de la pila: " + tamanoPila);

        // Vaciar la pila
        pila.clear();
        System.out.println("Pila vacía? " + pila.isEmpty());
    }
}

//Algoritmos de búsqueda y selección

public static int busquedaSecuencial(int[] arr, int x) {
    for (int i = 0; i < arr.length; i++) {
        if (arr[i] == x) {
            return i;
        }
    }
    return -1;
}


public static int busquedaBinaria(int[] arr, int x) {
    int inicio = 0, fin = arr.length - 1;
    while (inicio <= fin) {
        int medio = inicio + (fin - inicio) / 2;
        if (arr[medio] == x) {
            return medio;
        } else if (arr[medio] < x) {
            inicio = medio + 1;
        } else {
            fin = medio - 1;
        }
    }
    return -1;
}

public static int busquedaInterpolacion(int[] arr, int x) {
    int inicio = 0, fin = arr.length - 1;
    while (inicio <= fin && x >= arr[inicio] && x <= arr[fin]) {
        int posicion = inicio + ((x - arr[inicio]) * (fin - inicio)) / (arr[fin] - arr[inicio]);
        if (arr[posicion] == x) {
            return posicion;
        } else if (arr[posicion] < x) {
            inicio = posicion + 1;
        } else {
            fin = posicion - 1;
        }
    }
    return -1;
}

public static void selectionSort(int[] arr) {
    int n = arr.length;
    for (int i = 0; i < n-1; i++) {
        int minIndex = i;
        for (int j = i+1; j < n; j++) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j;
            }
        }
        int temp = arr[minIndex];
        arr[minIndex] = arr[i];
        arr[i] = temp;
    }
}

public static void insertionSort(int[] arr) {
    int n = arr.length;
    for (int i = 1; i < n; i++) {
        int key = arr[i];
        int j = i - 1;
        while (j >= 0 && arr[j] > key) {
            arr[j+1] = arr[j];
            j = j - 1;
        }
        arr[j+1] = key;
    }
}

public static void bubbleSort(int[] arr) {
    int n = arr.length;
    for (int i = 0; i < n-1; i++) {
        for (int j = 0; j < n-i-1; j++) {
            if (arr[j] > arr[j+1]) {
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
}

//Hilos

public class EjemploThreads extends Thread {

    private String mensaje;

    public EjemploThreads(String mensaje) {
        this.mensaje = mensaje;
    }

    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(mensaje);
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        EjemploThreads t1 = new EjemploThreads("Hola desde el thread 1");
        EjemploThreads t2 = new EjemploThreads("Hola desde el thread 2");
        t1.start();
        t2.start();
    }
}

//Sincronización


public class Contador {
    private int contador = 0;

    public synchronized void incrementar() {
        contador++;
    }

    public int getContador() {
        return contador;
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Contador contador = new Contador();

        Thread hilo1 = new Thread(new Runnable() {
            public void run() {
                for (int i = 0; i < 100000; i++) {
                    contador.incrementar();
                }
            }
        });

        Thread hilo2 = new Thread(new Runnable() {
            public void run() {
                for (int i = 0; i < 100000; i++) {
                    contador.incrementar();
                }
            }
        });

        hilo1.start();
        hilo2.start();

        hilo1.join();
        hilo2.join();

        System.out.println("El valor del contador es: " + contador.getContador());
    }
}


//Excepciones

//Captura especifica
try {
  // código que puede lanzar una excepción
  FileReader file = new FileReader("archivo.txt");
} catch (FileNotFoundException e) {
  // código que se ejecuta si se lanza la excepción FileNotFoundException
  System.out.println("El archivo no fue encontrado");
}

 //Excepción genérica
try {
  // código que puede lanzar una excepción
  int x = 5/0;
} catch (Exception e) {
  // código que se ejecuta si se lanza cualquier excepción
  System.out.println("Ha ocurrido un error: " + e.getMessage());
}

//Usando finally para asegurarse de que cierto código se ejecute sin importar si se lanza una excepción o no

FileWriter file = null;
try {
  file = new FileWriter("archivo.txt");
  file.write("Hola mundo");
} catch (IOException e) {
  System.out.println("Error al escribir en el archivo");
} finally {
  try {
    if (file != null) {
      file.close();
    }
  } catch (IOException e) {
    System.out.println("Error al cerrar el archivo");
  }
}

//Excepción personalizada

public class MiExcepcion extends Exception {
  public MiExcepcion(String mensaje) {
    super(mensaje);
  }
}

try {
  // código que puede lanzar una excepción personalizada
  throw new MiExcepcion("Ocurrió un error personalizado");
} catch (MiExcepcion e) {
  System.out.println("Ha ocurrido un error: " + e.getMessage());
}

//La programación orientada a objetos en Java se compone de los siguientes elementos:

Clases: son los bloques de construcción fundamentales en la programación orientada a objetos en Java. Una clase es una plantilla que define los atributos y métodos de un objeto.

Objetos: son instancias de una clase. Cada objeto tiene sus propios valores de atributos y puede ejecutar sus propios métodos.

Atributos: son variables que se definen en una clase y contienen datos que describen el estado del objeto.

Métodos: son funciones definidas en una clase que pueden ser ejecutadas por un objeto de esa clase.

Encapsulamiento: es la capacidad de una clase para ocultar los detalles de su implementación y exponer sólo una interfaz pública para interactuar con sus objetos.

Herencia: es la capacidad de una clase para heredar atributos y métodos de una clase padre.

Polimorfismo: es la capacidad de objetos de diferentes clases para responder al mismo mensaje o llamada a un método de una manera diferente.

La programación orientada a objetos en Java se basa en la definición de clases que encapsulan datos y comportamientos,
y en la creación de objetos a partir de estas clases. 
Los objetos interactúan entre sí a través de sus métodos, lo que permite construir programas modulares y escalables.

//Clase
public class Persona {
  String nombre;
  int edad;
  
  public void presentarse() {
    System.out.println("Hola, mi nombre es " + nombre + " y tengo " + edad + " años.");
  }
}

//Atributos:
public class Coche {
  String marca;
  String modelo;
  int anio;
}

//Métodos
public class Circulo {
  double radio;
  
  public double calcularArea() {
    return Math.PI * radio * radio;
  }
}

//Encapsulamiento
public class CuentaBancaria {
  private double saldo;
  
  public void depositar(double cantidad) {
    saldo += cantidad;
  }
  
  public double getSaldo() {
    return saldo;
  }
}

//Herencia
public class Animal {
  String nombre;
  
  public void comer() {
    System.out.println(nombre + " está comiendo.");
  }
}

public class Perro extends Animal {
  public void ladrar() {
    System.out.println(nombre + " está ladrando.");
  }
}

//Polimorfismo
public class Figura {
  public void dibujar() {
    System.out.println("Dibujando una figura genérica.");
  }
}

public class Circulo extends Figura {
  public void dibujar() {
    System.out.println("Dibujando un círculo.");
  }
}

public class Cuadrado extends Figura {
  public void dibujar() {
    System.out.println("Dibujando un cuadrado.");
  }
}


//Sobreescritura de métodos

public class Animal {
   public void hacerSonido() {
      System.out.println("Haciendo sonido genérico");
   }
}

public class Perro extends Animal {
   @Override
   public void hacerSonido() {
      System.out.println("Ladrando");
   }
}

public static void main(String[] args) {
   Animal animal = new Animal();
   animal.hacerSonido(); // Imprime "Haciendo sonido genérico"

   Perro perro = new Perro();
   perro.hacerSonido(); // Imprime "Ladrando"
}

//Gestion de listas de objetos
import java.util.ArrayList;
import java.util.List;

public class EjemploLista {
    public static void main(String[] args) {
        // Crear una lista de objetos de la clase Persona
        List<Persona> listaPersonas = new ArrayList<>();

        // Agregar objetos a la lista
        listaPersonas.add(new Persona("Juan", 25));
        listaPersonas.add(new Persona("María", 30));

        // Eliminar un objeto de la lista
        listaPersonas.remove(0);

        // Obtener un objeto de la lista
        Persona persona = listaPersonas.get(0);

        // Iterar sobre los elementos de la lista
        for (Persona p : listaPersonas) {
            System.out.println(p.getNombre() + " " + p.getEdad());
        }
    }
}