JAVA - Métodos

Signed-off-by: diwes-gh <alejandro@alejandroalsa.es>

Author: alejandroalsa

_posts/2023-12-15-java-metodos-clase.md

@@ -0,0 +1,127 @@
+---
+title: métodos de clase
+date: 2023-12-15 12:00:00 +0800
+categories: [Programación, Java]
+tags: [Java]
+---
+
+# Métodos de clase
+
+Haciendo memoria recordamos que un método es un bloque de código que solo se ejecuta cuando se llama.
+
+```java
+public class main{
+  static void mimétodo(){
+    System.out.println("Hola Mundo!!");
+  }
+
+  public static void main(String[] args){
+    mimétodo();
+  }
+}
+```
+
+## Estático vs Público
+
+A menudo veras que en  Java aparecen `static` o `public` atributos y métodos.
+
+En el ejemplo anterior, creamos un método `static`, lo que se puede acceder a el sin crear un objeto de clase, a diferencia de `public`, al que se puede acceder mediante objetos:
+
+```java
+// Ejemplo practico para demostrar las diferencias entre `static` y `public`
+
+public class main{
+  // Método estático
+  static void metodoEstatico() {
+    System.out.println("Los métodos estáticos pueden invocarse sin crear objetos");
+  }
+
+  // Método publico
+  public void metodoPublico(){
+    System.out.println("Los métodos públicos deben ser invocados mediante la creación de objetos");
+  }
+
+  // Método principal
+  public static void main(String[] args){
+    metodoEstatico();
+    // métodoPublico(); Al compilar daría error
+    
+    main myObjeto = new main();
+    myObjeto.metodoPublico();
+  }
+}
+```
+
+## Métodos de acceso con un objeto
+
+```java
+// Crea un objeto llamado `miCoche`. Llama a `aceleracion()` y `valocidad()` en el objeto `miCoche` y ejecuta el programa.
+
+// Creamos la clase main
+public class main{
+
+  // Creamos el método aceleracion
+  public void aceleracion(){
+    System.out.println("¡El coche va tan rápido como puede!");
+  }
+
+  // Creamos el método y añadimos el parámetro velocidad
+  public void velocidad(int velocidadMaxima){
+    System.out.println("La velocidad maxima es: " + velocidadMaxima + "Km/h");
+  }
+
+  // Dentro de main, llamamos a los métodos del objeto miCoche
+  public static void main(String[] args){
+    main miCoche = new main(); // Creamos el objeto miCoche
+    miCoche.aceleracion(); // Llamamos al método aceleracion
+    miCoche.velocidad(200); // Lamamos al método velocidad y le indicamos el valor del parámetro
+  }
+}
+```
+
+Salida: 
+
+```txt
+¡El coche va tan rápido como puede!
+La velocidad máxima es: 200Km/h
+```
+
+## Utilizando múltiples clases
+
+Como vimos en la publicación de "Clases", es una buena practica crear un objeto de una clase y acceder a el en otro clase (en otro .java)
+
+```java
+// main.java
+
+public class main{
+  
+  public void aceleracion(){
+    System.out.println("¡El coche va tan rápido como puede!");
+  }
+
+  public void velocidad(int velocidadMaxima){
+    System.out.println("La velocidad máxima es: " + velocidadMaxima + "Km/h");
+  }
+}
+```
+
+```java
+// execute.java
+
+public class execute{
+
+  public static void main(String[] args){
+
+	main miCoche = new main();
+    miCoche.aceleracion();
+    miCoche.velocidad(200);
+  }
+}
+```
+
+Salida: 
+
+```txt
+¡El coche va tan rápido como puede!
+La velocidad máxima es: 200Km/h
+```

_posts/2023-12-15-java-programacion-orientada-objetos.md

@@ -7,14 +7,14 @@ tags: [Java]
 
 # Programación orientada a objetos - POO
 
-La programación convencional consisten en escribir procedimientos o métodos que realicen operaciones sobre los datos, mientras que la POO se trata de crear objetos que contangan datos y métodos.
+La programación convencional consisten en escribir procedimientos o métodos que realicen operaciones sobre los datos, mientras que la POO se trata de crear objetos que contengan datos y métodos.
 
-Esta tiene cietas ventajas frente a la programación convencional:
+Esta tiene ciertas ventajas frente a la programación convencional:
 
-* Es mas rapida y facil de ejecutar
+* Es mas rápida y fácil de ejecutar
 * Proporciona una estructura clara para los programas
-* Ayuda a mantener el codigo SECO (sin repeticiones) y hace que el codigo sea más facil de mantener, entender, modificar y depurar
-* Permite crear herramientas totalmente reutilizablas, aplicaciones con menos codigo y menor tiempo de desarrollo.
+* Ayuda a mantener el código SECO (sin repeticiones) y hace que el código sea más fácil de mantener, entender, modificar y depurar
+* Permite crear herramientas totalmente reutilizabas, aplicaciones con menos código y menor tiempo de desarrollo.
 
 ## Clases y Objetos
 
@@ -34,7 +34,7 @@ Las clases y los objetos son los dos aspectos principales de la POO.
 
 Una clase es una plantilla para objetos y un objeto es una instancia de una clase, cuando se crean los objetos individuales, heredan todas las variables y métodos de la clase.
 
-Todo en Java esta asociado con lcases y objetos, junto con sus atributos y metodos. Por ejemplo: en la vida real un coches es un objeto y este tiene atributos, como peso, color, y métodos, como conducir y frenar.
+Todo en Java esta asociado con clases y objetos, junto con sus atributos y métodos. Por ejemplo: en la vida real un coches es un objeto y este tiene atributos, como peso, color, y métodos, como conducir y frenar.
 
 Una clase es como un constructor de objetos o un "modelo" para crear objetos.
 
@@ -57,9 +57,9 @@ public class main{
 
 ## Múltiples clases
 
-Tambien puedes crear un objeto de una clase y acceder a él en otra clase. Esto se utiliza a menudo para una mejor organizacion de las clases (una de las clases tiene todos los atributos y metodos, mientras que la otra clase tiene los metodos)
+También puedes crear un objeto de una clase y acceder a él en otra clase. Esto se utiliza a menudo para una mejor organización de las clases (una de las clases tiene todos los atributos y métodos, mientras que la otra clase tiene los métodos)
 
-Recuerda que el nombre del archivo `.java` debe conincidir con el nombre de la clase, por eso crearemos dos archivos uno llamado `main.java` y otro `execute.java`
+Recuerda que el nombre del archivo `.java` debe coincidir con el nombre de la clase, por eso crearemos dos archivos uno llamado `main.java` y otro `execute.java`
 
 ```java
 // main.java
@@ -85,3 +85,124 @@ Salida de `execcute.java`
 ```text
 5
 ```
+
+## Atributos de clase Java
+
+Anteriormente utilizamos el termino "variable" para `x`, como se muestra a continuación. En realidad es un atributo de clase. O se podría decir que los atributos de clases son variables dentro de una clase.
+
+```java
+// Crea una clase llamada "main" con dos atributos "x" e "y"
+
+public class main{
+  int x = 10;
+  int y = 20;
+}
+```
+
+> NOTA: Otro termino para los atributos de clases es campos.
+
+### Acceso a los atributos
+
+Podemos acceder a los atributos creando un objeto de clase y utilizando la sintaxis de puntos `.`.
+
+En el siguiente ejemplo crearemos un objeto de la clase `main` con el nombre `myObjeto` y utilizaremos el atributo `x` en el objeto para imprimir su valor:
+
+```java
+// Crear un objeto llamado `myObjeto` e imprimir el valor de `x`
+
+public class main{
+  int x = 10;
+
+
+  public static void main(String[] args){
+    main myObjeto = new main();
+    System.out.println(myObjeto.x);
+
+  }
+}
+```
+
+### Modificar atributos
+
+Al igual que podemos modificar el valor de las variables como vimos en anteriores post, los atributos también los podemos modificar:
+
+```java
+public class main{
+  int x = 10;
+
+  public static void main(String[] args){
+    main myObjeto = new main();
+    myObjeto.x = 20;
+    System.out.println(myObjeto.x);
+  }
+}
+```
+
+Salida:
+
+```txt
+20
+```
+
+O también podemos indicar que no se puede modificar el valor de una variable
+
+```java
+public class main{
+  final int x = 10;
+
+  public static void main(String[] args){
+    main myObjeto = new main();
+    myObjeto.x = 10; // Generará un error: no se puede asignar un valor a una variable final
+    System.out.println(myObjeto.x);
+  }
+}
+```
+
+> NOTA: `final` es una palabra clave y es útil utilizarla cuando deseamos que el valor de una variable se almacene de forma permanente como el valor del numero PI (3.14159265359...)
+
+### Múltiples objetos
+
+Si creamos varios objetos de una clase, podemos cambiar los valores de los atributos (llamados "variables" fuera del contexto POO) en un objeto, sin afectar a los valores del atributo en otros objetos:
+
+
+```java
+public class main{
+  int x = 10;
+
+
+  public static void main(String[] args){
+    main myObjetoX = new main();
+    main myObjetoY = new main();
+
+    myObjetoX.x = 20;
+    System.out.println(myObjetoY.x);
+    System.out.println(myObjetoX.x);
+  }
+}
+```
+
+Salida;
+
+```txt
+10
+20
+```
+
+#### Múltiples atributos
+
+Podemos especificar varios atributos (variables) como queramos:
+
+
+```java
+public class main{
+  String nombre = "Alejandro";
+  String apellidos = "Alfaro Sánchez";
+  int edad = 20;
+
+  public static void main(String[] args){
+    main datosPersonales = new main();
+
+    System.out.println("Nombre: " + datosPersonales.nombre + ", Apellidos: " + datosPersonales.apellidos + ", Edad: " + datosPersonales.edad);
+  }
+}
+```