Programación Orientada a Objetos en JAVA

¡Hola, equipo! Bienvenidos al que probablemente sea el cambio de mentalidad más importante en vuestro viaje como desarrolladores: la Programación Orientada a Objetos (POO). Hasta ahora, hemos manejado datos y hemos creado programas que siguen una secuencia de pasos, como una receta de cocina. Funciona, pero... ¿es la mejor forma de construir software complejo y que deba evolucionar con el tiempo?

Imaginad por un momento que sois los arquitectos de una nueva urbanización. El método "tradicional" sería como tener un único plano gigantesco que detalla cada ladrillo, cada tubería y cada cable de toda la urbanización. Si un cliente quisiera cambiar el diseño de una sola casa, tendríais que modificar ese plano colosal, con un riesgo altísimo de cometer errores que afecten a otras casas. Sería un infierno de mantener.

La POO nos propone una estrategia mucho más inteligente, la misma que usan los arquitectos de verdad. En lugar de un plano monolítico, diseñamos "planos" modulares para diferentes tipos de edificios: un plano para un "Chalet", otro para un "Apartamento", y quizás otro para un "Garaje". Cada uno de estos planos, que en nuestro mundo llamaremos Clases, define a la perfección qué tiene cada edificio (sus atributos: numeroDeHabitaciones, metrosCuadrados) y qué se puede hacer en él (sus métodos: abrirPuerta(), encenderLuces()).

Luego, para construir la urbanización, simplemente usamos esos planos para crear los edificios reales: "Construye tres Chalet aquí, un bloque de 20 Apartamento allá, y un Garaje por cada uno". Cada edificio construido es un Objeto, una "instancia" tangible y funcional de una clase. La belleza de esto es que si queremos modificar los chalets, solo tenemos que actualizar el plano Chalet, y si queremos añadir un nuevo tipo de edificio, como una "PiscinaComunitaria", simplemente diseñamos un nuevo plano sin perturbar los existentes.

Este es el corazón de la POO: modelar problemas complejos como un ecosistema de objetos independientes pero colaborativos. Es la filosofía que impulsa desde el motor gráfico de Cyberpunk 2077 hasta la app que usas para pedir comida. En este tema, no solo aprenderéis a programar; aprenderéis a diseñar.

¿Qué es la POO?

La Programación Orientada a Objetos (POO) es un paradigma de programación que se basa en el concepto de "clases" y "objetos". Este modelo de programación permite estructurar un programa de software en piezas simples y reutilizables de planos de código (clases) para crear instancias individuales de objetos.

En el paradigma de objetos, solo hay objetos y mensajes (que también son objetos). Un programa en POO es un conjunto de objetos que colaboran enviándose mensajes.

graph TD
    A[ENTRADA] --> B{Objeto A};
    B -- Atributos y Métodos --> C{Objeto B};
    C -- Atributos y Métodos --> D{Objeto C};
    B -- Atributos y Métodos --> D;
    D -- Atributos y Métodos --> E[SALIDA];

    subgraph "Proceso"
        B;
        C;
        D;
    end

Ventajas de la POO

La Programación Orientada a Objetos ofrece varias ventajas significativas para el desarrollo de software:

• Reutilización de Código: Facilita la reutilización de código a través de conceptos como la herencia y la composición, permitiendo aprovechar clases existentes para crear nuevas, lo que ahorra tiempo y esfuerzo.
• Organización del Código: Proporciona una estructura organizada para el código al dividirlo en clases y objetos, mejorando la modularidad y facilitando la comprensión y el mantenimiento del software.
• Abstracción: Permite abstraer detalles complejos, centrándose en la representación de objetos del mundo real, lo que facilita la comprensión del sistema y la resolución de problemas.
• Mantenibilidad: La modularidad y la estructura organizada facilitan la identificación y corrección de errores. Los cambios y actualizaciones se pueden realizar de manera más eficiente sin afectar otras partes del sistema.
• Escalabilidad: Facilita la escalabilidad del software al permitir la adición de nuevas funcionalidades mediante la creación de nuevas clases o la extensión de clases existentes.

Desventajas de la POO

A pesar de sus ventajas, la POO también presenta algunas desventajas:

• Cambio en la forma de pensar: Requiere un cambio de mentalidad con respecto a la programación tradicional o estructurada.
• Ejecución más lenta: La ejecución de programas orientados a objetos puede ser más lenta en comparación con otros paradigmas.
• Complejidad para adaptarse: La curva de aprendizaje puede ser más pronunciada para los programadores que no están familiarizados con el paradigma.
• Dificultad en la abstracción: Diseñar una jerarquía de clases y objetos efectiva puede ser un desafío.

Conceptos Generales de la POO

Clase

Una clase es una plantilla mediante la cual se crean los diferentes objetos requeridos para la solución del problema. Los objetos son instancias de las clases. Una clase se compone de:

• Información: Campos (atributos, propiedades).
• Comportamiento: Métodos (operaciones, funciones).

graph TD
    subgraph "Clase"
        direction LR
        A[ATRIBUTOS] --> B[propiedad1];
        A --> C[propiedad2];
        A --> D[propiedad3];

        E[MÉTODOS] --> F[metodo1];
        E --> G[metodo2];
        E --> H[metodo3];
    end

Objeto

Un objeto es una instancia de una clase. Por lo tanto, los objetos hacen uso de los Atributos (variables) y Métodos (funciones y procedimientos) de su correspondiente clase. Es una variable de tipo clase y permite modelar entidades del mundo real.

Clases y Objetos: Definición y Ejemplos

En POO, una clase es un plano para crear objetos, mientras que un objeto es una instancia específica de una clase. Las clases definen atributos y métodos comunes para los objetos.

Ejemplos:

• Una clase 'Vehículo' puede tener:

  • atributos como 'color' y 'modelo'.
  • métodos como 'arrancar' y 'parar'.

• Una clase 'Persona' puede tener:

  • atributos como 'nombre', 'apellido', 'edad', 'género'.
  • métodos como 'esMayorEdad'.

Identificación de Objetos

La primera tarea de un programador en POO es la identificación de los objetos inmersos en el problema a solucionar. Generalmente se ubican en las siguientes categorías:

• Cosas tangibles: árbol, auto, etc.
• Cosas intangibles: emociones, marca.
• Organizaciones o entidades: universidad, empresa de transporte.
• Roles: alumno, profesor, etc.

Objetos y Atributos

Los atributos determinan el estado interno de un objeto.

Ejemplo: Sea la clase PERSONA y el objeto ANA:
* El nombre de Ana es Ana María.
* El apellido de Ana es Rodríguez.
* La edad de Ana es 27.
* El género de Ana es Femenino.

Objetos y Comportamientos

El comportamiento determina el protocolo del objeto.

Ejemplo: Sea la clase PERSONA y el objeto ANA:
* Ana es mayor de edad.
* Ana habla.
* Ana compra tickets.
* Ana viaja en avión.
* Ana entra a un hotel.

Conceptos Fundamentales: El ADN de la POO

Antes de lanzarnos al código, es crucial dominar el vocabulario. Estos son los términos que usaréis a diario.

Para visualizar esta diferencia fundamental entre la plantilla y la creación, aquí tenéis un diagrama.

graph TD
    subgraph "El Plano (Clase)"
        A["class Coche
        - marca: String
        - modelo: String
        - velocidad: int
        + acelerar()
        + frenar()"]
    end

    subgraph "Los Objetos (Instancias)"
        B["Objeto: miCoche
        marca = 'Ford'
        modelo = 'Focus'
        velocidad = 20"]
        C["Objeto: tuCoche
        marca = 'Tesla'
        modelo = 'Model 3'
        velocidad = 100"]
    end

    A -- "Instanciación" --> B
    A -- "Instanciación" --> C

Los 4 Pilares de la Programación Orientada a Objetos

La POO no es solo una forma de organizar el código; es un paradigma que se sostiene sobre cuatro pilares conceptuales. Entenderlos es entender por qué la POO ha dominado el desarrollo de software durante décadas.

Encapsulación: Tu Código como una Caja Fuerte

La encapsulación consiste en agrupar datos (atributos) y los métodos que operan sobre esos datos dentro de una misma unidad (la clase), y controlar el acceso a esos datos. La idea es proteger la información de manipulaciones indebidas.

Los atributos se declaran como private, haciéndolos inaccesibles desde fuera de la clase. El único modo de interactuar con ellos es a través de los métodos públicos (public) de la clase, que actúan como una interfaz segura.

graph TD
    subgraph Objeto_Coche ["Objeto Coche"]
        direction TB

        subgraph Interfaz_Publica ["Interfaz Pública (Métodos)"]
            A[acelerar #40;#41;]
            B[frenar #40;#41;]
            C[getVelocidad #40;#41;]
        end

        subgraph Estado_Privado ["Estado Privado (Atributos)"]
            D[velocidad: int]
            E[marchaActual: int]
            F[...otros detalles...]
        end

        %% Relaciones internas (métodos acceden al estado)
        A -.-> D
        B -.-> D
        C -.-> D
    end

    subgraph Mundo_Exterior ["Mundo Exterior"]
       G[Conductor]
    end

    %% Relaciones válidas
    G -- "Puede usar" --> A
    G -- "Puede usar" --> B
    G -- "Puede usar" --> C

    %% Relación prohibida
    G -.->|"NO PUEDE ACCEDER"| D

Abstracción: Simplificando la Complejidad

La abstracción se centra en mostrar solo las características esenciales de un objeto, ocultando los detalles irrelevantes o complejos de su implementación. Es el resultado directo de la encapsulación.

Cuando usas el método coche.frenar(), no necesitas saber si el sistema de frenos es de disco, de tambor o ABS. Solo necesitas saber que el coche va a reducir su velocidad. La clase Coche abstrae la complejidad del frenado en un método simple.

Herencia: Reutilización de Código Genética

La herencia permite crear nuevas clases (clases hijas o subclases) que reutilizan, extienden y modifican el comportamiento definido en otras clases (clases padres o superclases).

Una clase Coche y una clase Moto tienen mucho en común: ambas son vehículos, tienen un motor, aceleran y frenan. En lugar de repetir ese código, podemos crear una clase Vehiculo con esos atributos y métodos comunes, y hacer que Coche y Moto hereden de ella.

classDiagram
    class Vehiculo {
        -int velocidad
        +acelerar()
        +frenar()
    }

    class Coche {
        -int numeroPuertas
        +abrirMaletero()
    }

    class Moto {
        -boolean tieneSidecar
        +hacerCaballito()
    }

    Vehiculo <|-- Coche
    Vehiculo <|-- Moto

Polimorfismo: Una Acción, Múltiples Formas

El polimorfismo (del griego, "muchas formas") permite que objetos de diferentes clases respondan al mismo mensaje (la misma llamada a un método) de maneras distintas y específicas para cada clase.

Por ejemplo, podríamos tener un método mover() en varias clases. Para un objeto de la clase Pajaro, mover() implicaría volar. Para un Pez, implicaría nadar. Para un Coche, rodar. Aunque llamemos al mismo método, el comportamiento es diferente según el objeto.

// Suponiendo que Pajaro y Pez heredan de una clase Animal que tiene un método mover()
Animal miMascota = new Pajaro();
Animal tuMascota = new Pez();

miMascota.mover(); // Llama al método volar() del Pájaro
tuMascota.mover(); // Llama al método nadar() del Pez

Mensajes

Un objeto sin comunicación con el mundo exterior no es de utilidad. Los objetos deben relacionarse e interactúan entre ellos mediante mensajes. Cuando un objeto A quiere que otro objeto B ejecute una de sus funciones o procedimientos (métodos de B), el objeto A manda un mensaje al objeto B.

Un mensaje consta de 3 partes:
1. Identidad del receptor: Nombre del objeto que contiene el método a ejecutar.
2. Nombre del método a ejecutar: Solo los métodos declarados públicos.
3. Lista de Parámetros: que recibe el método (cero o más parámetros).

graph TD
    A(Objeto Emisor) --> B(Objeto Receptor);
    B --> A;

Especificación de Clases

Las clases se especifican por medio de un nombre, el estado o estructura interna que tendrán sus instancias y los métodos asociados que definen el comportamiento.

classDiagram
    class Auto {
        -marca: string
        -modelo: string
        -combustible: int
        +arrancar()
        +propietario(unaPersona)
        +kilometraje()
        +cargar(combustible)
    }

Identificadores: Son los nombres que pueden tener las clases, los métodos y las variables y no pueden contener espacios ni caracteres especiales. Aunque no es obligatorio (el código funcionará igual), estos nombres deben respetar ciertas convenciones según el tipo de identificador:

Para modelar gráficamente las clases, objetos y relaciones utilizaremos el estándar UML:

Anatomía de una Clase en Java: Manos a la Obra

A continuación se especifica el esquema de definición de una clase:

[ámbito] class NombreDeLaClase {
    // Definición de atributos
    [ámbito] tipo nombreVar1;
    [ámbito] tipo nombreVar2;

    ...

    // Definición de métodos

    // Constructores
    ...
    // Otros métodos

}

Veamos en detalle cómo se construye una clase en Java, pieza a pieza.

// Modificador de acceso: 'public' la hace visible desde cualquier otra clase.
public class CuentaBancaria {

    // 1. ATRIBUTOS (Variables de instancia)
    // Siempre 'private' para una buena encapsulación.
    private String titular;
    private String iban;
    private double saldo;

    // 2. CONSTRUCTOR
    // Se ejecuta al crear un objeto. Su misión es inicializar los atributos.
    public CuentaBancaria(String titular, String iban) {
        this.titular = titular;
        this.iban = iban;
        this.saldo = 0.0; // Se inicializa a 0 por defecto al abrir la cuenta.
    }

    // 3. MÉTODOS
    // Comportamientos del objeto.

    // Getter para el saldo (solo consulta)
    public double getSaldo() {
        return this.saldo;
    }

    // Método para ingresar dinero (modifica el estado)
    public void ingresar(double cantidad) {
        if (cantidad > 0) {
            this.saldo += cantidad;
        }
    }

    // Método para retirar dinero
    public void retirar(double cantidad) {
        if (cantidad > 0 && this.saldo >= cantidad) {
            this.saldo -= cantidad;
        } else {
            System.out.println("Operación denegada. Saldo insuficiente o cantidad inválida.");
        }
    }
}

Comparativa de Acceso a Atributos

Ejemplo de Clase e instanciación

Creación de la clase Triangulo:

/**
 * La clase Triangulo representa un triángulo con una base, altura, color y una posición de vértice.
 */
public class Triangulo {
    // --- ATRIBUTOS ---
    private double base;      // La base del triángulo
    private double altura;    // La altura del triángulo
    private String color;     // El color del triángulo
    private int verticeAX, verticeAY; // Coordenadas del vértice A como punto de referencia

    /**
     * Constructor por defecto.
     * Crea un triángulo con base 100, altura 100, color "azul" y vértice A en (100,100).
     */
    public Triangulo() {
        base = 100;
        altura = 100;
        color = "azul";
        verticeAX = 100;
        verticeAY = 100;
    }

    // --- MÉTODOS ---

    /**
     * Consulta la base del triángulo.
     * @return La base actual del triángulo.
     */
    public double getBase() {
        return base;
    }

    /**
     * Actualiza la base del triángulo.
     * @param nuevaBase El nuevo valor para la base.
     */
    public void setBase(double nuevaBase) {
        base = nuevaBase;
    }

    /**
     * Consulta la altura del triángulo.
     * @return La altura actual del triángulo.
     */
    public double getAltura() {
        return altura;
    }

    /**
     * Actualiza la altura del triángulo.
     * @param nuevaAltura El nuevo valor para la altura.
     */
    public void setAltura(double nuevaAltura) {
        altura = nuevaAltura;
    }

    /**
     * Reduce las dimensiones (base y altura) del triángulo en un factor de 1.5.
     */
    public void reducirDimensiones() {
        base = base / 1.5;
        altura = altura / 1.5;
    }

    /**
     * Calcula el área del triángulo.
     * @return El área calculada del triángulo.
     */
    public double area() {
        return (base * altura) / 2;
    }

    /**
     * Obtiene una representación en String con las propiedades del triángulo.
     * @return Un String con los detalles del triángulo.
     */
    public String toString() {
        return "Triángulo de base " + base + ", altura " + altura + ", color " + color + " y vértice de referencia en (" + verticeAX + "," + verticeAY + ")";
    }
}

Y su instanciación:

public class ProgramaTriangulo {
    public static void main(String[] args) {
        // Crear un objeto de la clase Triangulo
        Triangulo t1 = new Triangulo();

        // Modificar sus atributos usando los métodos set
        t1.setBase(15.5);
        t1.setAltura(20.2);

        // Imprimir los datos del triángulo en la consola
        System.out.println("Los datos del triángulo son: " + t1.toString());

        // Calcular e imprimir el área del triángulo
        System.out.println("El área del triángulo es: " + t1.area());
    }
}

Ámbito de declaración: private y public

• Toda la información (atributos o métodos) declarada como private es exclusiva del objeto y resulta inaccesible desde fuera de la clase.

  • Cualquier intento de acceso a las variables de instancia base, altura o color que se realice desde fuera de la clase Triangulo (p. ej., en la clase ProgramaTriangulo) dará un error de compilación.

  private double base;
  private double altura;
  private String color;
  

• Toda la información declarada como public es accesible desde fuera de la clase, permitiendo la comunicación con el objeto.

  • Es el caso de los métodos getBase() o area() de la clase Triangulo, que pueden ser invocados desde cualquier otra clase.

  public double getBase() {
      return base;
  }
  

  public double area() {
      return (base * altura) / 2;
  }
  

  ¡Por supuesto! A continuación, tienes una adaptación completa y ampliada del contenido de las imágenes, utilizando el ejemplo de la clase Triangulo y formateado en Markdown para MkDocs.

Modificadores de Acceso: Controlando la Visibilidad

En Java, los modificadores de acceso son palabras clave que definen el nivel de visibilidad de las clases, atributos y métodos. Determinan desde dónde se puede acceder a estos elementos, siendo una pieza fundamental del principio de encapsulación.

Modificadores para Atributos y Métodos

Estos modificadores se aplican a los miembros de una clase (sus variables y métodos):

• public: Es el nivel menos restrictivo. Un miembro public puede ser accedido desde cualquier otra clase, sin importar el paquete en el que se encuentre.

  • Ejemplo en Triangulo: Los métodos como getBase() o area() son públicos para que un objeto Triangulo pueda ser manipulado desde el exterior.

• private: Es el nivel más restrictivo. Un miembro private solo puede ser accedido desde dentro de la misma clase donde fue declarado. Es la base de la encapsulación, ya que oculta el estado interno del objeto y fuerza a que la interacción se realice a través de métodos públicos (getters y setters).

  • Ejemplo en Triangulo: Los atributos base y altura son privados. No podemos hacer miTriangulo.base = 10; desde otra clase; debemos usar miTriangulo.setBase(10);.

• protected: Este modificador está ligado al concepto de herencia. Un miembro protected es accesible desde la propia clase, desde cualquier clase del mismo paquete y, muy importante, desde cualquier subclase (clase hija), incluso si esta se encuentra en un paquete diferente.

• Sin modificador (default o package-private): Si no se especifica ningún modificador, el miembro tiene acceso a nivel de paquete. Esto significa que solo puede ser accedido por clases que se encuentren en el mismo paquete.

Nota importante: Estos modificadores se pueden aplicar a cualquier miembro de la clase, incluidos los constructores. Hacer un constructor privado es una técnica utilizada en patrones de diseño como el Singleton, donde se quiere controlar de forma estricta cómo y cuándo se crean las instancias de una clase.

Modificadores para Clases

Las clases en sí mismas también pueden tener modificadores de acceso, aunque sus opciones son más limitadas:

• public: Una clase public puede ser utilizada por cualquier otra clase en cualquier paquete del proyecto. Para que una clase sea pública, el nombre del archivo .java debe coincidir exactamente con el nombre de la clase.

  • Ejemplo: public class Triangulo { ... }

• Sin modificador (default): Si una clase no tiene modificador, solo puede ser utilizada e instanciada por otras clases que pertenezcan al mismo paquete.

Las clases de nivel superior (no anidadas) no pueden ser declaradas private ni protected.

Elementos Fundamentales de una Clase

Atributos (Variables de Instancia)

Los atributos, también conocidos como variables de instancia o campos, representan el estado de un objeto. Son los datos que definen a cada instancia particular de la clase. Se declaran con un tipo de dato y, por convención y buena práctica de encapsulación, su ámbito casi siempre será private.

La sintaxis general para definirlos es:

// Definición genérica de atributos
[ámbito] tipo nombreVariable1;
[ámbito] tipo nombreVariable2;

Aplicado a nuestra clase Triangulo:

public class Triangulo {
    // --- Definición de atributos ---
    // Representan el estado interno de cada objeto Triangulo

    private double base;      // Almacena la longitud de la base
    private double altura;    // Almacena la altura del triángulo
    private String color;     // Almacena el color
    private int verticeAX, verticeAY; // Coordenadas de un punto de referencia

    // ... resto de la clase
}

Métodos

Los métodos definen el comportamiento de los objetos. Son las acciones u operaciones que una instancia de la clase puede realizar. Un método se compone de dos partes principales:

1. La cabecera (o firma del método): Define el nombre, el tipo de dato que devuelve, el modificador de acceso y la lista de parámetros que necesita para funcionar.
2. El cuerpo: Contiene el conjunto de instrucciones que se ejecutan cuando el método es invocado.

Aplicado a nuestra clase Triangulo, el método area() sería:

public class Triangulo {
    // ... atributos

    // --- Definición de un método ---

    // Cabecera: public double area()
    // Cuerpo: { return (base * altura) / 2; }
    public double area() {
        // Esta es la lógica para calcular el área
        return (base * altura) / 2;
    }

    // ... resto de la clase
}

Métodos de Acceso y Modificación: Getters y Setters

Para interactuar con los atributos privados desde fuera de la clase, se utilizan métodos públicos específicos conocidos como Getters y Setters.

• Getters (Consultores): Permiten obtener el valor de un atributo. Suelen tener el prefijo get seguido del nombre del atributo. No modifican el estado del objeto.
• Setters (Modificadores): Permiten modificar el valor de un atributo. Suelen tener el prefijo set seguido del nombre del atributo. Son el lugar ideal para añadir lógica de validación y asegurar que el objeto no llegue a un estado inválido.

No es obligatorio que cada atributo tenga su getter y setter. Una buena práctica de encapsulación es exponer solo los que sean estrictamente necesarios.

Ejemplo simple vs. Ejemplo con validación para Triangulo:

// Getter para la base
public double getBase() {
    return base;
}

// Setter simple
public void setBase(double nuevaBase) {
    base = nuevaBase;
}

// Getter para la base
public double getBase() {
    return base;
}

// Setter con lógica de validación
public void setBase(double nuevaBase) {
    if (nuevaBase > 0) {
        base = nuevaBase;
    } else {
        // Evita valores no válidos
        base = 0; 
    }
}

Sobrecarga de Constructores en Java

La sobrecarga de constructores es una característica de la programación orientada a objetos que permite a una clase tener múltiples constructores, siempre y cuando sus listas de parámetros sean diferentes. Esto significa que podemos tener varios métodos con el mismo nombre (el de la clase) pero que se distinguen por el número de parámetros, el tipo de los parámetros o el orden de los mismos.

Esta técnica proporciona flexibilidad a la hora de crear objetos. Permite definir diferentes maneras de inicializar una instancia, ya sea con valores por defecto, con un conjunto parcial de datos o con toda la información necesaria.

Aplicando la Sobrecarga a la Clase Triangulo

Imaginemos que queremos crear objetos de la clase Triangulo de varias formas:

1. Un triángulo por defecto: Sin especificar ningún dato, queremos que se cree un triángulo con dimensiones y color predefinidos.
2. Un triángulo especificando sus dimensiones: Queremos crearlo indicando solo la base y la altura, asumiendo un color por defecto.
3. Un triángulo completamente personalizado: Queremos crearlo especificando la base, la altura y también el color.

Para lograr esto, implementamos tres constructores en nuestra clase Triangulo.

/**
 * La clase Triangulo representa una figura geométrica con base, altura y color.
 * Demuestra la sobrecarga de constructores para ofrecer flexibilidad en la creación de objetos.
 */
public class Triangulo {
    // --- Atributos privados ---
    private double base;
    private double altura;
    private String color;

    /**
     * --- 1. Constructor por defecto (sin parámetros) ---
     * Crea un triángulo con valores predeterminados.
     * Ideal para cuando se necesita una instancia genérica rápidamente.
     */
    public Triangulo() {
        this.base = 10.0;      // Base por defecto
        this.altura = 10.0;    // Altura por defecto
        this.color = "Rojo";   // Color por defecto
    }

    /**
     * --- 2. Constructor sobrecargado (con dos parámetros) ---
     * Crea un triángulo especificando su base y altura.
     * El color se asigna a un valor por defecto.
     * @param base La base del triángulo.
     * @param altura La altura del triángulo.
     */
    public Triangulo(double base, double altura) {
        this.base = base;
        this.altura = altura;
        this.color = "Azul";   // Color por defecto para esta versión
    }

    /**
     * --- 3. Constructor sobrecargado (con todos los parámetros) ---
     * Crea un triángulo totalmente personalizado, especificando todos sus atributos.
     * @param base La base del triángulo.
     * @param altura La altura del triángulo.
     * @param color El color del triángulo.
     */
    public Triangulo(double base, double altura, String color) {
        this.base = base;
        this.altura = altura;
        this.color = color;
    }

    // --- Métodos de la clase (getters, setters, etc.) ---

    /**
     * Devuelve una representación en String del estado del objeto.
     */
    @Override
    public String toString() {
        return "Triangulo [base=" + base + ", altura=" + altura + ", color='" + color + "']";
    }
}

¿Cómo se utiliza?

Java sabe qué constructor invocar basándose en los argumentos que se le pasan al crear el objeto con la palabra clave new.

public class ProgramaPrincipal {
    public static void main(String[] args) {

        // 1. Usando el constructor por defecto (sin parámetros)
        Triangulo trianguloPorDefecto = new Triangulo();
        System.out.println("1. Triángulo por defecto: " + trianguloPorDefecto.toString());
        // Salida: 1. Triángulo por defecto: Triangulo [base=10.0, altura=10.0, color='Rojo']

        // 2. Usando el constructor con dos parámetros (base y altura)
        Triangulo trianguloConDimensiones = new Triangulo(25.5, 30.0);
        System.out.println("2. Triángulo con dimensiones: " + trianguloConDimensiones.toString());
        // Salida: 2. Triángulo con dimensiones: Triangulo [base=25.5, altura=30.0, color='Azul']

        // 3. Usando el constructor con todos los parámetros
        Triangulo trianguloPersonalizado = new Triangulo(5.0, 8.0, "Verde");
        System.out.println("3. Triángulo personalizado: " + trianguloPersonalizado.toString());
        // Salida: 3. Triángulo personalizado: Triangulo [base=5.0, altura=8.0, color='Verde']
    }
}

Ventajas de la Sobrecarga de Constructores

• Flexibilidad: Proporciona múltiples formas de instanciar un objeto, adaptándose a diferentes necesidades.
• Código más limpio: Evita tener que crear un objeto y luego llamar a varios métodos set para inicializarlo. La inicialización se hace en un solo paso.
• Mejora la legibilidad: Al leer new Triangulo(10, 20), es evidente que se está creando un triángulo con dimensiones específicas.
• Valores por defecto: Facilita el establecimiento de valores predeterminados de manera controlada y centralizada.

Clasificación de Métodos según su Función

Podemos clasificar los métodos de una clase según el propósito que cumplen:

• Constructores: Métodos especiales que permiten crear e inicializar un objeto. Tienen el mismo nombre que la clase y no devuelven ningún valor.
• Modificadores (Setters): Permiten modificar el estado del objeto (los valores de sus atributos).
• Consultores (Getters): Permiten conocer el estado del objeto sin cambiarlo.
• Métodos de comportamiento: Realizan operaciones o cálculos utilizando los atributos del objeto. El método area() es un ejemplo perfecto.

Aquí tienes la clase Triangulo completa con ejemplos de cada tipo de método:

public class Triangulo {
    // --- Atributos ---
    private double base;
    private double altura;
    private String color;

    // --- Constructor ---
    // Se invoca al crear un nuevo objeto: new Triangulo()
    public Triangulo(double baseInicial, double alturaInicial, String colorInicial) {
        // Usamos los setters para asegurar la validación desde el inicio
        setBase(baseInicial);
        setAltura(alturaInicial);
        this.color = colorInicial;
    }

    // --- Métodos Consultores (Getters) ---
    public double getBase() {
        return this.base;
    }

    public double getAltura() {
        return this.altura;
    }

    // --- Métodos Modificadores (Setters) ---
    public void setBase(double nuevaBase) {
        if (nuevaBase > 0) {
            this.base = nuevaBase;
        }
    }

    public void setAltura(double nuevaAltura) {
        if (nuevaAltura > 0) {
            this.altura = nuevaAltura;
        }
    }

    // --- Método de Comportamiento ---
    public double area() {
        return (this.base * this.altura) / 2;
    }
}

Métodos: El Comportamiento de las Clases

Los métodos son el corazón de una clase. Definen su comportamiento, es decir, las operaciones y acciones que un objeto de esa clase puede realizar. Mientras que los atributos almacenan el estado de un objeto (qué es), los métodos definen lo que el objeto hace.

Anatomía de la Declaración de un Método

La estructura para declarar un método en Java sigue una sintaxis precisa que define su visibilidad, comportamiento y lo que devuelve.

La sintaxis completa es:

[acceso] [static] [final] tipoRetorno nombreMetodo([argumentos]) {
    /*
     * Cuerpo del método:
     * Contiene las instrucciones a ejecutar.
     */
}

Analicemos cada componente:

• acceso: Es el modificador de acceso. Define desde dónde se puede llamar al método. Los valores posibles son:

  • public: Accesible desde cualquier clase.
  • private: Accesible solo desde dentro de la misma clase.
  • protected: Accesible desde la clase, clases del mismo paquete y subclases.
  • Sin modificador (package-private): Accesible solo por clases en el mismo paquete.

• static (opcional): La palabra clave static indica que el método pertenece a la clase en sí, no a una instancia (objeto) particular. Esto significa que se puede invocar sin necesidad de crear un objeto de la clase. Son también conocidos como "métodos de clase". > Ejemplo: Podríamos crear un método estático para validar las dimensiones de un triángulo antes de crearlo: public static boolean sonDimensionesValidas(double base, double altura). Se llamaría directamente desde la clase: if (Triangulo.sonDimensionesValidas(10, 5)) { ... }.

• final (opcional): La palabra clave final evita que un método pueda ser sobrescrito por una subclase en la herencia. Lo convierte en la implementación definitiva de ese método.

• tipoRetorno: Especifica el tipo de dato del valor que el método devuelve al finalizar su ejecución. Puede ser un tipo primitivo (int, double, boolean) o un objeto (String, Triangulo). Si el método no devuelve ningún valor, se utiliza la palabra clave void.

• nombreMetodo: Es el identificador o nombre del método. Por convención en Java, los nombres de métodos empiezan con una letra minúscula y siguen el formato camelCase (ej. calcularArea).

• [argumentos]: Es la lista de parámetros que el método necesita para operar. Cada parámetro se define con su tipo y nombre, y van separados por comas. Si un método no necesita ningún dato de entrada, los paréntesis se dejan vacíos.

El Método Especial: El Constructor

El constructor es un método único y fundamental que se invoca automáticamente cada vez que se crea una nueva instancia (objeto) de una clase con la palabra new.

Características principales:

1. Mismo nombre que la clase: Un constructor siempre se llama igual que la clase.
2. Sin tipo de retorno: Es el único método que no tiene tipoRetorno, ni siquiera void.
3. Misión principal: Su propósito es reservar memoria para el objeto e inicializar sus atributos, asegurando que el objeto nazca en un estado válido y coherente.

public class Triangulo {
    private double base;
    private double altura;

    // --- CONSTRUCTOR ---
    // Este método se llama con: new Triangulo(15.0, 20.0);
    public Triangulo(double base, double altura) {
        System.out.println("¡Creando un nuevo triángulo!");
        this.base = base;
        this.altura = altura;
    }
}

Constructor por Defecto

Si no defines ningún constructor en tu clase, Java proporciona uno automáticamente. Este se llama constructor por defecto. * No tiene argumentos. * Inicializa los atributos a sus valores por defecto: * Tipos numéricos (int, double): 0 o 0.0. * boolean: false. * Objetos y Strings: null.

En cuanto defines al menos un constructor, pierdes el constructor por defecto que Java te regalaba. Si lo necesitas, debes definirlo explícitamente.

Invocación y Sobrecarga de Métodos

Invocación de Métodos

Para llamar a un método de un objeto (un método de instancia), se utiliza el operador punto (.) sobre la instancia.

// Sintaxis: nombreInstancia.nombreMetodo(argumentos);

Triangulo miTriangulo = new Triangulo(10.0, 5.0); // Se invoca el constructor
double areaDelTriangulo = miTriangulo.area();      // Se invoca el método area()
System.out.println("El área es: " + areaDelTriangulo);

La única excepción son los métodos static, que se invocan usando el nombre de la clase, no de la instancia.

Sobrecarga de Métodos

La sobrecarga permite definir varios métodos con el mismo nombre dentro de la misma clase, siempre y cuando se diferencien en su lista de parámetros (ya sea en el número de parámetros o en el tipo de dato de los mismos).

Importante: El tipo de retorno no es suficiente para diferenciar dos métodos sobrecargados. La firma del método (nombre y parámetros) debe ser única.

public class Triangulo {
    // ... atributos y constructores

    // Método para escalar el triángulo con un único factor
    public void escalar(double factor) {
        this.base *= factor;
        this.altura *= factor;
    }

    // Sobrecarga del método: escalar la base y la altura con factores diferentes
    public void escalar(double factorBase, double factorAltura) {
        this.base *= factorBase;
        this.altura *= factorAltura;
    }
}

Variables Locales dentro de Métodos

Los métodos pueden declarar sus propias variables para realizar cálculos intermedios. Estas se conocen como variables locales.

• Visibilidad limitada: Una variable local solo existe y es visible dentro del método donde fue declarada. No se puede acceder a ella desde fuera.
• No se inicializan por defecto: A diferencia de los atributos de instancia, las variables locales deben ser inicializadas explícitamente antes de ser utilizadas. De lo contrario, se producirá un error de compilación.

Buena práctica: Es recomendable no declarar variables locales que no sean estrictamente necesarias. Esto hace el código más conciso y legible.

// Método para calcular el perímetro de un
// triángulo rectángulo
public double calcularPerimetroRectangulo() {
    // 'hipotenusa' es una variable local
    double hipotenusa = Math.sqrt((base * base) + (altura * altura));
    double perimetro = base + altura + hipotenusa;
    return perimetro;
}

// Versión más directa sin variables locales
// intermedias.
public double calcularPerimetroRectangulo() {
    return base + altura + Math.sqrt((base * base) + (altura * altura));
}

El Origen de los Objetos: Constructores y "this"

Ya hemos visto el constructor en acción, pero su poder va más allá de la simple inicialización. La capacidad de sobrecargarlos y de encadenarlos es fundamental para crear clases flexibles y robustas.

La Palabra Clave this en Java

En Java, this es una palabra reservada que actúa como una referencia al objeto actual, es decir, a la instancia sobre la cual se está ejecutando un método o un constructor.

Piensa en this como una forma que tiene un objeto de referirse a sí mismo. Está disponible implícitamente en todos los constructores y métodos de instancia (no estáticos).

Sus dos usos principales y más importantes son: 1. Desambiguar variables de instancia (atributos) de parámetros o variables locales. 2. Invocar un constructor desde otro constructor de la misma clase.

Uso 1: Desambiguación de Variables

Este es el uso más común de this. Ocurre cuando un parámetro de un método o constructor tiene el mismo nombre que un atributo de la clase. En este caso, el nombre del parámetro "oculta" (hace sombra) al nombre del atributo. Para resolver esta ambigüedad, usamos this.nombreAtributo para referirnos explícitamente al atributo de la instancia.

¿Por qué es esto una práctica común? Es una convención de código muy extendida y recomendada nombrar los parámetros de los constructores y setters igual que los atributos que van a inicializar. Hace el código más intuitivo y fácil de leer.

Veamos el ejemplo en la clase Triangulo:

public class Triangulo {
    private double base;
    private double altura;

    // AMBIGÜEDAD: ¿cuál es cuál?
    public Triangulo(double base, double altura) {
        // ERROR: se está asignando el valor del
        // parámetro 'base' a sí mismo.
        // El atributo de la clase no se modifica.
        base = base;
        altura = altura;
    }
}

public class Triangulo {
    private double base;
    private double altura;

    // CORRECTO: 'this' desambigua
    public Triangulo(double base, double altura) {
        // this.base -> se refiere al ATRIBUTO
        // base -> se refiere al PARÁMETRO
        this.base = base;
        this.altura = altura;
    }
}

En el ejemplo de la derecha, this.base se refiere sin lugar a dudas al atributo de la instancia Triangulo, mientras que base (a la derecha del =) se refiere al parámetro que se recibe en el constructor.

Uso 2: Invocación de Constructores (Constructor Chaining)

Una clase puede tener varios constructores sobrecargados. A menudo, un constructor es una versión más simple de otro. Para evitar la duplicación de código y centralizar la lógica de inicialización, un constructor puede llamar a otro constructor de la misma clase.

Esto se conoce como encadenamiento de constructores (constructor chaining).

Para hacerlo, se utiliza la sintaxis this(...), pasando los argumentos correspondientes al constructor que se quiere invocar.

Regla de oro: La llamada this(...) debe ser obligatoriamente la primera sentencia dentro del cuerpo del constructor. No puede haber ninguna otra línea de código antes.

Veamos cómo aplicar esto en nuestra clase Triangulo para mejorarla:

Versión Ineficiente (Código Duplicado)

public class Triangulo {
    private double base;
    private double altura;
    private String color;

    // Constructor por defecto
    public Triangulo() {
        base = 10.0;
        altura = 10.0;
        color = "Rojo";
    }

    // Constructor con dimensiones
    public Triangulo(double base, double altura) {
        this.base = base;
        this.altura = altura;
        color = "Azul"; // Código similar al de arriba
    }
}

Versión Eficiente con this(...)

En esta versión, definimos un constructor "principal" que se encarga de toda la inicialización, y los demás constructores simplemente lo llaman con los valores adecuados.

public class Triangulo {
    private double base;
    private double altura;
    private String color;

    /**
     * Constructor principal que realiza toda la inicialización.
     */
    public Triangulo(double base, double altura, String color) {
        System.out.println("Ejecutando constructor principal...");
        this.base = base;
        this.altura = altura;
        this.color = color;
    }

    /**
     * Constructor que solo recibe dimensiones.
     * Llama al constructor principal con un color por defecto.
     */
    public Triangulo(double base, double altura) {
        // Llama al constructor de 3 parámetros de ESTA misma clase
        this(base, altura, "Azul"); 
    }

    /**
     * Constructor por defecto.
     * Llama al constructor de 2 parámetros, que a su vez llamará al de 3.
     */
    public Triangulo() {
        // Llama al constructor de 2 parámetros de ESTA misma clase
        this(10.0, 10.0);
    }
}

Al usar new Triangulo(), se llamará al constructor de dos parámetros this(10.0, 10.0), y este a su vez llamará al constructor principal this(10.0, 10.0, "Azul"), centralizando la lógica y haciendo el código mucho más mantenible.

this(): Constructor Chaining

Imagina que tienes varios constructores y gran parte del código de inicialización se repite. Sería una violación del principio DRY (Don't Repeat Yourself). La solución es que los constructores más simples llamen a los más complejos, proporcionando valores por defecto.

Ejemplo: Clase Producto

Vamos a modelar un producto para una tienda online. Un producto puede crearse de varias formas: con todos sus datos, solo con los esenciales, o incluso como un producto genérico.

/**
 * Representa un producto en un inventario.
 * Demuestra sobrecarga de constructores y constructor chaining.
 */
public class Producto {
  private final String sku; // Stock Keeping Unit, identificador único
  private String nombre;
  private double precio;
  private int stock;

  /** Constructor principal y más completo. Toda la lógica de inicialización está aquí. */
  public Producto(String sku, String nombre, double precio, int stock) {
    // La palabra clave 'this' es necesaria para distinguir el atributo del parámetro.
    this.sku = sku;
    this.nombre = nombre;
    this.precio = precio;
    this.stock = stock;
  }

  /** Constructor para productos nuevos donde el stock inicial es 0. */
  public Producto(String sku, String nombre, double precio) {
    // Llama al constructor principal, pasando 0 como stock por defecto.
    this(sku, nombre, precio, 0);
  }

  /** Constructor para un producto "borrador" solo con SKU y nombre. */
  public Producto(String sku, String nombre) {
    // Llama al segundo constructor, que a su vez llamará al primero.
    this(sku, nombre, 0.0);
  }

  // ... (getters y setters)

  public void mostrarDetalle() {
    System.out.println("=======================");
    System.out.println("SKU: " + this.sku);
    System.out.println("Nombre: " + this.nombre);
    System.out.printf("Precio: %.2f €\n", this.precio);
    System.out.println("Stock: " + this.stock + " unidades");
    System.out.println("=======================");
  }
}

public class GestionAlmacen {
  public static void main(String[] args) {
    Producto portatil = new Producto("LAP-ASUS-123", "ASUS Zenbook", 999.99, 50);
    Producto raton = new Producto("PER-LOGI-456", "Logitech MX Master 3", 89.90); // Stock 0
    Producto teclado = new Producto("PER-KEY-789", "Keychron K2"); // Stock 0, Precio 0.0

    portatil.mostrarDetalle();
    raton.mostrarDetalle();
    teclado.mostrarDetalle();
  }
}

Miembros Estáticos: Atributos y Métodos de Clase

Los miembros static son compartidos por todos los objetos de una clase. Son como un tablón de anuncios en la oficina de la fábrica: todos los trabajadores (objetos) pueden verlo y algunos pueden escribir en él, y la información es la misma para todos.

En Java, cuando un miembro (un atributo o un método) se declara con la palabra clave static, deja de pertenecer a las instancias individuales (objetos) y pasa a pertenecer a la clase en su conjunto.

Piensa en ello de esta manera: * Miembros de instancia (no estáticos): Son como las propiedades de una nave (su nombre, su nivel de energía). Cada nave (instancia) tiene sus propias copias de estas propiedades. * Miembros estáticos (de clase): Son como el registro de la Flota Estelar. El registro es único y compartido por todas las naves; no es una propiedad individual de cada una.

Atributos Estáticos (Variables de Clase)

Un atributo estático es una variable cuyo valor es compartido por todas las instancias de la clase. Solo existe una única copia de esta variable en memoria, sin importar cuántos objetos se creen (o incluso si no se crea ninguno).

Características clave:

• No es específico de un objeto: Su valor no define el estado de una instancia particular, sino un estado global de la clase.
• Valor compartido: Si una instancia modifica el valor de un atributo estático, el cambio será visible para todas las demás instancias.
• Existe sin objetos: Se puede acceder a él incluso si no se ha creado ningún objeto de la clase.
• Acceso: Se accede utilizando el nombre de la clase, seguido de un punto y el nombre del atributo. La sintaxis es NombreClase.nombreAtributoEstatico.

Ejemplo: Contador de Naves en la Flota

Vamos a añadir una funcionalidad a nuestra clase NaveEspacial para que lleve la cuenta de cuántos objetos de su tipo han sido comisionados en la flota. Un atributo estático es perfecto para esto.

public class NaveEspacial {
    // --- Atributos de Instancia ---
    private String nombre;
    private double nivelDeEnergia;

    // --- Atributo Estático (de Clase) ---
    // Esta variable es compartida por todas las naves de la flota.
    private static int contadorNaves = 0;

    // El constructor se ejecuta cada vez que se comisiona una nueva nave.
    public NaveEspacial(String nombre, double nivelDeEnergia) {
        this.nombre = nombre;
        this.nivelDeEnergia = nivelDeEnergia;

        // Incrementamos el contador estático de la flota.
        contadorNaves++;
    }

    // ... otros métodos de la clase
}

Métodos Estáticos (Métodos de Clase)

Un método estático es un método que pertenece a la clase y no opera sobre una instancia específica. Se puede invocar directamente desde la clase sin necesidad de crear un objeto.

Características clave:

• No necesita una instancia: Se puede llamar usando la sintaxis NombreClase.nombreMetodo().
• Limitación fundamental: Un método estático no puede acceder a miembros de instancia (atributos o métodos no estáticos). Esto es lógico, ya que el método no sabe sobre qué instancia específica debería operar.
• No puede usar this: Como no está asociado a ninguna instancia, la referencia this no existe en un contexto estático.
• Acceso: Solo pueden acceder directamente a otros miembros estáticos de la clase.
• Utilidad: Son perfectos para crear funciones de utilidad o para operar sobre atributos estáticos.

Ejemplo: Getter para el contador y una función de utilidad

1. Crearemos un método estático para obtener el número total de naves en la flota.
2. Crearemos un método de utilidad que, dado un nivel de potencia, calcule la velocidad teórica de curvatura (warp). Esta es una ley física del universo, no depende de una nave concreta.

public class NaveEspacial {
    // ... Atributos (incluido el contador estático) y constructor

    // --- Método Estático (de Clase) ---
    // Devuelve el valor del contador. Es estático porque accede a un atributo estático.
    public static int getNumeroDeNaves() {
        // NO se puede hacer esto: return this.nombre; (nombre es de instancia)
        return contadorNaves;
    }

    // --- Método Estático de Utilidad ---
    // Este método no depende de ninguna nave en particular.
    public static double calcularVelocidadWarp(int nivelPotencia) {
        // Fórmula de ejemplo
        return Math.pow(nivelPotencia, 10.0/3.0);
    }
}

Poniéndolo todo en práctica:

public class FlotaEstelarApp {
    public static void main(String[] args) {
        // Podemos llamar a los métodos estáticos incluso ANTES de crear naves.
        System.out.println("Naves actuales en la flota: " + NaveEspacial.getNumeroDeNaves()); // Salida: 0

        double velocidadWarp5 = NaveEspacial.calcularVelocidadWarp(5);
        System.out.println("Velocidad teórica a Warp 5: " + velocidadWarp5 + "c");

        System.out.println("\n--- Comisionando naves ---");
        NaveEspacial enterprise = new NaveEspacial("USS Enterprise", 100.0);
        NaveEspacial voyager = new NaveEspacial("USS Voyager", 95.5);

        // Ahora consultamos el contador después de crear las instancias.
        System.out.println("Naves finales en la flota: " + NaveEspacial.getNumeroDeNaves()); // Salida: 2
    }
}

La Palabra Clave final: Creando Constantes

La palabra reservada final es un modificador que se puede aplicar a variables, métodos y clases. Su significado fundamental es que el elemento no puede ser modificado una vez asignado.

• Una variable final: Su valor no puede cambiar después de ser inicializada. Se convierte en una constante.
• Un método final: No puede ser sobrescrito por una subclase (en herencia).
• Una clase final: No puede tener clases hijas; no se puede heredar de ella.

La Combinación Perfecta: static final

Cuando se combinan los modificadores static y final, se crea una constante de clase. Es el mecanismo estándar en Java para definir valores que son universales, fijos y compartidos en toda la aplicación.

• static: asegura que haya una única copia compartida por todos.
• final: asegura que su valor nunca cambie.

Por convención, los nombres de las variables static final se escriben en mayúsculas, separando las palabras con guiones bajos (UPPER_SNAKE_CASE).

Ejemplo: Añadiendo una constante a la clase NaveEspacial

Añadamos una constante que represente la frecuencia de comunicación de emergencia de la Flota Estelar.

public class NaveEspacial {
    // --- Constante de Clase ---
    // Es pública para que cualquier sistema pueda consultarla.
    // Es estática porque es la misma para toda la flota.
    // Es final porque esta frecuencia es un estándar que no cambia.
    public static final double FRECUENCIA_EMERGENCIA_MHZ = 457.525;

    // ... el resto de la clase
}

public class FlotaEstelarApp {
    public static void main(String[] args) {
        // Accedemos a la constante directamente desde la clase.
        System.out.println("Canal de emergencia de la Flota: " + NaveEspacial.FRECUENCIA_EMERGENCIA_MHZ + " MHz.");
    }
}

Memoria: static vs. Instancia

Para entenderlo bien, hay que visualizar cómo se organiza la memoria.

• Área Estática/de Clase: Es un espacio de memoria donde Java carga las clases. Aquí se almacena una única copia de los atributos static.
• Heap: Es el montón de memoria donde se crean los objetos (instancias). Cada objeto tiene su propio espacio con sus propios atributos de instancia.

graph TD
    subgraph "Área de Memoria Estática (Clase)"

        C(class Punto 
        - static contadorPuntos: int)
    end

    subgraph "Heap (Objetos)"

        O1(p1: Punto <br/> - x: 10 <br/> - y: 20)
        O2(p2: Punto <br/> - x: 5 <br/> - y: 15)
        O3(p3: Punto <br/> - x: 0 <br/> - y: 0)
    end

    C -- "contadorPuntos = 3" --> C

    O1 -- "Accede a" --> C
    O2 -- "Accede a" --> C
    O3 -- "Accede a" --> C

Comparativa: static vs. Instancia

Ejemplo: Configuración Global

Los atributos estáticos son perfectos para valores de configuración que deben ser iguales para toda la aplicación.

public class AppConfig {
    // Atributos estáticos para configuración global
    public static final String VERSION = "1.2.0";
    private static String databaseUrl = "jdbc:mysql://localhost:3306/prod_db";
    private static int maxConnections = 10;

    // El constructor privado evita que se creen instancias
    private AppConfig() {}

    public static String getDatabaseUrl() {
        return databaseUrl;
    }

    // Podemos cambiar la configuración en tiempo de ejecución
    public static void setTestMode() {
        databaseUrl = "jdbc:mysql://localhost:3306/test_db";
        maxConnections = 50;
    }

    public static int getMaxConnections() {
        return maxConnections;
    }
}

Uso:

public class MainApp {
    public static void main(String[] args) {
        System.out.println("Iniciando aplicación versión " + AppConfig.VERSION);
        System.out.println("Conectando a: " + AppConfig.getDatabaseUrl());

        // Supongamos que detectamos que estamos en un entorno de pruebas
        boolean isTest = true;
        if (isTest) {
            System.out.println("\n--- MODO TEST DETECTADO ---");
            AppConfig.setTestMode();
            System.out.println("Nueva URL de BBDD: " + AppConfig.getDatabaseUrl());
            System.out.println("Nuevas conexiones máximas: " + AppConfig.getMaxConnections());
        }
    }
}

El Dilema de los Parámetros: Paso por Valor vs. "Referencia"

En el universo de Java, hay una regla de oro que a menudo se malinterpreta: todos los parámetros, sin excepción, se pasan siempre por valor. Esto significa que cuando un método es llamado, recibe una copia del valor que le enviamos.

Sin embargo, el efecto de este mecanismo es drásticamente diferente cuando trabajamos con tipos primitivos (como int o double) y cuando trabajamos con objetos (como nuestra clase Triangulo). Entender esta diferencia es clave para dominar la POO.

1. Paso por Valor en Tipos Primitivos: "La Fotocopia"

Imagina que tienes un documento original con un número escrito: 1. Si alguien te pide ese número para trabajar con él, no le das tu documento original. En su lugar, le das una fotocopia.

Esa persona puede tomar la fotocopia, tachar el 1 y escribir 999 encima. Pero cuando te devuelve la fotocopia (o simplemente la tira al terminar), tu documento original sigue intacto, con el número 1 original.

Esto es exactamente lo que ocurre con los tipos primitivos.

• El método recibe: Una copia del valor literal.
• El efecto: Cualquier modificación a esa copia dentro del método es temporal y se desvanece cuando el método termina. La variable original fuera del método nunca se entera del cambio.

Ejemplo Práctico:

public static void main(String[] args) {
    int numeroOriginal = 1;
    System.out.println("Antes de llamar al método, numeroOriginal es: " + numeroOriginal);

    modificarEntero(numeroOriginal); // Le pasamos una fotocopia del valor '1'

    System.out.println("Después de llamar al método, numeroOriginal es: " + numeroOriginal);
}

// Este método recibe una COPIA del valor.
public static void modificarEntero(int numeroCopia) {
    numeroCopia = 999; // Modificamos la copia, no el original.
}

Salida:

Antes de llamar al método, numeroOriginal es: 1
Después de llamar al método, numeroOriginal es: 1

2. Paso de Objetos: "La Dirección en un Post-it"

Ahora, imagina que tienes una casa (el objeto). La "referencia" a tu objeto no es la casa en sí, sino la dirección donde se encuentra, anotada en un post-it.

Si alguien necesita trabajar con tu casa, no le das una copia de la casa (¡eso sería imposible!). En su lugar, copias la dirección en otro post-it y se lo entregas.

Esa persona ahora tiene una copia de la dirección, pero esa dirección apunta a tu única y original casa. Si va a esa dirección y pinta la puerta de verde, tu casa original ahora tiene una puerta verde. Cuando esa persona termina y tira su post-it, tu casa sigue teniendo la puerta pintada.

Esto es lo que sucede con los objetos en Java. Técnicamente, se pasa el valor de la referencia (la dirección en el post-it), pero como esa referencia apunta al objeto original, podemos modificar el estado interno de dicho objeto.

• El método recibe: Una copia del valor de la referencia (la dirección).
• El efecto: El método puede seguir esa dirección y modificar el objeto original. Los cambios persisten después de que el método termina.

Ejemplo Práctico:

// Suponiendo que tenemos una clase Punto con getters y setters
Punto puntoOriginal = new Punto(1, 1);
System.out.println("Antes, puntoOriginal.x = " + puntoOriginal.getX());

modificarPunto(puntoOriginal); // Le pasamos una copia de la dirección al objeto

System.out.println("Después, puntoOriginal.x = " + puntoOriginal.getX());


public static void modificarPunto(Punto p) { // 'p' recibe la dirección
    // Seguimos la dirección y modificamos el objeto ORIGINAL
    p.setX(999); 
}

Salida:

Antes, puntoOriginal.x = 1
Después, puntoOriginal.x = 999

3. El Caso Especial: Objetos Inmutables como String

Los String son objetos, pero tienen una cualidad especial: son inmutables. Esto significa que una vez creados, su contenido interno no puede ser alterado.

Volviendo a la metáfora de la casa: un String es como una casa prefabricada y sellada. Si le pides a alguien que cambie el color de la puerta, no puede. Lo único que puede hacer es construir una casa completamente nueva con una puerta del nuevo color y darte la dirección de esa nueva casa.

Cuando pasas un String a un método y tratas de "modificarlo", lo que realmente ocurre es que se crea un nuevo objeto String en memoria, y la variable local del método pasa a apuntar a ese nuevo objeto. La variable original fuera del método sigue apuntando al String viejo e intacto.

Ejemplo Práctico:

String nombreOriginal = "String inmutable";
System.out.println("Antes, nombreOriginal = " + nombreOriginal);

modificarString(nombreOriginal);

System.out.println("Después, nombreOriginal = " + nombreOriginal);

public static void modificarString(String s) { // 's' apunta a "String inmutable"
    // Esto NO modifica el objeto original.
    // Crea un NUEVO String "String modificada" y hace que 's' apunte a él.
    s = "String modificada"; 
}

Salida:

Antes, nombreOriginal = String inmutable
Después, nombreOriginal = String inmutable

Resumen en Código

Aquí está el código completo que ilustra los tres casos en acción:

public class TestPasoPorValor {

    public static void main(String[] args) {
        int num = 1;
        String nombre = "String inmutable";
        Punto p1 = new Punto(1, 1);

        System.out.println("--- Valores Iniciales ---");
        System.out.println("Punto.x = " + p1.getX());
        System.out.println("num = " + num);
        System.out.println("nombre = " + nombre);

        // Llamamos a los métodos
        modificarPunto(p1);
        modificarEntero(num);
        modificarString(nombre);

        System.out.println("\n--- Valores Finales ---");
        System.out.println("Punto.x = " + p1.getX()); // Objeto modificado
        System.out.println("num = " + num);           // Primitivo NO modificado
        System.out.println("nombre = " + nombre);     // String inmutable NO modificado
    }

    // Recibe una copia de la referencia y modifica el objeto original
    public static void modificarPunto(Punto p) {
        p.setX(999);
    }

    // Recibe una copia del valor primitivo
    public static void modificarEntero(int n) {
        n = 999;
    }

    // La variable 's' apunta a un nuevo objeto String, el original no se toca
    public static void modificarString(String s) {
        s = "String modificada";
    }
}

// Clase de apoyo
class Punto {
    private int x, y;
    public Punto(int x, int y) { this.x = x; this.y = y; }
    public int getX() { return x; }
    public void setX(int x) { this.x = x; }
}

Aplicación en el Mundo Real

La POO no es un concepto académico; es el pilar sobre el que se construye el software moderno.

• Frameworks de Desarrollo Web (Spring, Jakarta EE): En entornos como Spring, toda la aplicación se modela como un conjunto de objetos (llamados Beans o Components) que colaboran. El framework se encarga de "instanciar" y "conectar" estos objetos por ti, un concepto llamado Inversión de Control (IoC). Tú defines los planos (las clases) y el framework construye la casa.
• Desarrollo de Videojuegos (Unity, LibGDX): En un motor de videojuegos, todo es un objeto: el jugador, los enemigos, las balas, los obstáculos... La clase Enemigo puede tener atributos como vida y velocidad, y métodos como atacar() o recibirDanio(). Luego creas múltiples instancias de Enemigo para poblar el nivel.
• Aplicaciones Android: Cada pantalla (Activity) de una app Android es una clase. Los botones, campos de texto y otros elementos visuales son objetos de clases predefinidas que tú instancias y configuras.
• APIs y Librerías: Las APIs que consumes (como la de Google Maps o la de Twitter) te exponen un conjunto de clases (Mapa, Tweet, Usuario) con métodos que puedes llamar para interactuar con su servicio, ocultando toda la complejidad interna (encapsulación).

En resumen, pensar en términos de objetos, responsabilidades y colaboraciones es la habilidad clave que te permitirá construir sistemas robustos, mantenibles y escalables en cualquier área del desarrollo de software.

Para Saber Más

Para profundizar en estos conceptos, aquí tienes algunos recursos de altísima calidad:

1. Documentación Oficial de Oracle sobre Clases y Objetos (Español): La fuente de la verdad. Imprescindible tenerla a mano siempre. https://docs.oracle.com/javase/tutorial/java/javaOO/index.html

2. pildorasinformaticas - Curso de Java (YouTube): Un curso legendario en español, muy completo y con explicaciones muy claras sobre todos los conceptos de la POO. Los vídeos del 27 en adelante son oro puro para este tema. https://www.youtube.com/playlist?list=PLU8oAlHdN5BlyaPFiNQDFiSIi_IkK_d5a

3. Baeldung - "Static" in Java (Inglés): Baeldung es una de las mejores webs técnicas sobre Java. Este artículo explica en profundidad y con ejemplos claros todos los matices de la palabra clave static. https://www.baeldung.com/java-static

   
   
   

   ---

   ---

EJERCICIOS

=> Ejercicios de Estructuras de Datos