jueves, 11 de mayo de 2023

CONCEPTOS BÁSICOS DE JAVA: PROGRAMACION ORIENTADA A OBJETOS (POO)

PROGRAMACION ORIENTADA A OBJETOS(POO)

La Programación Orientada a Objetos (POO) es un paradigma de la programación la cual se basa en la creación y manipulación de objetos, cuyos conceptos más importantes son: 
  • Clase
  • Objeto
  • Encapsulamiento
  • Herencia
  • Polimorfismo
  • Asociación
  • Composición
CLASE

Es un modelo que define propiedades y comportamientos comunes a un grupo de objetos. Las clases son los componentes fundamentales de la POO y se utilizan para crear instancias u objetos.

public class Persona {
private String nombre;
private int edad;

public Persona(String nombre, int edad) {
//Constructor
this.nombre = nombre;
this.edad = edad;
}

public void saludar() {
//método
System.out.println(
"Hola, soy " + nombre + " y tengo " + edad + " años.");
}

public static void main(String[] args) {
//método
Persona persona1 = new Persona(
"Juan", 25);//Creación instancia de la clase Persona
System.out.println(persona1.nombre);
// Imprime "Juan"
System.out.println(persona1.edad); // Imprime 25
persona1.saludar(); // Imprime "Hola, soy Juan y tengo 25 años."
}
}
Se define la clase Persona con dos atributos: nombre (de tipo String) y edad (de tipo int). El constructor de la clase se llama Persona y se utiliza para inicializar los atributos.

El método saludar imprime un mensaje de saludo utilizando los valores de nombre y edad.

En el método main, se crea una instancia de la clase Persona llamada persona1, pasando los valores "Juan" y 25 para el nombre y la edad, respectivamente. Luego, se accede a los atributos nombre y edad de la instancia y se llama al método saludar, que muestra un mensaje en la consola.


OBJETO

Un objeto es una instancia concreta de una clase. Posee propiedades (atributos) y comportamientos (métodos) definidos por su clase. Los objetos representan entidades del mundo real y se utilizan para interactuar con el sistema.

public class Persona {
    private String nombre;
    private int edad;

    public Persona(String nombre, int edad) {
        this.nombre = nombre;
        this.edad = edad;
    }

    public void saludar() {
        System.out.println(
"Hola, soy " + nombre + " y tengo " + edad + " años.");
    }

    public static void main(String[] args) {
        Persona persona1 = new Persona(
"Juan", 25);
        persona1.saludar(); // Imprime "Hola, soy Juan y tengo 25 años."
   
}
}


En el método main, se crea una instancia de Persona llamada persona1 con los valores "Juan" y 25 para el nombre y la edad, respectivamente. Luego, se llama al método saludar de persona1, lo cual muestra un mensaje de saludo en la consola.

ENCAPSULAMIENTO

 La encapsulación es un principio de la POO que consiste en ocultar los detalles internos de un objeto y exponer solo una interfaz para interactuar con él. Permite proteger los datos y asegurar que solo puedan ser accedidos y modificados a través de métodos definidos en la clase.

public class Persona {
private String nombre;
private int edad;

public String getNombre() {
return nombre;
}

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

public int getEdad() {
return edad;
}

public void setEdad(int edad) {
if (edad > 0) {
this.edad = edad;
} else {
System.out.println("La edad debe ser mayor que 0.");
}
}
}

En este ejemplo, los atributos nombre y edad están definidos como privados, lo que significa que solo se pueden acceder a ellos desde dentro de la clase Persona. Para acceder a estos atributos desde fuera de la clase, se proporcionan métodos públicos de acceso, conocidos como getters y setters.

Los métodos getNombre y getEdad son getters, que devuelven el valor de los atributos nombre y edad, respectivamente.

Los métodos setNombre y setEdad son setters, que permiten establecer los valores de los atributos nombre y edad, respectivamente. En el caso del setter setEdad, se realiza una validación para asegurarse de que la edad sea mayor que 0 antes de establecerla. Si la edad no cumple esta condición, se muestra un mensaje de error en la consola.

ABSTRACCIÓN: La abstracción es el proceso de simplificar un objeto o sistema enfocándose solo en los aspectos relevantes para un contexto determinado. Permite definir clases y objetos que representen conceptos del dominio de manera abstracta, sin considerar todos los detalles de implementación.

HERENCIA

La herencia es un mecanismo que permite crear nuevas clases basadas en clases existentes, heredando sus propiedades y comportamientos. La clase existente se denomina clase base o superclase, mientras que la nueva clase se denomina clase derivada o subclase. La herencia facilita la reutilización de código y la extensibilidad.

Volvemos a utilizar nuestra clase Persona la cuál sería la clase existente, por lo tanto es nuestra clase base(superclase)

class Persona {
private String nombre;
private int edad;

public Persona(String nombre, int edad) {
this.nombre = nombre;
this.edad = edad;
}

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;
}

public void saludar() {
System.out.println("Hola, soy " + nombre + " y tengo " + edad + " años.");
}
}

Aplicaremos la herencia utilizando la clase Estudiante la cual se denomina clase derivada o subclase.

class Estudiante extends Persona {
private String curso;

public Estudiante(String nombre, int edad, String curso) {
super(nombre, edad);
this.curso = curso;
}

public String getCurso() {
return curso;
}

public void setCurso(String curso) {
this.curso = curso;
}

public void estudiar() {
System.out.println("Estoy estudiando " + curso);
}
}
public class EjemploHerencia {
public static void main(String[] args) {
Estudiante estudiante = new Estudiante("Juan", 20, "Informática");
estudiante.saludar();
estudiante.estudiar();
}
}

Ejercicio: De acuerdo a lo estudiado a este punto, ¿Cuáles son las salidas que nos dará la implementación del código?

POLIMORFISMO

El polimorfismo permite que un objeto pueda tomar diferentes formas y comportarse de manera distinta en diferentes contextos. Puede manifestarse a través de la sobrecarga de métodos (mismos nombres, diferentes parámetros) o la sobrescritura de métodos (implementaciones diferentes en las subclases).

public class Animal {
public void hacerSonido() {
System.out.println("El animal hace un sonido.");
}
}

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

public class Gato extends Animal {
@Override
public void hacerSonido() {
System.out.println("El gato maulla.");
}
}

public class EjemploPolimorfismo {
public static void main(String[] args) {
Animal animal1 = new Perro();
Animal animal2 = new Gato();

animal1.hacerSonido();
animal2.hacerSonido();
}
}

En este ejemplo, tenemos una clase base Animal con un método hacerSonido(). Las subclases Perro y Gato heredan de la clase Animal y sobrescriben el método hacerSonido() con su propia implementación. 

En el método main(), creamos objetos de las subclases Perro y Gato pero los asignamos a variables de tipo Animal. Esto es posible debido al principio de polimorfismo en la programación orientada a objetos. 

Al llamar al método hacerSonido() en los objetos animal1 y animal2, se ejecutará la implementación específica de cada subclase (Perro y Gato). Esto demuestra cómo el mismo método puede comportarse de manera diferente dependiendo del tipo de objeto al que se llama en tiempo de ejecución.

El @Override es una anotación en Java que se utiliza para indicar que un método de una subclase está sobrescribiendo un método de la clase base. Esta anotación es opcional, pero se considera una buena práctica incluirla para mejorar la legibilidad del código y evitar posibles errores.

 Cuando se utiliza @Override, el compilador de Java verificará si el método decorado con esta anotación realmente está sobrescribiendo un método de la clase base. Si no se encuentra un método en la clase base que coincida con la firma del método anotado, se generará un error de compilación.

ASOCIACIÓN

La asociación es una relación entre dos o más clases, donde cada clase conserva su independencia. Puede haber asociaciones unidireccionales o bidireccionales, y pueden ser de tipo uno a uno, uno a muchos o muchos a muchos.

public class Usuario {
private String nombre;
private int edad;

public Usuario(String nombre, int edad) {
this.nombre = nombre;
this.edad = edad;
}

public String getNombre() {
return nombre;
}

public int getEdad() {
return edad;
}
}

public class Biblioteca {
private String nombre;
private Usuario[] usuarios;

public Biblioteca(String nombre) {
this.nombre = nombre;
this.usuarios = new Usuario[100];
}

public void agregarUsuario(Usuario usuario) {
// Lógica para agregar un usuario a la biblioteca
// Aquí se puede implementar la asociación entre Usuario y Biblioteca
}

public void mostrarUsuarios() {
// Lógica para mostrar los usuarios de la biblioteca
// Aquí se puede acceder a los datos de los usuarios asociados
}
}

public class EjemploAsociacion {
public static void main(String[] args) {
Usuario usuario1 = new Usuario("Juan", 25);
Usuario usuario2 = new Usuario("María", 30);

Biblioteca biblioteca = new Biblioteca("Biblioteca Central");
biblioteca.agregarUsuario(usuario1);
biblioteca.agregarUsuario(usuario2);

biblioteca.mostrarUsuarios();
}
}

En este ejemplo, las clases Usuario y Biblioteca están asociadas. La clase Usuario representa a un usuario con un nombre y una edad. La clase Biblioteca representa una biblioteca con un nombre y una lista de usuarios.

La asociación se establece a través del método agregarUsuario() en la clase Biblioteca. Este método permite agregar un usuario a la lista de usuarios de la biblioteca.

Mediante esta asociación, la clase Biblioteca puede acceder a los datos de los usuarios asociados y realizar operaciones relacionadas, como mostrar la lista de usuarios en el método mostrarUsuarios().

En el método main(), creamos instancias de Usuario y una instancia de Biblioteca. Luego, agregamos los usuarios a la biblioteca utilizando el método agregarUsuario(). Finalmente, mostramos la lista de usuarios llamando al método mostrarUsuarios() de la biblioteca.

Este ejemplo ilustra cómo las clases Usuario y Biblioteca están asociadas, permitiendo que la biblioteca gestione y acceda a los usuarios asociados.

COMPOSICIÓN

La composición es un tipo especial de asociación donde una clase contiene a otras clases como parte de su estructura interna. La relación de composición es más fuerte que la asociación, ya que las clases contenidas no existen de forma independiente y su ciclo de vida está estrechamente ligado a la clase contenedora.

public class Coche {
private String marca;
private Motor motor;

public Coche(String marca, String tipoMotor) {
this.marca = marca;
this.motor = new Motor(tipoMotor);
}

public String getMarca() {
return marca;
}

public String getTipoMotor() {
return motor.getTipo();
}
}

public class EjemploComposicion {
public static void main(String[] args) {
Coche coche = new Coche("Toyota", "Gasolina");

System.out.println("Marca: " + coche.getMarca());
System.out.println("Tipo de motor: " + coche.getTipoMotor());
}
}

En este ejemplo, la clase Coche tiene una composición con la clase Motor. Cada instancia de Coche contiene un objeto Motor como parte de su estructura interna.

La clase Motor representa el motor de un coche y tiene un atributo tipo que indica el tipo de motor.

La clase Coche tiene un atributo marca para indicar la marca del coche y un atributo motor que es una instancia de la clase Motor.

En el constructor de Coche, se crea una instancia de Motor pasando el tipo de motor como argumento y se asigna a la variable motor.

En el método main(), creamos un objeto Coche y obtenemos la marca y el tipo de motor llamando a los métodos getMarca() y getTipoMotor() respectivamente.

La composición se refleja en el hecho de que un coche está compuesto por un motor. El objeto Motor es creado y gestionado por la clase Coche, y forma parte integral de la estructura del coche.

La salida del programa será:

Marca: Toyota
Tipo de motor: Gasolina

jueves, 4 de mayo de 2023

TO DO LIST(CRUD): JAVA+SPRINGBOOT+ MYSQL-PARTE I

Saludos a todos 

Le solicitamos a ChatGPT que nos dijera cómo hacer un todo List utilizando Java, Spring Boot y MySQL y nos dio la siguiente lista de tareas las cuales iremos ejecutando y explicando a detalle.

Este ejercicio to do list nos permite realizar un CRUD: Create (Crear), Read (Leer), Update (Actualizar) y Delete (Borrar) información de una base de datos. Nos centraremos en el backend del ejercicio y en la segunda parte implementaremos el Front End de la aplicación.

Puedes ingresar al GITHUB y descarga aquí el código

  1. Crear un proyecto Spring Boot en el IDE de preferencia.
Para este punto, debo generar un proyecto en Spring Boot con dependencias MySQL Driver, Spring Data JPA y Spring Web.
Utilizaré Intellij IDEA como mi IDE de preferencia.

2. Configurar la conexión a la base de datos MySQL en el archivo "application.properties".

En este caso ChatGPT se saltó un paso en la creación de la base de datos, por lo que ingresaré sobre este mismo Ítem, la creación y la configuración de la misma.

  • CREACIÓN BD: Esta base de datos será creada con MySQL Workbench 8.0 y tendrá columnas: (id, titulo, descripción y fecha). Tener en cuenta el tipo de dato de cada atributo.

  • CONEXIÓN BD: Se requiere conectarla a un servidor, en este caso sigo usando MySQL Server, el cuál está dentro de nuestro programa MySQL Workbench 8.0
  • CONFIGURACION: Para la configuración de "application.properties". Tener presente que esta configuración sólo aplica para MySQL, si tienes otro gestor de BD debes consultar la configuración.
spring.datasource.url=jdbc:mysql://localhost:3306/todolist
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL8Dialect
spring.jpa.hibernate.ddl-auto=update
  1. Crear la entidad "Tarea" que representará las tareas en la base de datos.
Tener presente que nuestra entidad estará incluida en un paquete nombrado Entity y la entidad la llamé TodolistEntity y tiene el siguiente código:

package com.example.demo.Entity;

import jakarta.persistence.*;

import java.time.LocalDate;

@Entity
@Table(name = "todolist")
public class TodolistEntity {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(name = "titulo")
private String titulo;
@Column(name = "descripcion")
private String descripcion;
@Column(name = "fecha")
private LocalDate fecha;

public TodolistEntity(){

}

public TodolistEntity(String titulo, String descripcion, LocalDate fecha) {
this.titulo = titulo;
this.descripcion = descripcion;
this.fecha = fecha;
}

public String getTitulo() {
return titulo;
}

public void setTitulo(String titulo) {
this.titulo = titulo;
}

public String getDescripcion() {
return descripcion;
}

public void setDescripcion(String descripcion) {
this.descripcion = descripcion;
}

public LocalDate getFecha() {
return fecha;
}

public void setFecha(LocalDate fecha) {
this.fecha = fecha;
}
}

4. Crear un repositorio para la entidad "Tarea" que extienda de "JpaRepository".

Recordar que la entidad se llama TodolistEntity. Para el repositorio realizé la creación de un paquete llamado Repository y la interface con nombre TodolistRepository
package com.example.demo.Repository;

import com.example.demo.Entity.TodolistEntity;
import org.springframework.data.jpa.repository.JpaRepository;

public interface TodolistRepository extends JpaRepository<TodolistEntity, Long> {
}

5. Crear un controlador REST que maneje las operaciones CRUD para las tareas.

Por último la creación del controlador se realiza creando otro paquete con nombre Controller y la clase TodolistController con las operaciones Create (Crear), Read (Leer), Update (Actualizar) y Delete (Borrar)
package com.example.demo.Controller;

import com.example.demo.Entity.TodolistEntity;
import com.example.demo.Repository.TodolistRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/tareas")
public class TodolistController {
@Autowired
private TodolistRepository todolistRepository;
@GetMapping("")
public List<TodolistEntity> mostrarTarea(){
return todolistRepository.findAll();
}
@PostMapping("")
public TodolistEntity crearTarea(@RequestBody TodolistEntity todolistEntity){
return todolistRepository.save(todolistEntity);
}
@PutMapping("/{id}")
public TodolistEntity actualizarTarea(@RequestBody TodolistEntity todolistEntity){
return todolistRepository.save(todolistEntity);

}
@DeleteMapping("/{id}")
public void eliminarTarea(@PathVariable Long id){
todolistRepository.deleteById(id);
}
}
Ahora realizamos pruebas a nuestro código y utilizando la aplicación POSTMAN ingresaremos nuestros datos, tener presente que para la otra parte de este ejercicio haremos el Front.

POST: Se ingresan y cargan a la base de datos con un RESPONSE 200, lo cuál nos indica que la solicitud ha sido exitosa.


GET: Se muestran todos los elementos de la base datos, lo puedo validar directamente en el navegador, o también por la aplicación POSTMAN




PUT: Se actualiza la información, tener en cuenta las rutas que se asignan en el TodolistController. Para este ejemplo usé: http://localhost:8080/tareas/1

DELETE: Se elimina un elemento deseado, usaré el de la ruta http://localhost:8080/tareas/2




Así quedaron distribuidos los paquetes y las clases utilizados.



Con este ejercicio hemos integrado bases de datos con el lenguaje de programación Java con la ayuda del framework Spring Boot cuyos microservicios nos ayudaron a realizar esta sencilla implementación. ¿Qué más se te ocurre aplicar utilizando esta herramientas? Coméntame tus ideas en la sección de comentarios.

Saludos