Los atajos de teclado en un entorno de desarrollo integrado como IntelliJ IDEA pueden acelerar el flujo de trabajo. Por ejemplo, escribir main o psvm genera la estructura del método principal. La combinación Ctrl+D duplica la línea actual. Ctrl+Y o Ctrl+X eliminan la línea. Ctrl+Alt+L reorganiza y formatea el código. Alt+Shift+FlechaArriba mueve una línea hacia arriba.

La variable de entorno PATH almacena rutas a programas, permitiendo su ejecución desde cualquier directorio en la línea de comandos.

En el código Java, los literales de tipo entero y decimal se escriben de forma estándar. Los literales de carácter se encierran entre comillas simples y contienen un único símbolo. Las cadenas de texto se delimitan con comillas dobles, pudiendo estar vacías.

Una variable es una porción de memoria que almacena un dato. La memoria del programa se divide en áreas como el área de métodos, la pila y el montón.

Los identificadores deben comenzar con una letra, guion bajo o símbolo de dólar, seguidos por letras, números, guiones bajos o símbolos de dólar.

Conceptos de Programación Orientada a Objetos (POO)

Dentro de un método, la palabra clave this es una referencia que apunta al objeto que invocó el método. Se utiliza para desambiguar entre variables de instancia y parámetros locales cuando comparten el mismo nombre.

public void comparar(double notaParametro) {
    if (this.nota > notaParametro) { // 'this.nota' se refiere a la variable de instancia
        // ...
    }
}

El proceso de creación de un objeto implica la carga de la definición de la clase en el área de métodos. El operador new asigna espacio en el montón para el objeto, inicializando sus variables de instancia. Las referencias en la pila (como miObjeto) almacenan la dirección de este espacio. El recolector de basura de Java libera automáticamente la memoria de los objetos que ya no están referanciados.

Un constructor es un bloque de código especial que se ejecuta al crear una instancia con new. Su nombre debe coincidir con el de la clase y no posee tipo de retorno explícito.

public class Instrumento {
    public Instrumento() {
        System.out.println("Constructor sin parámetros ejecutado.");
    }

    public Instrumento(String modelo) {
        System.out.println("Constructor con parámetros ejecutado. Modelo: " + modelo);
    }
}

Instrumento guitarra = new Instrumento();
Instrumento piano = new Instrumento("Steinway");

Principios de Diseño y Encapsulamiento

Se recomienda que todos los atributos de una clase sean private (ocultos). El acceso controlado se prrovee mediante métodos públicos (getX() y setX()) y constructores. Esto promueve la integridad de los datos y un diseño modular.

Una JavaBean es una clase que sigue convenciones específicas: tiene un constructor público sin argumentos, atributos privados y métodos accesores (getters/setters) para cada atributo.

public class Producto {
    private String nombre;
    private double precio;

    public Producto() {
    }

    public Producto(String nombre, double precio) {
        this.nombre = nombre;
        this.precio = precio;
    }

    public String getNombre() { return nombre; }
    public void setNombre(String nombre) { this.nombre = nombre; }
    public double getPrecio() { return precio; }
    public void setPrecio(double precio) { this.precio = precio; }
}

Producto item1 = new Producto("Laptop", 999.99);
Producto item2 = new Producto();
item2.setNombre("Teclado");
item2.setPrecio(49.95);
System.out.println(item1.getNombre() + ": " + item1.getPrecio());
System.out.println(item2.getNombre() + ": " + item2.getPrecio());

El propósito de un JavaBean es únicamente almacenar datos. La lógica de negocio se implementa en otras clases, separando así el modelo de datos del procesamiento.

Estructura y Convenciones de Clases

Una clase se compone típicamente de: atributos, métodos, constructores, bloques de inicialización e clases internas.

Convenciones importantes: el nombre de la clase debe empezar en mayúsculas y seguir la convención CamelCase. Un archivo .java puede contener múltiples clases, pero solo una puede ser public y su nombre debe coincidir con el del archivo. Los atributos no requieren inicialización explícita, ya que tienen valores por defecto (0, null, false).

Para instanciar un objeto: NombreClase referencia = new NombreClase();. Los miembros se acceden mediante el operador punto: referencia.atributo o referencia.metodo().

Los constructores inicializan un objeto y devuelven su referencia. Un constructor sin parámetros establece valores por defecto. Un constructor con parámetros permite asignar valores iniciales.

Clase String y Colecciones

La clase String en Java representa cadenas de caracteres inmutables. Se pueden crear instancias con literales (String s = "texto";) o con el operador new. Los literales se almacenan en un pool de constantes del montón, donde cada contenido único se almacena una sola vez. Cada uso de new String() crea un nuevo objeto en el montón.

Algunos métodos comunes de String:

• length(): devuelve la longitud.
• charAt(int índice): obtiene el carácter en una posición.
• toCharArray(): convierte a un arreglo de caracteres.
• substring(int inicio, int fin): extrae una subcadena.
• replace(CharSequence viejo, CharSequence nuevo): reemplaza ocurrencias.
• contains(CharSequence s): verifica si contiene una subcadena.
• startsWith(String prefijo): verifica si comienza con un prefijo.
• split(String delimitador): divide la cadena.
• equals(Object otro): compara el contenido.
• equalsIgnoreCase(String otro): compara ignorando mayúsculas.

Es crucial usar equals() para comparar el contenido de dos String, ya que el operador == compara referencias.

La clase ArrayList (del paquete java.util) es una colección que implementa una lista dinámica, a diferencia de los arreglos de tamaño fijo. Es ideal para escanarios donde el número de elementos es variable.

import java.util.ArrayList;

// Declaración con tipo genérico
ArrayList<string> nombres = new ArrayList<>();

// Operaciones comunes
nombres.add("Ana");
nombres.add("Luis");
nombres.add(0, "Elena"); // Insertar en índice 0

String primero = nombres.get(0); // Obtener elemento por índice
int total = nombres.size();      // Tamaño de la lista

String eliminado = nombres.remove(1); // Eliminar por índice y retornar elemento
boolean exito = nombres.remove("Ana"); // Eliminar por contenido

String anterior = nombres.set(0, "Maria"); // Reemplazar elemento en índice</string>

Para recorrer y modificar una ArrayList de manera segura, se puede iterar en orden inverso:

import java.util.ArrayList;

public class EjemploFiltrado {
    public static void main(String[] args) {
        ArrayList<string> listaTareas = new ArrayList<>();
        listaTareas.add("Estudiar Java");
        listaTareas.add("Comprar frutas");
        listaTareas.add("Estudiar bases de datos");
        listaTareas.add("Limpiar casa");
        listaTareas.add("Estudiar redes");

        // Eliminar elementos que contienen "Estudiar" recorriendo al revés
        for (int i = listaTareas.size() - 1; i >= 0; i--) {
            String tarea = listaTareas.get(i);
            if (tarea.contains("Estudiar")) {
                listaTareas.remove(i);
            }
        }
        System.out.println("Tareas pendientes: " + listaTareas);
    }
}</string>