diff --git a/BigDecimalProject.java b/BigDecimalProject.java
new file mode 100644
index 0000000..a77a6df
--- /dev/null
+++ b/BigDecimalProject.java
@@ -0,0 +1,26 @@
+package Exercise1;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+
+public class BigDecimalProject {
+
+ public static double roundToCent(BigDecimal number) {
+ BigDecimal rounded = number.setScale(2, RoundingMode.HALF_UP);
+ return rounded.doubleValue();
+ }
+ public static BigDecimal invertAndRoundToTenth(BigDecimal number) {
+ BigDecimal inverted = number.negate();
+ return inverted.setScale(1, RoundingMode.HALF_UP);
+ }
+
+ public static void main(String[] args) {
+ BigDecimal number = new BigDecimal("4.2545");
+ System.out.println(roundToCent(number));
+
+ BigDecimal number1 = new BigDecimal("1.2345");
+ BigDecimal number2 = new BigDecimal("-45.67");
+ System.out.println(invertAndRoundToTenth(number1));
+ System.out.println(invertAndRoundToTenth(number2));
+ }
+}
\ No newline at end of file
diff --git a/Car.java b/Car.java
new file mode 100644
index 0000000..c340694
--- /dev/null
+++ b/Car.java
@@ -0,0 +1,19 @@
+package Exercise2;
+
+public abstract class Car {
+ protected String vinNumber;
+ protected String make;
+ protected String model;
+ protected int mileage;
+
+ public Car(String vinNumber, String make, String model, int mileage) {
+ this.vinNumber = vinNumber;
+ this.make = make;
+ this.model = model;
+ this.mileage = mileage;
+ }
+
+ public String getInfo() {
+ return "VINnumber: " + vinNumber + ", Make: " + make + ", Model: " + model + ", Mileage: " + mileage + " miles";
+ }
+}
diff --git a/IntArrayList.java b/IntArrayList.java
new file mode 100644
index 0000000..774351e
--- /dev/null
+++ b/IntArrayList.java
@@ -0,0 +1,29 @@
+package Exercise4;
+import java.util.Arrays;
+
+public class IntArrayList implements IntList {
+ private int[] array;
+ private int size;
+
+ public IntArrayList() {
+ array = new int[10];
+ size = 0;
+ }
+ @Override
+ public void add(int number) {
+ if (size == array.length) {
+ int newSize = array.length + (array.length / 2);
+ int[] newArray = new int[newSize];
+ System.arraycopy(array, 0, newArray, 0, array.length);
+ array = newArray;
+ }
+ array[size++] = number;
+ }
+ @Override
+ public int get(int id) {
+ if (id < 0 || id >= size) {
+ throw new IndexOutOfBoundsException("Index: " + id + ", Size: " + size);
+ }
+ return array[id];
+ }
+}
diff --git a/IntList.java b/IntList.java
new file mode 100644
index 0000000..7310d18
--- /dev/null
+++ b/IntList.java
@@ -0,0 +1,6 @@
+package Exercise4;
+
+public interface IntList {
+ void add(int number);
+ int get(int id);
+}
diff --git a/IntVector.java b/IntVector.java
new file mode 100644
index 0000000..9ee1018
--- /dev/null
+++ b/IntVector.java
@@ -0,0 +1,29 @@
+package Exercise4;
+import java.util.Arrays;
+
+public class IntVector implements IntList {
+ private int[] array;
+ private int size;
+
+ public IntVector() {
+ array = new int[20];
+ size = 0;
+ }
+ @Override
+ public void add(int number) {
+ if (size == array.length) {
+ int newSize = array.length * 2;
+ int[] newArray = new int[newSize];
+ System.arraycopy(array, 0, newArray, 0, array.length);
+ array = newArray;
+ }
+ array[size++] = number;
+ }
+ @Override
+ public int get(int id) {
+ if (id < 0 || id >= size) {
+ throw new IndexOutOfBoundsException("Index: " + id + ", Size: " + size);
+ }
+ return array[id];
+ }
+}
diff --git a/Main.java b/Main.java
new file mode 100644
index 0000000..52070b1
--- /dev/null
+++ b/Main.java
@@ -0,0 +1,27 @@
+package Exercise4;
+
+public class Main {
+ public static void main(String[] args) {
+ IntList intArrayList = new IntArrayList();
+ for (int i = 0; i < 15; i++) {
+ intArrayList.add(i);
+ System.out.println("IntArrayList add: " + i);
+ }
+
+ System.out.println("Elementos en IntArrayList:");
+ for (int i = 0; i < 15; i++) {
+ System.out.println("Elemento en posición " + i + ": " + intArrayList.get(i));
+ }
+
+ IntList intVector = new IntVector();
+ for (int i = 0; i < 25; i++) {
+ intVector.add(i);
+ System.out.println("IntVector add: " + i);
+ }
+
+ System.out.println("Elementos en IntVector:");
+ for (int i = 0; i < 25; i++) {
+ System.out.println("Elemento en posición " + i + ": " + intVector.get(i));
+ }
+ }
+}
\ No newline at end of file
diff --git a/Movie.java b/Movie.java
new file mode 100644
index 0000000..46c48da
--- /dev/null
+++ b/Movie.java
@@ -0,0 +1,15 @@
+package Exercise3;
+
+public class Movie extends Video {
+ private double rating;
+
+ public Movie(String title, int duration, double rating) {
+ super(title, duration);
+ this.rating = rating;
+ }
+
+ @Override
+ public String getInfo() {
+ return super.getInfo() + ", Rating: " + rating;
+ }
+}
diff --git a/README.md b/README.md
index 82afa88..c039725 100644
--- a/README.md
+++ b/README.md
@@ -1,339 +1,16 @@
-
-
-
-# LAB | Java Interfaces y clases abstractas
-
-## Introducción
-
-Acabamos de aprender cómo crear e implementar interfaces, así como cómo crear y extender clases abstractas, así que ahora practiquemos un poco.
-
-
-
-## Requisitos
-
-1. Haz un fork de este repositorio.
-2. Clona este repositorio.
-3. Añade a tu instructor y a los calificadores de la clase como colaboradores de tu repositorio. Si no estás seguro de quiénes son los calificadores de tu clase, pregunta a tu instructor o consulta la presentación del primer día.
-4. En el repositorio, crea un proyecto de Java y añade el código para las siguientes tareas.
-
-## Entrega
-
-Una vez que termines la tarea, envía un enlace URL a tu repositorio o tu solicitud de extracción en el campo de abajo.
-
-
-
-## Instrucciones
-
-### Operaciones BigDecimal
-
-1. Usando [la documentación de BigDecimal](https://docs.oracle.com/javase/7/docs/api/java/math/BigDecimal.html), crea un método que acepte un `BigDecimal` y devuelva un `double` del número `BigDecimal` redondeado al centésimo más cercano. Por ejemplo, `4.2545` debería devolver `4.25`.
-2. Usando [la documentación de BigDecimal](https://docs.oracle.com/javase/7/docs/api/java/math/BigDecimal.html), crea un método que acepte un `BigDecimal`, invierte el signo (si el parámetro es positivo, el resultado debería ser negativo y viceversa), redondea el número a la décima más cercana y devuelva el resultado. Por ejemplo, `1.2345` debería devolver `-1.2` y `-45.67` debería devolver `45.7`.
-
-
-
-### Sistema de inventario de automóviles
-
-1. Supongamos que estás construyendo un sistema de inventario de automóviles. Todos los automóviles tienen un `vinNumber`, `make`, `model` y `mileage`. Pero ningún automóvil es solo un automóvil cualquiera. Cada automóvil puede ser un `Sedan`, un `UtilityVehicle` o un `Truck`.
-2. Crea una clase abstracta llamada `Car` y define las siguientes propiedades y comportamientos:
- - `vinNumber`: una `String` que representa el número de VIN del automóvil
- - `make`: una `String` que representa la marca del automóvil
- - `model`: una `String` que representa el modelo del automóvil
- - `mileage`: un `int` que representa el kilometraje del automóvil
- - `getInfo()`: un método que devuelve una `String` que contiene todas las propiedades del automóvil en un formato legible
-3. Crea tres clases que extiendan `Car`: `Sedan`, `UtilityVehicle` y `Truck`.
-4. Los objetos de `UtilityVehicle` deben tener una propiedad adicional `fourWheelDrive`, un `boolean` que representa si el vehículo tiene tracción en las cuatro ruedas.
-5. Los objetos de `Truck` deben tener una propiedad adicional `towingCapacity`, un `double` que representa la capacidad de remolque del camión.
-
-
-
-### Servicio de transmisión de vídeo
-
-1. Supón que está construyendo un servicio de transmisión de vídeo. Todos los videos son series de televisión o películas.
-2. Crea una clase abstracta llamada `Video` y define las siguientes propiedades y comportamientos:
- - `title`: un `String` que representa el título del video
- - `duration`: un `int` que representa la duración del video en minutos
- - `getInfo()`: un método que devuelve un `String` que contiene todas las propiedades del video en un formato legible
-3. Crea dos clases que extiendan `Video`: `TvSeries` y `Movie`.
-4. Los objetos `TvSeries` deben tener una propiedad adicional `episodes`, un `int` que representa el número de episodios en la serie.
-5. Los objetos `Movie` deben tener una propiedad adicional `rating`, un `double` que representa la calificación de la película.
-
-
-
-### Interfaz IntList
-
-1. Crea una interfaz `IntList` con los siguientes métodos:
- - `add (int number)`: un método que agrega un nuevo número a la lista
- - `get (int id)`: un método que recupera un elemento por su ID
-2. Crea dos implementaciones de `IntList`: `IntArrayList` y `IntVector`.
-3. `IntArrayList` debe almacenar números en un array con una longitud de 10 por defecto. Cuando se llama al método `add`, primero debes determinar si el array está lleno. Si lo está, crea un nuevo array que sea el 50% más grande, mueve todos los elementos al nuevo array y agregue el nuevo elemento. (Por ejemplo, un array de longitud 10 aumentaría a 15).
-4. `IntVector` debe almacenar números en un arreglo con una longitud de 20 por defecto. Cuando se llama al método `add`, primero debes determinar si el array está lleno. Si lo está, crea un nuevo array que sea el doble del tamaño del array actual, mueve todos los elementos al nuevo array y agrega el nuevo elemento. (Por ejemplo, un array de longitud 10 aumentaría a 20).
-5. En su `README.md`, incluye un ejemplo de cuándo `IntArrayList` sería más eficiente y cuándo `IntVector` sería más eficiente.
-
-
-
-## FAQs (Preguntas frecuentes)
-
-
-
-
- Estoy atascado y no sé cómo resolver el problema o por dónde empezar. ¿Qué debo hacer?
-
-
-
- Si estás atascado con tu código y no sabes cómo resolver el problema o por dónde empezar, debes dar un paso atrás y tratar de formular una pregunta clara y directa sobre el problema específico que enfrentas. El proceso que seguirás al tratar de definir esta pregunta te ayudará a limitar el problema y a encontrar soluciones potenciales.
-
- Por ejemplo, ¿no entiendes el concepto o estás recibiendo un mensaje de error que no sabes cómo arreglar? Por lo general, es útil intentar formular el problema de la manera más clara posible, incluyendo cualquier mensaje de error que estés recibiendo. Esto puede ayudarte a comunicar el problema a otras personas y, potencialmente, a obtener ayuda de tus compañeros o recursos en línea.
-
- Una vez que tengas una comprensión clara del problema, deberías poder comenzar a trabajar hacia la solución.
-
-
-
-
-
-
- ¿Cómo creo un proyecto Maven en IntelliJ?
-
-
-
- Para crear un proyecto Maven en IntelliJ, puedes seguir estos pasos:
-
- 1. Abre IntelliJ IDEA y haz clic en el botón "Create New Project".
- 2. En el diálogo "New Project", selecciona "Maven" como el sistema de compilación.
- 3. Especifica el nombre del proyecto.
- 4. En la sección "Project Location", especifica una ubicación donde quieres guardar tu proyecto.
- 5. Selecciona la casilla de verificación "Create Git repository" para inicializar el repositorio git al crear el proyecto.
- 6. Haz clic en el botón "Create" para crear el proyecto Maven.
-
-
-
-
-
-
- ¿Cómo uso "BigDecimal" en Java para manejar números decimales precisos?
-
-
-
- `BigDecimal` es una clase en Java que proporciona soporte para números decimales precisos, lo que permite realizar operaciones aritméticas con precisión arbitraria.
-
- Aquí hay un ejemplo de cómo usar `BigDecimal` en un programa Java:
-
- ```java
- import java.math.BigDecimal;
-
- public class BigDecimalExample {
- public static void main(String[] args) {
- BigDecimal a = new BigDecimal("0.1");
- BigDecimal b = new BigDecimal("0.2");
- BigDecimal c = a.add(b);
- System.out.println("a + b = " + c);
- }
- }
- ```
-
- En este ejemplo, se crean objetos `BigDecimal` usando la palabra clave `new` y una representación String del número decimal. Luego se utiliza el método `add` para realizar operaciones aritméticas en los objetos `BigDecimal`, proporcionando resultados precisos.
-
- Es importante tener en cuenta que al crear un objeto `BigDecimal`, se recomienda usar el constructor String en lugar del constructor `double`. El constructor `double` no se recomienda para crear objetos `BigDecimal` porque el tipo de datos `double` tiene una precisión limitada y puede producir resultados inesperados.
-
- Además del método `add`, `BigDecimal` también proporciona otras operaciones aritméticas, como `subtract`, `multiply` y `divide`, así como métodos para redondear y dar formato al número decimal.
-
-
-
-
-
-
- ¿Cómo usar "setScale()", "RoundingMode" y "negate()" en Java con "BigDecimal"?
-
-
-
- `setScale()`, `RoundingMode` y `negate()` son métodos en la clase `BigDecimal` en Java que brindan funcionalidad adicional al trabajar con números decimales precisos.
-
- `setScale()` se utiliza para establecer la escala de un objeto `BigDecimal`, lo que determina la cantidad de lugares decimales a mantener. Por ejemplo:
-
- ```java
- import java.math.BigDecimal;
-
- public class BigDecimalExample {
- public static void main(String[] args) {
- BigDecimal a = new BigDecimal("1.234567");
- BigDecimal b = a.setScale(4, BigDecimal.ROUND_HALF_UP);
- System.out.println("a: " + a);
- System.out.println("b: " + b);
- }
- }
- ```
-
- En este ejemplo, se usa `setScale()` para establecer la escala de `a` en 4 lugares decimales y el resultado se almacena en un nuevo objeto `BigDecimal`, `b`. El argumento `ROUND_HALF_UP` especifica el modo de redondeo a usar al establecer la escala.
-
- `RoundingMode` es una enumeración en Java que define los diferentes modos de redondeo que se pueden usar con `BigDecimal`. Por ejemplo:
-
- ```java
- import java.math.BigDecimal;
- import java.math.RoundingMode;
-
- public class BigDecimalExample {
- public static void main(String[] args) {
- BigDecimal a = new BigDecimal("1.234567");
- BigDecimal b = a.setScale(4, RoundingMode.HALF_UP);
- System.out.println("a: " + a);
- System.out.println("b: " + b);
- }
- }
- ```
-
- En este ejemplo, `RoundingMode.HALF_UP` se usa como el argumento de modo de redondeo en el método `setScale()`.
-
- `negate()` se utiliza para negar el valor de un objeto BigDecimal, convirtiendo un valor positivo en negativo y viceversa. Por ejemplo:
-
- ```java
- import java.math.BigDecimal;
-
- public class BigDecimalExample {
- public static void main(String[] args) {
- BigDecimal a = new BigDecimal("1.234567");
- BigDecimal b = a.negate();
- System.out.println("a: " + a);
- System.out.println("b: " + b);
- }
- }
- ```
-
- En este ejemplo, se utiliza `negate()` para negar el valor de `a` y almacenar el resultado en un nuevo objeto `BigDecimal`, `b`.
-
-
-
-
-
-
- ¿Qué es una clase abstracta en Java y cómo se utiliza?
-
-
-
- Una clase abstracta en Java es una clase que no se puede instanciar y se destina a ser heredada por otras clases. Las clases abstractas pueden contener métodos abstractos, que son métodos que se declaran pero no tienen un cuerpo.
-
- Una clase abstracta se utiliza como una clase base para proporcionar una interfaz y una implementación común a sus subclases. Las subclases de una clase abstracta deben implementar los métodos abstractos definidos en la clase abstracta.
-
- Aquí hay un ejemplo de una clase abstracta en Java:
-
- ```java
- abstract class Shape {
- int x, y;
- // abstract method that subclasses must implement
- abstract void draw();
- }
-
- class Circle extends Shape {
- @Override
- void draw() {
- System.out.println("Drawing a circle");
- }
- }
-
- class Square extends Shape {
- @Override
- void draw() {
- System.out.println("Drawing a square");
- }
- }
- ```
-
- En este ejemplo, la clase `Shape` es una clase abstracta que contiene un método abstracto `draw()`. Las clases `Circle` y `Square` son subclases de Shape e implementan el método `draw()`.
-
- Cuando una subclase implementa los métodos abstractos de su clase abstracta, hereda las propiedades y métodos de la clase abstracta, lo que facilita la implementación de funcionalidades comunes en múltiples clases.
-
-
-
-
-
-
- ¿Cómo implemento una interfaz en Java?
-
-
-
- En Java, una interfaz es un plano que describe los métodos que una clase debe implementar. Para implementar una interfaz, es necesario crear una clase que implemente la interfaz y proporcione una implementación para cada uno de sus métodos.
-
- Aquí hay un ejemplo de cómo implementar una interfaz en Java:
-
- ```java
- interface Shape {
- void draw();
- }
-
- class Circle implements Shape {
- @Override
- public void draw() {
- System.out.println("Drawing a circle");
- }
- }
-
- class Square implements Shape {
- @Override
- public void draw() {
- System.out.println("Drawing a square");
- }
- }
- ```
-
- En este ejemplo, la interfaz `Shape` define un solo método `draw()`. Las clases `Circle` y `Square` implementan la interfaz Shape proporcionando una implementación para el método `draw()`.
-
- Cuando una clase implementa una interfaz, debe implementar todos los métodos definidos en la interfaz. Si una clase no implementa todos los métodos, no se compilará. Las interfaces se pueden utilizar para imponer un conjunto común de métodos en un grupo de clases, lo que facilita la escritura de código que es intercambiable entre diferentes clases que implementan la misma interfaz.
-
-
-
-
-
-
- ¿Cuál es el propósito de "System.arraycopy()" en Java y cómo lo usamos?
-
-
-
- El método `System.arraycopy()` en Java se utiliza para copiar elementos de una array a otro. Es parte de la clase `System` y proporciona una alternativa más rápida al método tradicional de bucle for para copiar arrays. El método tiene la siguiente firma:
-
- ```java
- public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
- ```
-
- Aquí hay un ejemplo de cómo puede usar `System.arraycopy()`:
-
- ```java
- int[] sourceArray = new int[] {1, 2, 3, 4, 5};
- int[] destinationArray = new int[5];
- System.arraycopy(sourceArray, 0, destinationArray, 0, sourceArray.length);
-
- System.out.println(Arrays.toString(destinationArray));
- ```
-
- En este ejemplo, se utiliza `System.arraycopy()` para copiar los elementos de `sourceArray` a `destinationArray`. El primer argumento `src` es el array fuente, el segundo argumento `srcPos` es la posición de inicio en el array fuente, el tercer argumento `dest` es el array destino, el cuarto argumento `destPos` es la posición de inicio en el array destino y el quinto argumento `length` es la cantidad de elementos que se deben copiar. El resultado de este ejemplo sería `[1, 2, 3, 4, 5]`.
-
-
-
-
-
-
- No puedo enviar cambios a mi repositorio. ¿Qué debo hacer?
-
-
-
- Si no puedes enviar cambios a tu repositorio, aquí hay algunos pasos que puedes seguir:
-
- 1. Verifica tu conexión a internet: Asegúrate de que tu conexión a internet sea estable y funcione.
- 2. Verifica la URL de tu repositorio: Asegúrate de estar usando la URL correcta de tu repositorio para enviar tus cambios.
- 3. Revisa tus credenciales de Git: Asegúrate de que tus credenciales de Git estén actualizadas y correctas. Puedes revisar tus credenciales usando el siguiente comando:
-
- ```bash
- git config --list
- ```
-
- 4. Actualiza tu repositorio local: Antes de enviar cambios, asegúrate de que tu repositorio local esté actualizado con el repositorio remoto. Puedes actualizar tu repositorio local usando el siguiente comando:
-
- ```bash
- git fetch origin
- ```
-
- 5. Revisa posibles conflictos: Si hay conflictos entre tu repositorio local y el repositorio remoto, resuélvelos antes de enviar cambios.
- 6. Envía cambios: Una vez que hayas resuelto los conflictos y actualizado tu repositorio local, puedes intentar enviar cambios nuevamente usando el siguiente comando:
-
- ```bash
- git push origin
- ```
-
-
+# Comparación de IntArrayList e IntVector
+
+## IntArrayList
+IntArrayList es más eficiente en términos de uso de memoria cuando se anticipa que la lista crecerá gradualmente y no se alcanzará una longitud muy grande rápidamente. Esto se debe a que crece en un 50% cada vez que se expande, lo que genera menos espacio desperdiciado pero más operaciones de copia.
+
+## IntVector
+IntVector es más eficiente cuando se anticipa que la lista crecerá rápidamente o alcanzará tamaños grandes. Dado que el arreglo se duplica cada vez que se expande, se minimiza la cantidad de veces que se necesita reubicar los elementos, aunque puede desperdiciarse más memoria en el crecimiento inicial porque el tamaño del array se expande más agresivamente.
+
+## Ejemplo
+Si estás trabajando con una lista que probablemente no superará los 30 o 40 elementos, `IntArrayList` podría ser más eficiente. Sin embargo, si sabes que tu lista podría crecer a varios cientos o miles de elementos, `IntVector` puede ser más adecuado para minimizar las operaciones de copia.
+Si tienes dudas en la implementación o en algún concepto, ¡pregúntame y estaré encantado de ayudarte!
+
+Aquí tienes la guía para aprender a usarme: Explora la guía.
+
+
+
diff --git a/Sedan.java b/Sedan.java
new file mode 100644
index 0000000..7098bff
--- /dev/null
+++ b/Sedan.java
@@ -0,0 +1,7 @@
+package Exercise2;
+
+public class Sedan extends Car {
+ public Sedan(String vinNumber, String make, String model, int mileage) {
+ super(vinNumber, make, model, mileage);
+ }
+}
\ No newline at end of file
diff --git a/Truck.java b/Truck.java
new file mode 100644
index 0000000..97d38d4
--- /dev/null
+++ b/Truck.java
@@ -0,0 +1,14 @@
+package Exercise2;
+
+public class Truck extends Car {
+
+ private double towingCapacity;
+ public Truck(String vinNumber, String make, String model, int mileage, double towingCapacity) {
+ super(vinNumber, make, model, mileage);
+ this.towingCapacity = towingCapacity;
+ }
+ @Override
+ public String getInfo() {
+ return super.getInfo() + ", Towing Capacity: " + towingCapacity + " pounds";
+ }
+}
\ No newline at end of file
diff --git a/TvSeries.java b/TvSeries.java
new file mode 100644
index 0000000..264c3f4
--- /dev/null
+++ b/TvSeries.java
@@ -0,0 +1,15 @@
+package Exercise3;
+
+public class TvSeries extends Video {
+ private int episodes;
+
+ public TvSeries(String title, int duration, int episodes) {
+ super(title, duration);
+ this.episodes = episodes;
+ }
+
+ @Override
+ public String getInfo() {
+ return super.getInfo() + ", Episodes: " + episodes;
+ }
+}
diff --git a/UtilityVehicle.java b/UtilityVehicle.java
new file mode 100644
index 0000000..4ffa848
--- /dev/null
+++ b/UtilityVehicle.java
@@ -0,0 +1,14 @@
+package Exercise2;
+
+public class UtilityVehicle extends Car {
+
+ private boolean fourWheelDrive;
+ public UtilityVehicle(String vinNumber, String make, String model, int mileage, boolean fourWheelDrive) {
+ super(vinNumber, make, model, mileage);
+ this.fourWheelDrive = fourWheelDrive;
+ }
+ @Override
+ public String getInfo() {
+ return super.getInfo() + ", Four Wheel Drive: " + (fourWheelDrive ? "Yes" : "No");
+ }
+}
\ No newline at end of file
diff --git a/Video.java b/Video.java
new file mode 100644
index 0000000..66cc85b
--- /dev/null
+++ b/Video.java
@@ -0,0 +1,15 @@
+package Exercise3;
+
+public abstract class Video {
+ protected String title;
+ protected int duration;
+
+ public Video(String title, int duration) {
+ this.title = title;
+ this.duration = duration;
+ }
+
+ public String getInfo() {
+ return "Title: " + title + ", Duration: " + duration + " minutes";
+ }
+}
\ No newline at end of file