Métodos de Java y Programación Orientada a Objetos Básica

Introducción

Este laboratorio mejorará tus habilidades en Java presentando métodos y los fundamentos de la programación orientada a objetos (OOP, por sus siglas en inglés). Estos conceptos son esenciales para escribir código bien estructurado, reutilizable y eficiente. Cubriremos:

1. Crear y utilizar métodos para organizar el código y facilitar la reutilización.
2. Comprender las ideas principales detrás de las clases y los objetos.
3. Implementar una clase básica que incluya métodos y atributos.

Al final de este laboratorio, serás capaz de escribir programas en Java que utilicen métodos para dividir problemas complejos en segmentos más pequeños y manejables. También adquirirás una comprensión de cómo funciona la programación orientada a objetos en Java, una habilidad crucial para construir aplicaciones más grandes y complejas. Si estos conceptos parecen complicados al principio, no te preocupes, los abordaremos paso a paso y, al final del laboratorio, apreciarás cómo estas ideas contribuyen a un código más organizado y potente.

¡Comencemos!

Entendiendo y Creando Métodos

Los métodos son esencialmente pequeños programas dentro de tu programa principal. Te ayudan a organizar tu código, mejorar su legibilidad y habilitar la reutilización del código sin necesidad de escribir el mismo código repetidamente. Considera los métodos como herramientas especializadas en un conjunto de herramientas, cada una diseñada para un propósito específico.

1. Comienza abriendo el archivo MethodDemo.java en el WebIDE. Deberías ver este código de inicio:

   public class MethodDemo {
       public static void main(String[] args) {
           System.out.println("Welcome to the Method Demo!");
   
           // TODO: Call methods here
       }
   
       // TODO: Add methods here
   }
   

   Esta es la estructura fundamental de nuestro programa Java. El método main es el punto de entrada donde comienza la ejecución de nuestro programa.

2. Ahora, creemos nuestro primer método. Haremos un método simple que imprima un saludo. Agrega este método fuera y después del método main, al nivel de la clase:

   public class MethodDemo {
       public static void main(String[] args) {
           System.out.println("Welcome to the Method Demo!");
   
           // TODO: Call methods here
       }
   
       // Add the new method here, outside and after the main method
       public static void printGreeting(String name) {
           System.out.println("Hello, " + name + "! Welcome to Java methods.");
       }
   }
   

   Analicemos lo que esto significa:

   • public: Esta palabra clave indica que se puede acceder al método desde otras clases.
   • static: Esto significa que el método pertenece a la clase misma, no a una instancia particular de la clase. Profundizaremos en este concepto más adelante; por ahora, piénsalo como un requisito para los métodos que queremos usar sin crear un objeto.
   • void: Esto significa que nuestro método no devuelve ningún valor. Realiza una acción (imprimir un saludo), pero no devuelve ningún dato.
   • printGreeting: Este es el nombre que le hemos asignado a nuestro método. Usaremos este nombre para invocar o llamar al método.
   • (String name): Este es un parámetro: una pieza de datos que acepta nuestro método. Espera un String (cadena de texto), que hemos llamado name. Cuando llamemos a este método, deberemos proporcionar un valor para este parámetro.

3. ¡Genial! Ahora que hemos creado un método, usémoslo. Dentro del método main, reemplaza el comentario // TODO: Call methods here con:

   printGreeting("Alice");
   

   

   Esta línea llama o invoca nuestro método printGreeting y le pasa el nombre "Alice" como un argumento. El argumento proporciona la entrada específica que el método necesita para realizar su acción.

4. Guarda el archivo y compilemos y ejecutemos el programa. En la terminal en la parte inferior de tu WebIDE, escribe estos comandos:

   javac ~/project/MethodDemo.java
   java -cp ~/project MethodDemo
   

   El primer comando compila nuestro archivo Java, traduciéndolo a bytecode (código de bytes) que la Java Virtual Machine (JVM) puede entender. El segundo comando ejecuta el programa compilado. Deberías ver una salida similar a esta:

   Welcome to the Method Demo!
   Hello, Alice! Welcome to Java methods.
   

5. ¡Excelente! Acabas de crear y utilizar tu primer método Java. Llamémoslo de nuevo con un nombre diferente. Agrega esta línea en el método main, justo después de la primera llamada a printGreeting:

   printGreeting("Bob");
   

6. Guarda, compila y ejecuta el programa nuevamente. Ahora deberías ver:

   Welcome to the Method Demo!
   Hello, Alice! Welcome to Java methods.
   Hello, Bob! Welcome to Java methods.
   

   ¿Notas cómo podemos reutilizar nuestro método con diferentes entradas? Este es un beneficio significativo del uso de métodos.

7. Ahora, creemos un método que devuelva un valor. Agrega este método a tu clase, debajo del método printGreeting:

   public static int sumNumbers(int a, int b) {
       return a + b;
   }
   

   Este método acepta dos enteros, los suma y devuelve el resultado. Observa que en lugar de void, usamos int para indicar que este método devuelve un valor entero.

8. Usemos este nuevo método en nuestro método main. Agrega estas líneas al final del método main:

   int result = sumNumbers(5, 7);
   System.out.println("The sum of 5 and 7 is: " + result);
   

   Aquí, estamos invocando nuestro método sumNumbers, proporcionando los valores 5 y 7 como argumentos. El valor de retorno del método se almacena luego en una variable llamada result. Después de almacenar el valor de retorno, imprimimos el valor en la consola.

9. Guarda, compila y ejecuta el programa una vez más. Ahora deberías ver la salida adicional:

   The sum of 5 and 7 is: 12
   

   

¡Felicitaciones! Has creado y utilizado tus primeros métodos Java. Has visto cómo los métodos pueden realizar acciones (como mostrar saludos) y proporcionar valores de retorno (como la suma de dos números). Los métodos te permiten estructurar tu código en piezas más pequeñas y reutilizables, lo que hace que tus programas sean más fáciles de entender y mantener.

Introducción a Clases y Objetos

Ahora que comprendemos los métodos, demos un paso hacia la programación orientada a objetos creando una clase simple. En la programación orientada a objetos, usamos las clases como planos para crear objetos. Piensa en una clase como un cortapastas y en los objetos como las galletas que haces con él.

1. Abre Car.java y comencemos a construir nuestra clase. Primero, definiremos la clase y agregaremos algunos atributos:

   public class Car {
       // Attributes
       private String make;
       private String model;
       private int year;
   }
   

   Estos atributos (también llamados campos o propiedades) definen lo que cada objeto Car tendrá. Cada automóvil tendrá una marca, un modelo y un año de fabricación.

   La palabra clave private significa que estos atributos solo pueden ser accedidos desde dentro de la clase misma. Este es un ejemplo de encapsulación, un concepto que ayuda a proteger la integridad de los datos dentro de nuestros objetos.

2. Ahora, agreguemos un constructor a nuestra clase. Un constructor es un método especial que se llama automáticamente cuando creamos un nuevo objeto. Se utiliza principalmente para inicializar los atributos del objeto. Agrega este constructor a tu clase Car:

   // Constructor
   public Car(String make, String model, int year) {
       this.make = make;
       this.model = model;
       this.year = year;
   }
   

   Este constructor toma tres parámetros y los utiliza para establecer los valores de nuestros atributos. La palabra clave this se utiliza para referirse a los atributos del objeto actual; ayuda a diferenciar entre el atributo del objeto y el parámetro pasado al constructor cuando sus nombres son idénticos.

3. A continuación, agreguemos un método a nuestra clase que mostrará información sobre el automóvil. Agrega este método a tu clase Car:

   // Method
   public void displayInfo() {
       System.out.println("Car Information:");
       System.out.println("Make: " + make);
       System.out.println("Model: " + model);
       System.out.println("Year: " + year);
   }
   

Este método no toma ningún parámetro y no devuelve ningún valor. Simplemente imprime la información del automóvil en la consola.

4. ¡Genial! Hemos creado nuestra clase Car. Ahora abramos CarDemo.java y agreguemos el siguiente código:

   public class CarDemo {
       public static void main(String[] args) {
           // We'll add code here in the next step
       }
   }
   

   Esto establece la estructura básica de nuestro programa de demostración.

5. Ahora, creemos algunos objetos Car y usémoslos. Agrega este código dentro del método main:

   Car myCar = new Car("Toyota", "Corolla", 2022);
   myCar.displayInfo();
   
   Car friendsCar = new Car("Honda", "Civic", 2023);
   friendsCar.displayInfo();
   

   Aquí, estamos creando dos objetos Car. La palabra clave new se utiliza para crear un nuevo objeto, y estamos llamando al constructor que definimos anteriormente para establecer la marca, el modelo y el año. Luego, estamos llamando al método displayInfo en cada objeto de automóvil para mostrar sus propiedades.

6. Antes de compilar y ejecutar nuestro programa, es importante tener en cuenta que estamos trabajando con múltiples archivos Java (Car.java y CarDemo.java). Cuando se compilan múltiples archivos que tienen dependencias, debemos compilarlos juntos. Además, asegúrate de que CarDemo.java y Car.java estén ubicados en el mismo directorio; de lo contrario, necesitarás importar la clase Car al principio de CarDemo.java como se muestra a continuación.

   Si CarDemo.java y Car.java se encuentran en diferentes directorios, es posible que debas agregar una declaración de importación en la parte superior de CarDemo.java:

   import packagename.Car;  // Replace 'packagename' with the actual package name if applicable
   

   Ahora, compilémos y ejecutemos el programa CarDemo:

   javac ~/project/Car.java ~/project/CarDemo.java
   java -cp ~/project CarDemo
   

   El primer comando compila ambos archivos Java juntos, asegurando que se aborden todas las dependencias. El segundo comando ejecuta nuestra clase CarDemo.

   Deberías ver una salida como esta:

   Car Information:
   Make: Toyota
   Model: Corolla
   Year: 2022
   Car Information:
   Make: Honda
   Model: Civic
   Year: 2023
   

¡Felicidades! Acabas de crear tu primera clase Java y la has utilizado para crear objetos. Esta es la base de la programación orientada a objetos en Java. Has definido un plano (la clase Car) y lo has utilizado para crear instancias específicas (los objetos Car). Cada objeto tiene su propio conjunto único de atributos, pero todos comparten la estructura y el comportamiento definidos por la clase.

Mejorando Nuestra Clase con Más Métodos

Ahora que tenemos una comprensión básica de las clases y los objetos, mejoremos nuestra clase Car con más métodos para aumentar su utilidad. Agregaremos métodos que representen acciones que un automóvil puede realizar y propiedades sobre las que podríamos querer preguntar sobre un automóvil.

1. Abre el archivo Car.java. Vamos a agregar un método que represente al automóvil acelerando. Agrega este método a la clase Car:

   public void accelerate() {
       System.out.println("The " + make + " " + model + " is accelerating.");
   }
   

   Este método no modifica ninguno de los atributos del automóvil; simplemente muestra un mensaje sobre el automóvil acelerando.

2. Ahora, agreguemos un método para frenar. Agrega este método a la clase Car:

   public void brake() {
       System.out.println("The " + make + " " + model + " is braking.");
   }
   

   Este método también solo muestra un mensaje sobre la acción del automóvil, al igual que el método accelerate anterior.

3. A continuación, agreguemos un método que proporcione información sobre el automóvil. Agrega este método:

   public String getMakeAndModel() {
       return make + " " + model;
   }
   

   Este método combina la marca y el modelo en una sola cadena y la devuelve. Observa que el tipo de retorno es String, no void, ya que este método nos está proporcionando información.

4. Finalmente, agreguemos un método que determine si un automóvil se clasifica como antiguo. En muchos lugares, un automóvil se considera antiguo si tiene más de 25 años. Agrega este método:

    public boolean isAntique() {
        int currentYear = java.time.Year.now().getValue();
        return (currentYear - year) > 25;
    }
   

   Este método utiliza la clase Year incorporada de Java para obtener el año actual. Luego calcula la edad del automóvil y devuelve true si tiene más de 25 años, y false en caso contrario.

5. Con estos métodos adicionales agregados a nuestra clase Car, actualicemos nuestro archivo CarDemo.java para usarlos. Abre CarDemo.java y reemplaza su contenido con:

   public class CarDemo {
       public static void main(String[] args) {
           Car myCar = new Car("Toyota", "Corolla", 2022);
           Car classicCar = new Car("Ford", "Mustang", 1965);
   
           myCar.displayInfo();
           myCar.accelerate();
           myCar.brake();
   
           System.out.println(classicCar.getMakeAndModel() + " is an antique: " + classicCar.isAntique());
   
           Car[] carArray = {myCar, classicCar};
           for (Car car : carArray) {
               System.out.println(car.getMakeAndModel() + " is an antique: " + car.isAntique());
           }
       }
   }
   

   Este nuevo método main logra varias cosas:

   • Crea dos objetos Car: un automóvil moderno y un automóvil clásico.
   • Llama a nuestros métodos recién agregados accelerate y brake en el objeto de automóvil moderno.
   • Utiliza los métodos getMakeAndModel e isAntique en el objeto de automóvil clásico.
   • Crea una matriz de objetos Car y utiliza un bucle for-each para iterar sobre ellos, demostrando cómo podemos manejar colecciones de objetos.

6. Guarda ambos archivos, luego compila y ejecuta el programa CarDemo:

   javac ~/project/Car.java ~/project/CarDemo.java
   java -cp ~/project CarDemo
   

   Deberías ver una salida similar a esta:

   Car Information:
   Make: Toyota
   Model: Corolla
   Year: 2022
   The Toyota Corolla is accelerating.
   The Toyota Corolla is braking.
   Ford Mustang is an antique: true
   Toyota Corolla is an antique: false
   Ford Mustang is an antique: true
   

¡Felicidades! Has ampliado significativamente tu clase Car y creado un programa más complejo utilizando objetos. Esto demuestra cómo se puede utilizar la programación orientada a objetos para modelar conceptos del mundo real en código. Cada objeto de automóvil ahora tiene sus propios datos (marca, modelo, año) y acciones (acelerar, frenar, etc.), al igual que los automóviles reales.

1. Agregamos métodos a nuestra clase Car que representan acciones (accelerate() y brake()). Si bien estos métodos no alteran el estado del automóvil en nuestra implementación actual, en un programa más complejo, podrían modificar atributos como la velocidad o el nivel de combustible.

2. Agregamos getMakeAndModel(), que combina dos piezas de información en una sola cadena. Este es un patrón común en la programación orientada a objetos: crear métodos que ofrezcan un acceso conveniente a los datos del objeto.

3. El método isAntique() muestra cómo se pueden combinar los datos del objeto (el año del automóvil) con información externa (el año actual) para obtener nueva información sobre un objeto.

4. En nuestra clase CarDemo, demostramos cómo crear y usar múltiples objetos, cómo llamar a varios métodos en estos objetos y cómo iterar a través de una matriz de objetos.

Este ejemplo demuestra el poder de la programación orientada a objetos. Hemos creado una clase Car que encapsula tanto datos (marca, modelo, año) como comportamiento (acelerar, frenar, isAntique). Cada objeto Car que creamos es independiente, con su propio conjunto único de datos, pero todos siguen el mismo conjunto de acciones definidas por la clase.

Resumen

En este laboratorio, hemos avanzado significativamente en nuestro viaje de programación en Java. Hemos cubierto algunos conceptos básicos pero esenciales que son fundamentales para escribir programas Java más complejos y organizados. Resumamos lo que hemos aprendido:

1. Métodos:

   • Creamos y utilizamos métodos para estructurar nuestro código y hacerlo más reutilizable.
   • Exploramos cómo los métodos pueden aceptar parámetros y devolver valores, lo que nos permite dividir problemas complejos en tareas más pequeñas y manejables.
   • Los métodos nos ayudan a reducir la repetición de código y a hacer nuestros programas más fáciles de comprender y mantener.

2. Clases y Objetos:

   • Introdujimos el concepto de clases como planos para crear objetos.
   • Construimos una clase Car con atributos (marca, modelo, año) y métodos (displayInfo, accelerate, brake, etc.).
   • Aprendimos cómo instanciar objetos (instancias de una clase) y llamar a métodos en esos objetos.

3. Programación Orientada a Objetos:

   • Observamos cómo la programación orientada a objetos nos permite modelar ideas del mundo real en nuestro código.
   • Encapsulamos datos (atributos) y comportamiento (métodos) dentro de nuestra clase Car.
   • Creamos múltiples objetos Car, demostrando cómo cada objeto tiene su propio conjunto de datos pero comparte las mismas acciones definidas por la clase.

4. Funcionalidad Mejorada de la Clase:

   • Ampliamos nuestra clase Car con métodos más complejos, incluyendo uno que utiliza las herramientas de fecha incorporadas de Java para determinar si un automóvil es un automóvil antiguo.
   • Vimos cómo los métodos pueden interactuar con los datos del objeto y la información externa para generar nueva información.

5. Trabajando con Múltiples Objetos:

   • Creamos una matriz de objetos Car, demostrando cómo trabajar con colecciones de objetos en nuestros programas.

Estos conceptos forman la base de la programación en Java y son esenciales para crear aplicaciones más grandes y complejas. A medida que continúes tu viaje en Java, encontrarás que utilizarás estos conceptos una y otra vez.

Recuerda, dominar la programación requiere práctica constante. Aquí hay algunas ideas para ampliar tu aprendizaje:

1. Intenta agregar más atributos a la clase Car, como color o mileage (kilometraje).
2. Crea métodos que modifiquen estos atributos, como paint(String newColor) (pintar con un nuevo color) o drive(int miles) (conducir una cantidad de millas).
3. Crea una clase Garage (garaje) que pueda almacenar múltiples objetos Car. Agrega métodos para agregar automóviles al garaje, quitar automóviles y mostrar todos los automóviles en el garaje.
4. Experimenta creando clases para otros tipos de objetos, como Book (libro) o Student (estudiante).

Sigue codificando, sigue explorando y, lo más importante, sigue divirtiéndote. Estás en el buen camino para convertirse en un programador Java competente.