JAVA - Constructores, Encapsulación, Herencia, Modificadores y Paquetes-APIs

alejandroalsa · alejandroalsa · commit 504ef4657f0d · 2024-01-03T18:33:11.000+01:00
Signed-off-by: diwes-gh &lt;alejandro@alejandroalsa.es&gt;
diff --git a/_posts/2024-01-03-java-constructores.md b/_posts/2024-01-03-java-constructores.md
@@ -0,0 +1,80 @@
+---
+title: Constructores
+date: 2024-01-03 12:00:00 +0800
+categories: [Programación, Java]
+tags: [Java]
+---
+
+# Constructores
+
+Un constructor en Java es un método especial que se utiliza para inicializar objetos. Se llama al constructor cuando se crea un objeto de una clase. Se puede utilizar para establecer valores iniciales para los atributos del objeto.
+
+```java
+// Crea un constructor
+
+public class main{
+  int x; // Creación de un atributo de clase
+
+  // Creación de un constructor de clase para la clase main
+  public class main(){
+    x = 5;
+  }
+
+  public static void main(String[] args){
+    main miObjeto = new main(); // Crear un objeto de la clase main (un constructor)
+    System.out.println(miObjeto.x);
+  }
+}
+```
+
+Ten en cuenta que el nombre del constructor debe coincidir con el nombre de la clase y no puede ser de tipo de retorno (como `void`), ademas para poder llamar a un constructor es necesario que se cre un objeto, como en los métodos públicos.
+
+## Parámetros del constructor
+
+Los constructores también pueden tomar parámetros, que se utilizan para inicializar atributos.
+
+```java
+public class main{
+  int x;
+
+  public main(int y){
+    x = y + 20;
+  }
+
+  public static void main(String[] args){
+    main miObjeto = new main(10);
+    System.out.println(miObjeto.x);
+  }
+}
+```
+
+Salida:
+
+```txt
+30
+```
+
+Podemos agregar tantos parámetros como queramos
+
+```java
+// Crea una calculadora que resuelva ecuaciones de segundo grado
+
+public class main{
+
+  double resultadoA;
+  double resultadoB;
+
+  public main(int a, int b, int c){
+	double operaciones = b*b-4*a*c;
+
+    resultadoA = (-b + Math.sqrt(operaciones)) / (2*a);
+    resultadoB = (-b - Math.sqrt(operaciones)) / (2*a);
+  }
+
+  public static void main(String[] args){
+    main ecuacionesSegundoGrado = new main(2, 5, 2);
+    System.out.println("Resultado A: " + ecuacionesSegundoGrado.resultadoA);
+    System.out.println("Resultado B: " + ecuacionesSegundoGrado.resultadoB);
+  }
+}
+```
diff --git a/_posts/2024-01-03-java-encapsulacion.md b/_posts/2024-01-03-java-encapsulacion.md
@@ -0,0 +1,69 @@
+---
+title: Encapsulación
+date: 2024-01-03 12:00:00 +0800
+categories: [Programación, Java]
+tags: [Java]
+---
+
+# Encapsulación
+
+El significado de encapsulación es asegurarse de que los datos sensibles estén ocultos de los usuarios, para poder lograr esto debemos declarar las variables y los atributos como `private` y proporcionar acceso publico y establecer métodos para acceder y actualizar el valor de na variable `private`
+
+## Obtener y configurar
+
+En otras publicaciones vimos que las variables declaradas como `private` solo pueden ser accedidas dentro de la misma clase, sin embargo, es posible acceder a ellas si proporcionamos métodos públicos de obtención y configuración.
+
+La sintaxis de ambas es que empiezan por `get` o `set`, seguidas del nombre de la variable, con la primera letra en mayúscula.
+
+```java
+public class persona{
+  private String nombre; // private = acceso restringido
+
+  // get
+  public String getnombre() {
+    return nombre;
+  }
+
+  // set
+  public void setnombre(String nuevoNombre){
+    this.nombre = nuevoNombre;
+  } 
+}
+```
+
+El método `get` devuelve el valor de la variable `name`
+
+El método `set` toma un parámetro (`nuevoNombre`) y lo asigna a la variable `nombre`. Después la utilizamos la palabra clave `this` para referirnos al objeto actual.
+
+Sin embargo, como `nombre` esta declarado como `private`, no podremos acceder a ella fuera de la clase.
+
+```java
+public class main{
+  public static void main(String[] args){
+    persona miObjeto = new persona();
+    miObjeto.nombre = "Alex"; // Error
+    System.out.println(miObjeto.nombre); // Error
+  }
+}
+```
+
+Si la variable estuviera declarada como `public`, nos devolvería: `Alejandro`, pero como esta declarada como `private`, obtendremos un error.
+
+Para evitar este error utilizaremos `getNombre()` y `setNombre()` para poder acceder y actualizar la variable.
+
+```java
+public class main{
+  public static void main(String[] args){
+    persona miObjeto = new persona();
+    miObjeto.setNombre("Alex");
+    System.out.println(miObjeto.getNombre());
+  }
+}
+```
+
+## ¿Por qué encapsular?
+
+* Mejor control de los atributos y métodos de clase
+* Los atributos de clase se pueden hacer de solo lectura (si solo utilizamos `get`) o de solo escritura (si solo utilizamos `set`)
+* Flexible, el programador puede cambiar una parte del código sin afectar a otras partes
+* Mayor seguridad de los datos
diff --git a/_posts/2024-01-03-java-herencia.md b/_posts/2024-01-03-java-herencia.md
@@ -0,0 +1,58 @@
+---
+title: Herencia
+date: 2024-01-03 12:00:00 +0800
+categories: [Programación, Java]
+tags: [Java]
+---
+
+# Herencia
+
+En Java es posible heredar atributos y métodos de una clase a otra (herencia), este concepto lo podemos categorizar en dos categorías:
+
+* **Subclase** (secundaria): La clase que hereda de otra clase
+* **Superclase** (padre): La clase de la que se hereda
+
+Para heredar de una clase, utilizamos la palabra clave `extends`
+
+En el siguiente ejemplo la clase `coche` (subclase) hereda atributos y métodos de la clase `vehiculos` (superclase)
+
+```java
+class vehiculo {
+    protected String marca = "Ford"; // Atributo del vehículo
+    public void bocina(){              // Método del vehículo
+        System.out.println("Tuut, tuut!");
+    }
+}
+
+class coche extends vehiculo {
+    private String nombreModelo = "Raptor";  // Atributo del coche
+    public static void main(String[] args){
+
+
+        // Creo mi objeto coche
+        coche miCoche = new coche();
+
+        // Llamo al metodo bocina (de la clase de vehículo) en el objeto coche
+        miCoche.bocina();
+
+
+        // Muestro el valor del atributo nombreModelo de la clase vehiculo y el valor del nombreModelo de la clase coche
+        System.out.println(miCoche.marca + " " + miCoche.nombreModelo);
+    }
+}
+```
+
+Si te das cuenta establecemos el atributo de marca en vehículo con un `protected`. Si estuviera configurado en private, la clase `coche` no podría acceder a él.
+
+Al igual que definíamos variables con `final` para evitar su modificación, en las clases también lo podemos hacer añadiendo la misma palabra clave (`final`):
+
+
+```java
+final class vehiculo {
+    // ...
+}
+
+class coche extends vehiculo {
+    // Error
+}
+```
diff --git a/_posts/2024-01-03-java-modificadores.md b/_posts/2024-01-03-java-modificadores.md
@@ -0,0 +1,131 @@
+---
+title: Modificadores
+date: 2024-01-03 12:00:00 +0800
+categories: [Programación, Java]
+tags: [Java]
+---
+
+# Modificadores
+
+Si has leído los otras publicaciones relacionadas con el curso de Java ya estarás mas que familiarizado con `public class main` palabra clave que aparece en todos mis ejemplos.
+
+La palabra clave `public` es un modificador de acceso, lo que significa que se utiliza para establecer el nivel de acceso para clases, atributos, métodos y constructores.
+
+Dividiremos los modificadores en dos grupos:
+
+* **Modificadores de acceso**: Controla en nivel de acceso 
+* **Modificadores sin acceso**: No controla el nivel de acceso, pero proporciona otras funciones
+
+## Modificadores de acceso
+
+Para **las clases**, podemos utilizar cualquiera de los dos: `public` y `default`
+
+* `public` La clase es accesible por cualquier otra clase
+
+```java
+public class main{
+  public static void main(String[] args){
+    System.out.println("alejandroalsa.es");
+  }
+}
+```
+
+* `default` La clase sólo es accesible por las clases del mismo paquete. Esta se utiliza cuando no se especifica un modificador. (Mas adelante veremos los paquetes)
+
+```java
+class main{
+  public static void main(String[] args){
+    System.out.println("alejandroalsa.es");
+  }
+}
+```
+
+Para **atributos, métodos y constructores**, podemos usar los siguientes:
+
+* `public` El código es accesible por otras clases
+* `private` El código solo es accesible dentro de la clase declarada
+
+```java
+public class main{
+
+  private String nombre = "Alejandro";
+  private String apellidos = "Alfaro Sánchez";
+
+  public static void main(String[] args){
+    main nombreApellidos = new main();
+    System.out.println(nombreApellidos.nombre + " " + nombreApellidos.apellidos);
+  }
+}
+```
+
+* `default` El codigo solo es accesible en el mismo paquete, se suele utilizar cuando no se especifica un modificador (Más adelante veremos los paquetes)
+
+```java
+class main{
+
+  String nombre = "Alejandro";
+  String apellidos = "Alfaro Sánchez";
+
+  public static void main(String[] args){
+    main nombreApellidos = new main();
+    System.out.println(nombreApellidos.nombre + " " + nombreApellidos.apellidos);
+  }
+}
+```
+
+* `protected` El código solo es accesible en el mismo paquete y subclases. (Más adelante veremos las subclases, superclases y herencia)
+
+```java
+class persona{
+  protected String nombre = "Alejandro";
+  protected String apellidos = "Alfaro Sánchez";
+  protected int edad = 20;
+  protected String correoElectronico = "alejandro@alejandroalsa.es";
+}
+class estudiantes extends persona{
+  private int fechaGraduacion = 2024;
+  public static void main(String[] args){
+    estudiantes miObjeto = new estudiantes();
+    System.out.println("Nombre: " + miObjeto.nombre + " " + miObjeto.apellidos);
+    System.out.println("Edad: " + miObjeto.edad);
+    System.out.println("Correo Electrónico: " + miObjeto.correoElectronico);
+    System.out.println("Año de graduación: " + miObjeto.fechaGraduacion);
+  }
+}
+```
+
+## Modificadores de no acceso
+
+Para **las clases**, puedes usar cualquiera de los dos, `final` o `abstract`.
+
+* `final` La clase no puede ser heredada por otras clases (más adelante veremos mas sobre herencia).
+
+* `abstract` La clase no puede utilizarse ara crear objetos, para acceder a una clase abstracta, debe heredarse de otra clase (más adelante veremos mas sobre herencia).
+
+```java
+// Clase abstracta
+
+abstract class main{
+  public String nombre = "Alejandro";
+  public String apellidos = "Alfaro Sánchez";
+  public String correoElectronico = "alejandro@alejandroalsa.es";
+  public int edad = 20;
+  public abstract void estudiante(); // Método abstracto
+}
+
+class estudiantes extends main{
+  public int fechaGraduacion = 2024;
+  public void estudiante(){
+    System.out.println("Estudiar todo el día");
+  }
+}
+```
+
+Para **atributos y métodos**
+
+* `final` Los atributos y métodos no pueden ser modificados.
+* `static` Los atributos y métodos pertenecen a la clase, en lugar de a un objeto
+* `abstract` Sólo se puede utilizar en una clase abstracta, y sólo se puede utilizar en métodos. El método no tiene cuerpo, por ejemplo `abstract void run();`. El cuerpo es proporcionado por la subclase (heredado de). 
+* `transient` Atributos y métodos se omiten al serializar el objeto que los contiene
+* `synchronized` Los métodos sólo pueden ser accedidos por un hilo a la vez
+* `volatile` El valor de un atributo no se almacena en caché localmente, y siempre se lee de la "memoria principal".
diff --git a/_posts/2024-01-03-java-paquetes-api.md b/_posts/2024-01-03-java-paquetes-api.md
