Semana 2 - Programación Orientada a Objetos - POO

La programación orientada a objetos (POO) es un paradigma de programación basado en la representación de los objetos del mundo real como objetos de software, con sus propiedades y definición de comportamiento.

Algunos puntos clave de la programación orientada a objetos son:

Clases: Representan objetos del mundo real. Por ejemplo clases Persona, Coche, etc. Cada clase define atributos (propiedades) y métodos (comportamientos).
Objetos: Son instancias de clases. Por ejemplo una persona concreta Juan es un objeto de la clase Persona.
Atributos: Son las propiedades de cada objeto. Por ejemplo la clase Persona puede tener atributos como nombre, edad, DNI.
Métodos: Son acciones o comportamientos de cada objeto. Por ejemplo métodos como caminar(), comer(), hablar() en la clase Persona.
Encapsulamiento: Consiste en ocultar los detalles de implementación de los objetos y exponer solo una interfaz. Esto hace que los objetos sean más flexibles y reutilizables.
Herencia: Permite crear nuevas clases a partir de clases existentes heredando sus atributos y métodos. Esto posibilita compartir código y crear jerarquías.
Polimorfismo: Capacidad de los objetos de una clase para soportar múltiples formas, esto permite que métodos con el mismo nombre tengan comportamientos distintos.

La programación orientada a objetos es un paradigma muy útil para modelar problemas reales y lograr software más fácil de mantener, reutilizable y extensible mediante clases, objetos, encapsulamiento y herencia. Java es un lenguaje de programación orientado a objetos.

Programación Orientada a Objetos en Java

La Programación Orientada a Objetos en Java se refiere al uso y aplicación de los principios fundamentales de la POO cuando se programa en el lenguaje Java.

Algunas características clave de la Programación Orientada a Objetos en Java son:

Todo en Java es un objeto: Clases, interfaces, arrays, primitivos, etc. Esto significa que se pueden aplicar los principios de la POO a cualquier elemento del lenguaje.
Las clases definen la estructura y comportamiento de un objeto a través de atributos y métodos. En Java las clases se declaran con la palabra clave class.
Los objetos son instancias de clases creadas mediante el operador new. Representan entidades concretas del mundo real.
Los atributos en Java definen las propiedades de un objeto. Pueden ser primitivos, objetos o arrays.
Los métodos son comportamientos asociados a un objeto, se declaran dentro de la clase usando la palabra clave public o private.
Encapsulamiento mediante modificadores de acceso como public, private, protected.
Herencia y polimorfismo apoyados por las palabras clave extends e implement.
Manejo de excepciones mediante bloques try-catch.
Colecciones y genéricos para definir conjuntos de objetos.

Así, Java ofrece un sólido apoyo para la POO gracias a sus características de clases, atributos, métodos, herencia, polimorfismo, encapsulamiento y manejo de excepciones. Esto permite modelar problemas del mundo real de forma objetal.

Conceptos fundamentales: objetos, clases, atributos, métodos, encapsulamiento.

Objetos: Representan entidades del mundo real, como personas, automóviles, árboles, entre otros. Son instancias concretas de las clases. Por ejemplo, "Juan Pérez" sería un objeto de la clase Persona.
Clases: Definen el modelo común para un grupo de objetos, indicando sus atributos y comportamientos. Por ejemplo, la clase Persona definiría atributos como nombre, edad, etc. y métodos como hablar(), caminar(), etc.
Atributos: Son las características o propiedades que definen el estado de un objeto. Por ejemplo, la clase Persona tendría atributos como nombre, edad, peso, etc. Los atributos pueden ser de tipo primitivo, objeto o array.
Métodos: Representan el comportamiento y acciones que pueden realizar los objetos de una clase. Por ejemplo, métodos como getNombre(), setNombre(), caminar(), correr(), etc. En Java los métodos se definen con el modificador de acceso (public, private), el retorno y el nombre.
Encapsulamiento: Es el proceso de ocultar los datos de las clases (atributos) y sólo exponer funcionalidad a través de métodos. Esto permite mayor flexibilidad, seguridad y reusabilidad del código. En Java se logra usando los modificadores de acceso como public, private, protected.
Instanciación: Se refiere a la creación de objetos concretos a partir de las clases, mediante el uso del operador new. Por ejemplo, Persona persona1 = new Persona().

Clases en Java

Las clases son un concepto fundamental en la Programación Orientada a Objetos (POO) y son la base para crear objetos en Java.

Una clase actúa como un plano o plantilla que define la estructura y el comportamiento de los objetos que se pueden crear a partir de ella.

Estructura de una clase:

Una clase en Java se define usando la palabra clave class seguida del nombre de la clase y un cuerpo delimitado por llaves {}. Dentro del cuerpo de la clase se pueden definir los siguientes elementos:

Atributos: Representan las características o propiedades de un objeto. Se declaran con un tipo de dato y un nombre descriptivo.
Métodos: Definen las acciones o comportamientos que un objeto puede realizar. Se declaran con un modificador de acceso, un tipo de retorno, un nombre y una lista de parámetros (opcional).

Ejemplo:

public class Coche {

  // Atributos
  private String marca;
  private String modelo;
  private int anio;

  // Métodos
  public void acelerar() {
    System.out.println("El coche acelera");
  }

  public void frenar() {
    System.out.println("El coche frena");
  }

}

En este ejemplo, la clase Coche tiene tres atributos: marca, modelo y anio. También tiene dos métodos: acelerar y frenar que representan acciones que un coche puede realizar.

Creando objetos:

Una vez definida una clase, se pueden crear objetos a partir de ella utilizando el operador new. Al crear un objeto, se asigna memoria para almacenar los valores de sus atributos.

Coche miCoche = new Coche();
miCoche.marca = "Honda";
miCoche.modelo = "Civic";
miCoche.anio = 2023;

miCoche.acelerar(); // Ejecuta el método acelerar del objeto miCoche

Beneficios de usar clases:

Modularidad: Las clases permiten dividir el programa en unidades reutilizables, mejorando la organización y mantenibilidad del código.
Encapsulamiento: Las clases permiten encapsular los datos y la funcionalidad, controlando el acceso a través de modificadores de acceso.
Herencia: Las clases permiten crear jerarquías de clases, donde una clase puede heredar atributos y métodos de otra clase.
Polimorfismo: Las clases permiten el polimorfismo, donde objetos de diferentes clases pueden responder al mismo mensaje de manera diferente.

Constructores:

Los constructores son métodos especiales utilizados para inicializar los objetos de una clase. Se llaman automáticamente cuando se crea un nuevo objeto utilizando la palabra clave new seguida del nombre del constructor. Los constructores tienen el mismo nombre que la clase y no tienen un tipo de retorno. Pueden aceptar argumentos para inicializar las variables de instancia.

Por ejemplo:

public MiClase(int parametro) { ... }

Métodos en Java POO

Los métodos son bloques fundamentales en la Programación Orientada a Objetos (POO) de Java. Definen el comportamiento de un objeto, es decir, las acciones que este puede realizar.

Estructura de un método:

Un método en Java se declara utilizando la siguiente estructura:

modificador_de_acceso tipo_retorno nombre_del_metodo(parámetros) {
  // Cuerpo del método
  // Instrucciones que definen el comportamiento
}

Explicación de los elementos:

modificador_de_acceso: Define el nivel de visibilidad del método (público, privado, etc.).
tipo_retorno: El tipo de dato que devuelve el método (puede ser void si no devuelve nada).
nombre_del_metodo: Un nombre descriptivo que representa la acción del método.
parámetros (opcional): Una lista separada por comas de variables que reciben valores al momento de llamar al método. Cada parámetro tiene un tipo de dato y un nombre.
cuerpo del método: Las instrucciones que se ejecutan cuando se invoca el método.

Tipos de métodos:

Métodos con retorno: Devuelven un valor del tipo especificado en el retorno.
```
public int sumar(int a, int b) {
  return a + b;
}
```
Métodos sin retorno (void): No devuelven ningún valor, utilizan void como tipo de retorno.
```
public void saludar() {
  System.out.println("Hola!");
}
```

Invocando métodos:

Los métodos se invocan utilizando el nombre del objeto seguido de un punto (.) y el nombre del método. Se pueden pasar argumentos (valores) a los parámetros del método al momento de la invocación.

Coche miCoche = new Coche();
miCoche.acelerar(); // Invoca el método acelerar del objeto miCoche

Persona yo = new Persona();
yo.saludar("Luis"); // Invoca el método saludar con el argumento "Luis"

Importancia de los métodos:

Modularidad: Los métodos permiten dividir el comportamiento de un objeto en partes más pequeñas y reutilizables.
Encapsulamiento: Los métodos permiten ocultar la implementación interna y solo exponer la funcionalidad a través de la interfaz pública.
Reusabilidad: Los métodos se pueden reutilizar en diferentes partes del código, evitando la duplicación.

Modificadores de acceso

Los modificadores de acceso son palabras clave que se utilizan para controlar quién tiene acceso a los miembros de una clase en Java. Estos modificadores son esenciales para el encapsulamiento, un pilar fundamental de la programación orientada a objetos.

Los cuatro modificadores de acceso principales en Java son:

Public: Indica que el miembro es accesible desde cualquier clase, independientemente del paquete en el que se encuentre.
Private: Indica que el miembro solo es accesible desde la clase en la que está definido.
Protected: Indica que el miembro es accesible desde la clase en la que está definido y desde sus subclases.
Default (package-private): Indica que el miembro es accesible desde las clases que se encuentran en el mismo paquete que la clase en la que está definido.

Ejemplo:

public class Persona {
  public String nombre; // Public, accesible desde cualquier clase
  private int edad; // Private, solo accesible desde la clase Persona
  protected String ciudad; // Protected, accesible desde Persona y sus subclases
  String telefono; // Default, accesible desde las clases del mismo paquete
}

Aplicación:

Public: Mayor visibilidad, usado para miembros que se necesitan exponer a otras clases.
Private: Mayor encapsulamiento, usado para miembros internos que no necesitan ser expuestos.
Protected: Visibilidad intermedia, usado para miembros que necesitan ser accesibles en subclases.
Default: Visibilidad de paquete, usado para miembros que solo necesitan ser accesibles en el mismo paquete.

Otros modificadores de acceso:

Static: Indica que el miembro pertenece a la clase en sí, no a una instancia particular de la clase.
Final: Indica que el miembro no puede ser modificado una vez que se ha inicializado.

Elegir el modificador de acceso adecuado:

Ejemplo:

public class Persona {

  private String nombre;
  protected int edad;
  public void saludar() {
    System.out.println("Hola, mi nombre es " + nombre);
  }

  protected void mostrarEdad() {
    System.out.println("Tengo " + edad + " años");
  }

}

public class Main {

  public static void main(String[] args) {
    Persona persona = new Persona();
    persona.nombre = "Juan"; // Public, se puede acceder desde cualquier clase
    persona.saludar(); // Public, se puede acceder desde cualquier clase

    // persona.edad = 20; // Protected, no se puede acceder desde otra clase

    // persona.mostrarEdad(); // Protected, no se puede acceder desde otra clase
  }

}

Método main:

El método main es el punto de entrada del programa y se encuentra dentro de una clase. Es el método que se ejecuta primero cuando se ejecuta un programa Java.

Por ejemplo:

public static void main(String[] args) { ... }

Explicación:

public: Es un modificador de acceso que indica que el método main es público y puede ser accedido desde cualquier otra clase.
static: Es una palabra clave que indica que el método main pertenece a la clase en sí misma en lugar de pertenecer a instancias individuales de la clase. Esto significa que no necesitas crear un objeto de la clase para llamar al método main.
void: Es el tipo de retorno del método main. La palabra void indica que el método no devuelve ningún valor.
main: Es el nombre del método. main es un nombre especial en Java y se utiliza como punto de entrada para el programa.
String[] args: Es el parámetro que recibe el método main. args es una variable de tipo array de String que se utiliza para pasar argumentos de línea de comandos al programa. Los argumentos pueden ser ingresados al ejecutar el programa desde la línea de comandos.

Ejemplo de clase en Java

Clase Auto

// Definición de la clase Auto
public class Auto {
    // Variables de instancia
    private String marca;
    private String modelo;
    private int año;
    private double precio;

    // Constructor de la clase Auto
    public Auto(String marca, String modelo, int año, double precio) {
        this.marca = marca;
        this.modelo = modelo;
        this.año = año;
        this.precio = precio;
    }

    // Métodos de la clase Auto
    public void acelerar() {
        System.out.println("El auto está acelerando.");
    }

    public void frenar() {
        System.out.println("El auto está frenando.");
    }

    public void mostrarInformacion() {
        System.out.println("Marca: " + marca);
        System.out.println("Modelo: " + modelo);
        System.out.println("Año: " + año);
        System.out.println("Precio: " + precio);
    }

    // Método main para probar la clase Auto
    public static void main(String[] args) {
        // Crear objetos de la clase Auto
        Auto auto1 = new Auto("Ford", "Mustang", 2022, 35000.0);
        Auto auto2 = new Auto("Chevrolet", "Camaro", 2021, 32000.0);

        // Acceder a los métodos y variables de los objetos
        auto1.acelerar();
        auto2.frenar();

        auto1.mostrarInformacion();
        auto2.mostrarInformacion();
    }
}

Explicación:

La palabra clave class se utiliza para definir una clase en Java. En este caso, estamos definiendo la clase "Auto".
Las variables de instancia (marca, modelo, año, precio) son las características del auto y se definen al comienzo de la clase. Estas variables son privadas (private) para asegurar el encapsulamiento.
El constructor Coche se utiliza para inicializar los valores de las variables de instancia al crear un objeto de la clase. Toma argumentos que se utilizan para asignar valores a las variables.
Los métodos (acelerar, frenar, mostrarInformacion) definen el comportamiento del auto. Pueden realizar acciones (como imprimir mensajes) o acceder y modificar los valores de las variables de instancia.
El método main es el punto de entrada del programa. Aquí creamos objetos de la clase Auto, llamamos a sus métodos y accedemos a sus variables.

En el ejemplo, creamos dos objetos Auto, "auto1" y "auto2", con diferentes valores. Luego, llamamos a los métodos acelerar, frenar y mostrarInformacion para cada objeto, lo que muestra diferentes mensajes en la salida.

Clase persona

// Definición de la clase "Persona"
public class Persona {
    // Variables de instancia
    private String nombre;
    private int edad;
    private String direccion;

    // Constructor de la clase "Persona"
    public Persona(String nombre, int edad, String direccion) {
        this.nombre = nombre;
        this.edad = edad;
        this.direccion = direccion;
    }

    // Métodos de la clase "Persona"
    public void saludar() {
        System.out.println("Hola, mi nombre es " + nombre);
    }

    public void cumplirAnios() {
        edad++;
        System.out.println("¡Feliz cumpleaños! Ahora tengo " + edad + " años.");
    }

    public void cambiarDireccion(String nuevaDireccion) {
        direccion = nuevaDireccion;
        System.out.println("Mi nueva dirección es: " + direccion);
    }

    // Método getter para obtener el nombre
    public String getNombre() {
        return nombre;
    }

    // Método setter para cambiar la edad
    public void setEdad(int edad) {
        this.edad = edad;
    }

    // Método main para probar la clase "Persona"
    public static void main(String[] args) {
        // Crear un objeto de la clase "Persona"
        Persona persona1 = new Persona("Juan", 30, "Calle Principal 123");

        // Acceder a los métodos y variables de la clase
        persona1.saludar();
        persona1.cumplirAnios();

        String nombrePersona1 = persona1.getNombre();
        System.out.println("El nombre de la persona es: " + nombrePersona1);

        persona1.setEdad(31);
        persona1.cumplirAnios();

        persona1.cambiarDireccion("Avenida Central 456");
    }
}

Explicación:

La clase se llama "Persona" y se define utilizando la palabra clave class.
Las variables de instancia (nombre, edad, direccion) representan las características de una persona y se definen al comienzo de la clase. Son privadas (private) para asegurar el encapsulamiento.
El constructor Persona se utiliza para inicializar los valores de las variables de instancia al crear un objeto de la clase. Toma argumentos que se utilizan para asignar valores a las variables.
Los métodos (saludar, cumplirAnios, cambiarDireccion) definen el comportamiento de una persona. Pueden realizar acciones (como imprimir mensajes) o acceder y modificar los valores de las variables de instancia.
Los métodos getNombre y setEdad son ejemplos de métodos getter y setter, respectivamente. El método getter permite obtener el valor de una variable de instancia, y el método setter permite cambiar su valor.
El método main es el punto de entrada del programa. Aquí creamos un objeto de la clase Persona llamado persona1 y luego llamamos a los métodos y usamos los métodos getter y setter para interactuar con el objeto.

Este ejemplo muestra cómo crear una clase en Java y utilizarla para crear objetos, acceder a sus métodos y variables, y cómo usar métodos getter y setter. Puedes personalizar la clase "Persona" y agregar más métodos y variables según tus necesidades.

Actividad Práctica: Introducción a la Programación Orientada a Objetos (POO) en Java

Instrucciones para los Estudiantes

En esta actividad, aprenderás y aplicarás los conceptos fundamentales de la Programación Orientada a Objetos (POO) en Java. Seguirás una serie de pasos guiados para crear una clase, instanciar objetos, trabajar con atributos, métodos y encapsulamiento, y finalmente presentar tus resultados. ¡Manos a la obra!

Paso 1: Creación de la Clase "Jugador"

Objetivo: Crear una clase llamada Jugador que represente a un jugador de un equipo deportivo.
Atributos:
Nombre (String)
Edad (int)
Posición (String)
Número de camiseta (int)
Equipo (String)
Instrucciones:
Declara los atributos como private para aplicar el principio de encapsulamiento.
No incluyas constructores ni métodos en este paso.

Ejemplo parcial:

public class Jugador {
    private String nombre;
    private int edad;
    private String posicion;
    private int numeroCamiseta;
    private String equipo;
}

Reflexión:
¿Qué representa esta clase? ¿Qué información contiene?

Paso 2: Agregar un Constructor

Objetivo: Agregar un constructor a la clase Jugador para inicializar todos los atributos.
Instrucciones:
Crea un constructor que reciba los valores de los atributos como parámetros.
Usa la palabra clave this para asignar los valores recibidos a los atributos correspondientes.

Ejemplo parcial:

public Jugador(String nombre, int edad, String posicion, int numeroCamiseta, String equipo) {
    this.nombre = nombre;
    this.edad = edad;
    this.posicion = posicion;
    this.numeroCamiseta = numeroCamiseta;
    this.equipo = equipo;
}

Reflexión:
¿Por qué es importante inicializar los atributos al crear un objeto? ¿Qué pasaría si no usáramos un constructor?

Paso 3: Crear Métodos de Acceso (Getters) y Modificación (Setters)

Objetivo: Agregar métodos get y set para cada atributo de la clase Jugador.
Instrucciones:
Para cada atributo, crea un método get que devuelva su valor.
Crea un método set que permita modificar el valor del atributo.

Ejemplo parcial:

public String getNombre() {
    return nombre;
}

public void setNombre(String nombre) {
    this.nombre = nombre;
}

public int getEdad() {
    return edad;
}

public void setEdad(int edad) {
    this.edad = edad;
}

// Repite para los demás atributos...

Reflexión:
¿Por qué no accedemos directamente a los atributos desde otras clases? ¿Qué ventajas tiene usar getters y setters?

Paso 4: Crear un Método Personalizado

Objetivo: Agregar un método personalizado llamado mostrarInformacion que imprima los detalles del jugador.
Instrucciones:
El método debe imprimir los valores de todos los atributos del jugador en un formato claro.

Ejemplo de salida esperada:

Nombre: Juan Pérez
Edad: 25
Posición: Delantero
Número de Camiseta: 10
Equipo: Rojos FC

Ejemplo parcial:

public void mostrarInformacion() {
    System.out.println("Nombre: " + nombre);
    System.out.println("Edad: " + edad);
    System.out.println("Posición: " + posicion);
    System.out.println("Número de Camiseta: " + numeroCamiseta);
    System.out.println("Equipo: " + equipo);
}

Reflexión:
¿Qué otros métodos podrían ser útiles para la clase Jugador? ¿Cómo podríamos mejorar este método?

Paso 5: Crear Objetos y Usar Métodos

Objetivo: Crear objetos de la clase Jugador y utilizar sus métodos.
Instrucciones:
En el método main, crea dos objetos de la clase Jugador con diferentes valores para los atributos.
Usa los métodos get, set y mostrarInformacion para interactuar con los objetos.

Ejemplo parcial:

public static void main(String[] args) {
    // Crear objetos
    Jugador jugador1 = new Jugador("Juan Pérez", 25, "Delantero", 10, "Rojos FC");
    Jugador jugador2 = new Jugador("Ana Gómez", 22, "Portero", 1, "Azules SC");

    // Mostrar información
    jugador1.mostrarInformacion();
    jugador2.mostrarInformacion();

    // Modificar atributos
    jugador1.setEdad(26);
    jugador2.setEquipo("Verdes United");

    // Mostrar información actualizada
    jugador1.mostrarInformacion();
    jugador2.mostrarInformacion();
}

Reflexión:
¿Qué aprendiste al crear y utilizar objetos? ¿Cómo cambia el estado de un objeto cuando usamos métodos set?