From 15667fc432f2a98dfce02497978018090ad5c032 Mon Sep 17 00:00:00 2001 From: diwes-gh Date: Tue, 2 Jan 2024 17:20:20 +0100 Subject: [PATCH] =?UTF-8?q?JAVA=20-=20M=C3=A9todos?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: diwes-gh --- _posts/2023-12-15-java-metodos-clase.md | 127 ++++++++++++++++ ...-15-java-programacion-orientada-objetos.md | 137 +++++++++++++++++- 2 files changed, 256 insertions(+), 8 deletions(-) create mode 100644 _posts/2023-12-15-java-metodos-clase.md diff --git a/_posts/2023-12-15-java-metodos-clase.md b/_posts/2023-12-15-java-metodos-clase.md new file mode 100644 index 0000000..2aea51d --- /dev/null +++ b/_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 +``` diff --git a/_posts/2023-12-15-java-programacion-orientada-objetos.md b/_posts/2023-12-15-java-programacion-orientada-objetos.md index 31b28ef..32eeb1a 100644 --- a/_posts/2023-12-15-java-programacion-orientada-objetos.md +++ b/_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); + } +} +```