Rama java2023

_posts/javaEE/java_dao/2022-11-02-javaEE-dao.md

@@ -36,7 +36,7 @@ page_css:
 
 * Ofrecer una ``interfaz`` sencillas en ciertas partes de la aplicación
 
-> Necesario cuando se utilizan API de bajo nivel como JDBC en las que las operaciones sobre la base de datos conllevan utilización de sentencias SQL que queremos aislar de otras capas de la aplicación
+> Necesario cuando se utilizan API de bajo nivel como **JDBC** en las que las operaciones sobre la base de datos conllevan utilización de sentencias **SQL** que queremos aislar de otras capas de la aplicación
 
 ## Utilidad
 
@@ -46,17 +46,17 @@ page_css:
 
   * ``Métodos`` del ``DAO`` que se **emparejan** con las operaciones ``CRUD``
 
-    1. **C** → ``Create``
+    1. **C** → **``Create``**
 
-    2. **R** → ``Read``
+    2. **R** → **``Read``**
 
-    3. **U** → ``Update``
+    3. **U** → **``Update``**
 
-    4. **D** → ``Delete``
+    4. **D** → **``Delete``**
 
 > Actúa de intermediario entre la aplicación y la base de datos
 
-* ``Clases DAO`` habrá una por ``entidad`` o ``tabla`` de la ``base de datos`` y tendremos ``métodos`` para realizar ``consultas genéricas`` o ``adaptadas`` a nuestra ``lógica de negocio``
+* **``Clases DAO``** habrá una por **``entidad``** o **``tabla``** de la **``base de datos``** y tendremos **``métodos``** para realizar **``consultas genéricas``** o **``adaptadas``** a nuestra **``lógica de negocio``**
 
 ```java
 package project.orm.manager.dao;
@@ -113,9 +113,11 @@ public interface Dao<T> {
 }
 ```
 
-* **Patrón  de diseño** que proporciona una ``interface abstracta`` hacia algún tipo de base de datos mediante otro mecanismo de ``persistencia``
+* **Patrón  de diseño**
 
-  > **Patrón** aplicable a la mayoría de los **lenguajes de programación** que necesitan uso de la **persistencia** y **conexión** con una **base de datos** asociados a las aplicaciones ``Java EE`` y las ``base de datos relacionales`` a las que se accede mediante las ``API`` de ``JDBC``
+  * Proporciona una ``interface abstracta`` hacia algún tipo de base de datos mediante otro mecanismo de ``persistencia``
+
+> **Patrón** aplicable a la mayoría de los **lenguajes de programación** que necesitan uso de la **persistencia** y **conexión** con una **base de datos** asociados a las aplicaciones ``Java EE`` y las ``base de datos relacionales`` a las que se accede mediante las ``API`` de ``JDBC``
 
 * Asignar llamadas de aplicaciones de ``capa de persistencia (DAO)`` proporciona especificas operaciones de datos sin especificar detalles de la ``base de datos``
 
@@ -153,9 +155,9 @@ como apoyar las necesidades de la ``DBMS especifico`` , un esquema de ``base de
 
 ## Herramientas Populares de los ORM para realizar DAO
 
-1. Frameworks : ``Hibernate, iBATIS``
+1. **Frameworks** : ``Hibernate, iBATIS``
 
-2. Library : ``JPA, como Apache OpenJPA``
+2. **Library** : ``JPA, como Apache OpenJPA``
 
 ## Casos de uso
 

_posts/javaSE/buffer/2023-05-18-java-IO-NIO.md

@@ -40,21 +40,21 @@ page_css:
 
   * ``Java IO`` es un ``paquete`` orientado a ``secuencias`` 
 
-    * Significa 
+    * **Significa** 
 
       * Que puede ``leer`` uno o más ``bytes`` a la vez desde una ``secuencia``
 
   * ``Java NIO`` es un paquete orientado al ``buffer``
 
-    * Significa 
+    * **Significa** 
 
       * Que los ``datos`` se leen en un ``buffer`` desde el cual se procesan más utilizando un canal
 
 ## Otras diferencias
 
 * ``Java IO`` es un ``IO`` de **bloqueo**
 
-  * Significa 
+  * **Significa** 
 
     * Que si un ``subproceso`` está ``invocando`` una ``operación`` de ``lectura`` o ``escritura`` ese ``subproceso`` **se bloquea** hasta que haya algunos ``datos`` para ``leer`` o los ``datos estén`` completamente escritos
 
@@ -64,7 +64,7 @@ page_css:
 
 * ``Java NIO`` es un ``IO`` **sin bloqueo**
 
-  * Significa
+  * **Significa**
 
     * Que si un ``subproceso`` está ``invocando`` una ``operación`` de ``lectura`` o ``escritura`` ese ``subproceso`` **no se bloquea** hasta que haya algunos ``datos`` para ``leer`` o los ``datos`` estén completamente ``escritos`` en lugar de que el ``subproceso`` continúe con otra cosa
 

_posts/javaSE/clases/clases_conceptos/2022-04-17-java-clase-concepto.md

@@ -93,7 +93,7 @@ public Persona(){
 
 ### Modificador final
 
-* Una clase con el modificador ``final`` no permite la creación de objetos
+* Una **clase** con el modificador ``final`` no permite la **creación** de **objetos**
 
 ```java
 // Modificador "final" establece claramente la intención

_posts/javaSE/herencia/2023-06-22-java-herencia-composicion.md

@@ -0,0 +1,164 @@
+---
+layout: single
+title: Java - Herencia & Composición
+date: 2023-06-22
+classes: wide
+toc: true
+toc_label: "Tabla de contenido"
+toc_icon: "clipboard-list"
+header:
+  teaser: /assets/images/java/logo-java-2.jpg
+categories:
+  - java
+  - java-manual
+  - java-conceptos
+tags:
+  - java-herencia
+  - java-composición
+page_css: 
+  - /assets/css/mi-css.css
+---
+
+## Concepto - Herencia
+
+> Relación ``"Es un"`` entre clases
+
+* Cuando una clase ``extiende`` a otra clase (``Hereda`` todos los ``métodos`` / ``propiedades``)
+
+* Utiliza el comportamiento de la **clase Padre** en la subclase (``Sobrescribir`` / ``Agregar`` nnuevos comportamientos)
+
+* ``Herencia`` se utiliza para representar ``relaciones`` jerarquicas entre ``clases`` ( Donde una ``subclase`` es un tipo más especifico de su ``clase Padre``)
+
+
+```java
+/**
+* Ejemplo de Herencia
+*/
+
+/**
+ * Clase Padre Concreta - Vehiculo
+ */
+public class Vehiculo {
+
+	/**
+	 * Atributo de instancia
+   * 
+   * Almacena el valor númerico de la velocidad
+	 */
+	private int velocidad;
+
+	/**
+   * Método de instancia
+	 * 
+	 * @param incremento la velocidad del objeto Vehiculo
+	 */
+	public void acelerar(int incremento) {
+		velocidad += incremento;
+	}
+
+}
+
+/**
+ * Clase Hija Concreta - Vehiculo
+ */
+class Coche extends Vehiculo {
+
+	/**
+	 * Atributo de instancia
+   * 
+   * Almacena la cantidad de ruedas que tiene un Coche
+   * 
+	 */
+	private int ruedas;
+
+	/**
+   * Constructor por defecto
+	 * 
+	 * @param ruedas que posee el objeto Vehiculo
+	 */
+	public Coche(int ruedas) {
+		this.ruedas = ruedas;
+	}
+}
+```
+
+## Concepto - Composición
+
+> La relación ``"tiene un`` entre clases
+
+- En lugar de ``heredar`` comportamiento de una **clase Padre** , una clase puede contener una ``instancia`` de otra **clase** y utilizar su ``comportamiento``
+
+- La **composición** se utiliza a menudo para representar relaciones entre ``objetos`` donde un ``objeto`` contiene o estas **compuestos** por otros ``objetos``
+
+```java
+/**
+ * Ejemplo de Composición
+ * 
+ * En lugar de heredar comportamientos de una clase padre , 
+ * una clase puede contener una instancia de otra clase y utilizar su comportamiento
+ * 
+ * La composición se utiliza a menudo para representar relaciones 
+ * entre objetos donde un objeto contiene o esta compuestos por otros objetos
+ */
+
+/**
+ * Clase Concreta Padre - Coche
+ * 
+ * Contiene un objeto de otra clase para implementar sus propios objetos
+ *
+ */
+public class Coche {
+
+	/**
+	 * Atributo de instancia
+	 * 
+	 * Almacena la cantidad de ruedas
+	 */
+	private int ruedas;
+
+	/**
+	 * Atributo de instancia 
+	 * 
+	 * Contiene un objeto de la clase Motor para implementar los objetos de la clase Coche
+   * 
+	 */
+	private Motor motor;
+
+	/**
+	 * Constructor parametrizado de la clase Coche
+	 * 
+	 * @param ruedas - Atributo de la clase Coche
+	 * @param motor  - Atributo de la clase motor - Almacena un objeto Motor para poder invocar tanto los metodos / atributos propios de la clase
+	 */
+	public Coche(int ruedas, Motor motor) {
+		this.ruedas = ruedas;
+		this.motor = motor; // Objeto de la clase Motor
+	}
+
+}
+
+/**
+ * Clase Concreta Hija - Motor
+ *  
+ * Crea una clase que se añadira un objeto a otra clase en su definición
+ *
+ */
+class Motor {
+
+	/**
+	 * Atributo de instancia
+	 * 
+	 * Almacena un elemento del tipo entero
+	 */
+	private int caballosDeFuerza;
+
+	/**
+	 * Constructor para inicializar objetos de la clase Motor
+	 * 
+	 * @param caballosDeFuerza - Almacena la cantidad de caballos de fuerza del objeto motor
+	 */
+	public Motor(int caballosDeFuerza) {
+		this.caballosDeFuerza = caballosDeFuerza;
+	}
+}
+```

_posts/javaSE/objetos/2022-04-14-java-objeto.md

@@ -87,7 +87,7 @@ page_css:
 
 ### Proceso de creación de un Objeto
 
-1. Declaración
+1. **Declaración**
 
 * Declarar la variable de **tipo de clase**
   * Esta **variable** **no define** un **objeto** , simplemente es una **variable** que puede **referirse** a un **objeto**
@@ -102,7 +102,7 @@ page_css:
    Gato           gato; // Se ha declarado una referencia a un objeto de tipo Coche
 ```
 
-2. Instanciación e Inicialización
+2. **Instanciación** e **Inicialización**
 
 * Ahora le asignaremos una **copia física** del **objeto** con el que estamos trabajando y le **asignaremos** la **variable** anteriormente **declarada** que define el **tipo de dato/objeto** que sera
 
@@ -209,7 +209,7 @@ System.out.println(caja2.alto);
 
 ### Desvinculación de un objeto
 
-* Si ambas variables de instancia como 'caja1' y 'caja2' **apuntan/referencia** al mismo objeto , no estarán vinculadas o enlazadas de ninguna otra manera posible
+* Si ambas variables de instancia como **'caja1'** y **'caja2'** *apuntan/referencia* al mismo *objeto* , no estarán *vinculadas* o *enlazadas* de ninguna otra manera posible
 
 ```java
 // Declaración e instanciación de las "variable de instancia" de la clase Caja
@@ -221,4 +221,6 @@ Caja caja2 = caja1;
 caja1 = null;
 ```
 
-* Nota : Cuando pasamos la **referencia** de un **objeto** a un **método**, el **parámetro** que lo recibe se referirá al **mismo objeto** al que hace **referencia** el **argumento** no al de la **clase** que lo instancio
+* Nota 
+
+  *  Cuando pasamos la **referencia** de un **objeto** a un **método**, el **parámetro** que lo recibe se referirá al **mismo objeto** al que hace **referencia** el **argumento** no al de la **clase** que lo instancio