Domina las Clases y Objetos en Java con 10 ejercicios prácticos resueltos paso a paso. ¡Ideal para principiantes en Programación Orientada a Objetos (POO)!
¿Estás comenzando tu viaje en la Programación Orientada a Objetos (POO) con Java? ¡Has llegado al lugar indicado! Las clases y los objetos son los pilares fundamentales de este paradigma, y entenderlos bien es el primer gran paso para convertirte en un desarrollador experto. En este artículo, no solo te explicaremos la teoría de forma sencilla, sino que te retaremos con 10 ejercicios diseñados para que aprendas haciendo. ¡Prepárate para llevar tu código al siguiente nivel!
Aprendizaje Teórico: ¿Qué Son las Clases y los Objetos?
Antes de sumergirnos en el código, aclaremos los conceptos básicos. Piensa en una clase como un plano o un molde para crear algo. Por ejemplo, el plano de una casa define sus características (número de habitaciones, color de las paredes, etc.) y sus funcionalidades (abrir puertas, encender luces). En Java, una clase define los atributos (variables) y métodos (funciones) que tendrán los objetos creados a partir de ella.
Un objeto, por otro lado, es la construcción real basada en ese plano. Siguiendo el ejemplo, cada casa construida a partir del mismo plano es un objeto único. Puede tener diferentes colores de pared o muebles distintos, pero todas comparten la misma estructura base definida en la clase. En resumen:
- Clase: Es la plantilla, el molde. Define la estructura y el comportamiento.
- Objeto: Es una instancia de una clase. Es la entidad real con la que interactuas en tu programa.
Con esta idea en mente, ¡ya estás listo para empezar a programar!
¡Inténtalo Tú Mismo Primero!
El verdadero aprendizaje ocurre cuando te enfrentas a un problema por tu cuenta. Antes de ver la solución de cada ejercicio, lee detenidamente el enunciado y piensa cómo lo resolverías. Abre tu editor de código, experimenta y no temas equivocarte. ¡Cada error es una oportunidad de aprender! Una vez que lo hayas intentado, compara tu solución con la nuestra para consolidar tus conocimientos.
10 Ejercicios Resueltos de Clases y Objetos
Ejercicio 1: Creando tu Primera Clase Coche
Problema: Crea una clase Coche que tenga los atributos marca, modelo y año. Incluye un método que imprima por pantalla toda la información del coche.
// Archivo: Coche.java
public class Coche {
// Atributos de la clase
String marca;
String modelo;
int anio;
// Constructor para inicializar los atributos
public Coche(String marca, String modelo, int anio) {
this.marca = marca;
this.modelo = modelo;
this.anio = anio;
}
// Método para mostrar la información del coche
public void mostrarInfo() {
System.out.println("Marca: " + marca);
System.out.println("Modelo: " + modelo);
System.out.println("Año: " + anio);
}
// Método main para probar la clase
public static void main(String[] args) {
// Creamos un objeto (instancia) de la clase Coche
Coche miCoche = new Coche("Toyota", "Corolla", 2021);
// Llamamos al método para mostrar su información
miCoche.mostrarInfo();
}
}
Ejercicio 2: Clase Rectangulo con Cálculo de Área
Problema: Diseña una clase Rectangulo con los atributos ancho y alto. Añade un método calcularArea() que devuelva el área del rectángulo.
// Archivo: Rectangulo.java
public class Rectangulo {
// Atributos
double ancho;
double alto;
// Constructor
public Rectangulo(double ancho, double alto) {
this.ancho = ancho;
this.alto = alto;
}
// Método para calcular el área
public double calcularArea() {
return ancho * alto;
}
public static void main(String[] args) {
// Creamos un objeto Rectangulo
Rectangulo miRectangulo = new Rectangulo(10.5, 5.2);
// Calculamos y mostramos el área
double area = miRectangulo.calcularArea();
System.out.println("El área del rectángulo es: " + area); // Salida: 54.6
}
}
Ejercicio 3: Clase Circulo con Radio y Perímetro
Problema: Crea una clase Circulo con un atributo radio. Debe tener métodos para calcular y devolver tanto el área (π * radio²) como el perímetro (2 * π * radio).
// Archivo: Circulo.java
public class Circulo {
// Atributo
double radio;
// Constructor
public Circulo(double radio) {
this.radio = radio;
}
// Método para calcular el área
public double calcularArea() {
// Math.PI es una constante de Java para el valor de Pi
return Math.PI * radio * radio;
}
// Método para calcular el perímetro
public double calcularPerimetro() {
return 2 * Math.PI * radio;
}
public static void main(String[] args) {
Circulo miCirculo = new Circulo(5.0);
System.out.println("Área del círculo: " + miCirculo.calcularArea());
System.out.println("Perímetro del círculo: " + miCirculo.calcularPerimetro());
}
}
Ejercicio 4: Clase Estudiante con Calificaciones
Problema: Define una clase Estudiante con los atributos nombre y calificacion (un número). Incluye un método que devuelva si el estudiante ha «Aprobado» (calificación >= 6) o «Reprobado».
// Archivo: Estudiante.java
public class Estudiante {
String nombre;
double calificacion;
public Estudiante(String nombre, double calificacion) {
this.nombre = nombre;
this.calificacion = calificacion;
}
// Método que determina si el estudiante aprobó
public String obtenerEstado() {
if (calificacion >= 6.0) {
return "Aprobado";
} else {
return "Reprobado";
}
}
public static void main(String[] args) {
Estudiante estudiante1 = new Estudiante("Ana", 8.5);
Estudiante estudiante2 = new Estudiante("Luis", 4.9);
System.out.println("El estado de " + estudiante1.nombre + " es: " + estudiante1.obtenerEstado());
System.out.println("El estado de " + estudiante2.nombre + " es: " + estudiante2.obtenerEstado());
}
}
Ejercicio 5: Clase Libro con Detalles
Problema: Crea una clase Libro con los atributos titulo, autor y numeroDePaginas. Añade un método que imprima un resumen del libro.
// Archivo: Libro.java
public class Libro {
String titulo;
String autor;
int numeroDePaginas;
public Libro(String titulo, String autor, int numeroDePaginas) {
this.titulo = titulo;
this.autor = autor;
this.numeroDePaginas = numeroDePaginas;
}
// Método para mostrar un resumen
public void mostrarResumen() {
System.out.println("'" + titulo + "', escrito por " + autor + ", tiene " + numeroDePaginas + " páginas.");
}
public static void main(String[] args) {
Libro miLibro = new Libro("Cien Años de Soledad", "Gabriel García Márquez", 496);
miLibro.mostrarResumen();
}
}
Ejercicio 6: Clase CuentaBancaria con Saldo
Problema: Diseña una clase CuentaBancaria con un atributo saldo. Incluye métodos para depositar() y retirar() dinero. El método retirar no debe permitir que el saldo quede negativo.
// Archivo: CuentaBancaria.java
public class CuentaBancaria {
private double saldo; // Usamos 'private' para proteger el acceso directo
public CuentaBancaria(double saldoInicial) {
this.saldo = saldoInicial;
}
// Método para depositar dinero
public void depositar(double cantidad) {
if (cantidad > 0) {
saldo += cantidad;
System.out.println("Depósito exitoso. Nuevo saldo: $" + saldo);
}
}
// Método para retirar dinero
public void retirar(double cantidad) {
if (cantidad > 0 && cantidad <= saldo) {
saldo -= cantidad;
System.out.println("Retiro exitoso. Nuevo saldo: $" + saldo);
} else {
System.out.println("Fondos insuficientes o cantidad no válida.");
}
}
// Método para consultar el saldo
public double getSaldo() {
return saldo;
}
public static void main(String[] args) {
CuentaBancaria miCuenta = new CuentaBancaria(1000.0);
System.out.println("Saldo inicial: $" + miCuenta.getSaldo());
miCuenta.depositar(500.0);
miCuenta.retirar(200.0);
miCuenta.retirar(1500.0); // Esto no debería ser posible
}
}
Ejercicio 7: Clase Producto con Precio e IVA
Problema: Crea una clase Producto con los atributos nombre y precio. Añade un método que calcule y devuelva el precio final incluyendo un IVA del 21%.
// Archivo: Producto.java
public class Producto {
String nombre;
double precio;
final double IVA = 0.21; // Usamos 'final' para definir una constante
public Producto(String nombre, double precio) {
this.nombre = nombre;
this.precio = precio;
}
// Método para calcular el precio final con IVA
public double calcularPrecioFinal() {
double impuesto = precio * IVA;
return precio + impuesto;
}
public static void main(String[] args) {
Producto miProducto = new Producto("Laptop", 1200.50);
System.out.println("El precio final de la " + miProducto.nombre + " es: $" + miProducto.calcularPrecioFinal());
}
}
Ejercicio 8: Clase Pelicula con Director y Género
Problema: Define una clase Pelicula con los atributos titulo, director y genero. Incluye un método que imprima la ficha técnica de la película.
// Archivo: Pelicula.java
public class Pelicula {
String titulo;
String director;
String genero;
public Pelicula(String titulo, String director, String genero) {
this.titulo = titulo;
this.director = director;
this.genero = genero;
}
// Método para mostrar la ficha técnica
public void mostrarFicha() {
System.out.println("----- Ficha Técnica -----");
System.out.println("Título: " + titulo);
System.out.println("Director: " + director);
System.out.println("Género: " + genero);
System.out.println("-------------------------");
}
public static void main(String[] args) {
Pelicula miPelicula = new Pelicula("Pulp Fiction", "Quentin Tarantino", "Crimen/Drama");
miPelicula.mostrarFicha();
}
}
Ejercicio 9: Clase Reloj con Horas y Minutos
Problema: Crea una clase Reloj con los atributos horas y minutos. Incluye un método que muestre la hora en formato «HH:MM».
// Archivo: Reloj.java
public class Reloj {
int horas;
int minutos;
public Reloj(int horas, int minutos) {
// Simple validación para mantener los valores en un rango lógico
this.horas = (horas >= 0 && horas < 24) ? horas : 0;
this.minutos = (minutos >= 0 && minutos < 60) ? minutos : 0;
}
// Método para mostrar la hora formateada
public void mostrarHora() {
// String.format para asegurar dos dígitos (ej. 09:05)
System.out.println(String.format("%02d:%02d", horas, minutos));
}
public static void main(String[] args) {
Reloj miReloj = new Reloj(9, 5);
miReloj.mostrarHora(); // Salida: 09:05
Reloj otroReloj = new Reloj(14, 30);
otroReloj.mostrarHora(); // Salida: 14:30
}
}
Ejercicio 10: Clase Mascota con Sonido
Problema: Diseña una clase Mascota con los atributos nombre y tipo (ej. «Perro», «Gato»). Añade un método hacerSonido() que imprima «Guau guau» si es un perro, «Miau miau» si es un gato, y un mensaje genérico para otros tipos.
// Archivo: Mascota.java
public class Mascota {
String nombre;
String tipo;
public Mascota(String nombre, String tipo) {
this.nombre = nombre;
this.tipo = tipo;
}
// Método que simula el sonido de la mascota
public void hacerSonido() {
// Usamos equalsIgnoreCase para comparar strings sin importar mayúsculas/minúsculas
if (tipo.equalsIgnoreCase("Perro")) {
System.out.println(nombre + " dice: Guau guau!");
} else if (tipo.equalsIgnoreCase("Gato")) {
System.out.println(nombre + " dice: Miau miau!");
} else {
System.out.println(nombre + " hace un sonido genérico.");
}
}
public static void main(String[] args) {
Mascota perro = new Mascota("Fido", "Perro");
Mascota gato = new Mascota("Misi", "Gato");
Mascota hamster = new Mascota("Pipo", "Hámster");
perro.hacerSonido();
gato.hacerSonido();
hamster.hacerSonido();
}
}
Preguntas Frecuentes (FAQs)
¿Qué es la palabra clave this?
La palabra clave this se utiliza dentro de un método o constructor de una instancia para referirse al objeto actual. Es muy útil para desambiguar entre los atributos de la clase y los parámetros de un método cuando tienen el mismo nombre, como en this.nombre = nombre;.
¿Para qué sirve el main dentro de las clases de los ejercicios?
El método public static void main(String[] args) es el punto de entrada de cualquier programa Java. Lo hemos incluido en cada clase para que puedas ejecutar cada ejercicio de forma independiente y probar su funcionalidad directamente sin necesidad de crear archivos adicionales.
¿Puedo tener varias clases en un mismo archivo .java?
Sí, pero solo una de ellas puede ser public y el archivo debe llamarse igual que esa clase pública. Generalmente, es una buena práctica mantener cada clase en su propio archivo para una mejor organización.
¡Has dado un gran paso!
¡Felicidades! Si has llegado hasta aquí y has intentado resolver los ejercicios, has fortalecido enormemente tu comprensión sobre clases y objetos, el corazón de Java. Recuerda que la programación es como un deporte: la práctica constante es la clave para mejorar. No te desanimes si algo no salió a la primera; lo importante es entender el porqué y seguir adelante.
Estos conceptos son la base para temas más avanzados como la herencia, el polimorfismo y la encapsulación. ¡Sigue así y pronto estarás construyendo aplicaciones complejas con confianza!
¿Te ha gustado este artículo? ¿Quieres seguir aprendiendo y dominar Java? ¡Visita nuestro blog para encontrar más tutoriales, ejercicios y consejos que te ayudarán en tu camino como desarrollador!
