Ejercicios Resueltos en Java Objetos (POO)
Ejercicios Resueltos en Java Objetos: Introducción a Objetos en Java
La programación orientada a objetos (POO) en Java permite desarrollar software organizado, reutilizable y fácil de mantener. Este artículo presenta diez ejercicios resueltos que introducen conceptos básicos de POO como clases, objetos, métodos, encapsulamiento y herencia. Cada ejercicio está diseñado para guiarte paso a paso en el aprendizaje de estos conceptos fundamentales.
Ejercicios de Programación enfocado en Objetos en Java
1. Creación de una Clase y su Objeto
Objetivo: Aprender a crear una clase y generar un objeto que permita acceder a sus atributos y métodos.
Solución:
// Clase básica Persona
public class Persona {
String nombre; // Atributo de la clase
// Método para imprimir el nombre de la persona
public void imprimirNombre() {
System.out.println("Nombre: " + nombre);
}
}
// Clase principal para probar
public class Main {
public static void main(String[] args) {
// Creación de un objeto de la clase Persona
Persona persona1 = new Persona();
persona1.nombre = "Ana"; // Asignación de valor al atributo nombre
persona1.imprimirNombre(); // Llamada al método
}
}Este ejercicio ilustra cómo crear una clase y un objeto en Java, permitiendo acceder y utilizar los atributos y métodos definidos en esa clase.
2. Métodos con Parámetros
Objetivo: Aprender a crear métodos que reciban valores específicos para realizar operaciones y devolver resultados.
Solución:
public class Calculadora {
// Método para sumar dos números
public int sumar(int a, int b) {
return a + b;
}
}
public class Main {
public static void main(String[] args) {
Calculadora calc = new Calculadora(); // Creación de objeto Calculadora
int resultado = calc.sumar(8, 12); // Llamada al método con valores específicos
System.out.println("Resultado de la suma: " + resultado);
}
}Aquí se explica cómo los métodos pueden aceptar valores externos, llamados parámetros, para realizar operaciones específicas dentro de la clase.
3. Uso de Constructores
Objetivo: Familiarizarse con el uso de constructores, que permiten crear objetos con valores inicializados de manera automática.
Solución:
public class Libro {
String titulo;
// Constructor para asignar un título al libro
public Libro(String titulo) {
this.titulo = titulo;
}
// Método para mostrar el título del libro
public void mostrarTitulo() {
System.out.println("Título del libro: " + titulo);
}
}
public class Main {
public static void main(String[] args) {
Libro libro1 = new Libro("Aprende Java Fácil"); // Creación de objeto con título
libro1.mostrarTitulo();
}
}En este ejercicio se muestra cómo los constructores son métodos especiales que se ejecutan automáticamente al crear un objeto, simplificando la inicialización de los atributos.
4. Encapsulamiento con Getters y Setters
Objetivo: Introducir el concepto de encapsulamiento para proteger los atributos de una clase, permitiendo su acceso controlado mediante métodos.
Solución:
public class Cuenta {
private double saldo; // Atributo privado
// Método getter para obtener el saldo
public double getSaldo() {
return saldo;
}
// Método setter para modificar el saldo
public void setSaldo(double saldo) {
if (saldo >= 0) { // Condición para evitar saldos negativos
this.saldo = saldo;
} else {
System.out.println("Saldo no puede ser negativo");
}
}
}
public class Main {
public static void main(String[] args) {
Cuenta cuenta = new Cuenta();
cuenta.setSaldo(1000); // Asignación de saldo
System.out.println("Saldo actual: " + cuenta.getSaldo());
}
}Este ejercicio ilustra el encapsulamiento: los atributos privados son modificados solo a través de métodos específicos, lo cual garantiza la seguridad de los datos.
5. Métodos Estáticos
Objetivo: Aprender a usar métodos estáticos, que pueden ser llamados directamente desde la clase sin necesidad de crear un objeto.
Solución:
public class Matemáticas {
// Método estático para calcular el cuadrado de un número
public static int cuadrado(int numero) {
return numero * numero;
}
}
public class Main {
public static void main(String[] args) {
int resultado = Matemáticas.cuadrado(6); // Llamada al método estático
System.out.println("Cuadrado de 6: " + resultado);
}
}Este ejemplo explica cómo los métodos estáticos se asocian a la clase en general y no a un objeto específico, ideal para operaciones generales.
6. Clases con Múltiples Atributos
Objetivo: Crear una clase que contenga varios atributos y métodos para trabajar con ellos.
Solución:
public class Persona {
String nombre;
int edad;
// Constructor para inicializar nombre y edad
public Persona(String nombre, int edad) {
this.nombre = nombre;
this.edad = edad;
}
public void mostrarInfo() {
System.out.println("Nombre: " + nombre + ", Edad: " + edad);
}
}
public class Main {
public static void main(String[] args) {
Persona persona = new Persona("Carlos", 28); // Creación de objeto con nombre y edad
persona.mostrarInfo();
}
}Este ejercicio ayuda a comprender cómo una clase puede tener varios atributos y cómo estos se inicializan y utilizan para crear objetos más complejos.
7. Métodos con Retorno de Valores
Objetivo: Crear métodos que devuelvan valores, útiles para obtener resultados de cálculos o procesamiento dentro de la clase.
Solución:
public class Circulo {
double radio;
// Constructor para inicializar el radio
public Circulo(double radio) {
this.radio = radio;
}
// Método para calcular el área del círculo
public double calcularArea() {
return Math.PI * radio * radio;
}
}
public class Main {
public static void main(String[] args) {
Circulo circulo = new Circulo(5.0);
System.out.println("Área del círculo: " + circulo.calcularArea());
}
}En este ejercicio, el método calcularArea devuelve el área del círculo, lo cual demuestra cómo obtener resultados de cálculos mediante métodos.
8. Herencia de Clases
Objetivo: Introducir la herencia, permitiendo que una clase derive de otra para reutilizar y extender funcionalidad.
Solución:
public class Animal {
public void hacerSonido() {
System.out.println("Sonido de animal");
}
}
public class Perro extends Animal {
@Override
public void hacerSonido() {
System.out.println("Guau Guau");
}
}
public class Main {
public static void main(String[] args) {
Perro perro = new Perro(); // Creación de objeto de la subclase
perro.hacerSonido();
}
}Este ejemplo demuestra cómo usar la herencia para crear una clase que hereda comportamientos de otra, a la vez que puede personalizar su propia funcionalidad.
9. Sobrecarga de Métodos
Objetivo: Aprender a sobrecargar métodos, creando varios métodos con el mismo nombre pero diferentes parámetros.
Solución:
public class Operacion {
// Suma de dos enteros
public int sumar(int a, int b) {
return a + b;
}
// Suma de dos números decimales
public double sumar(double a, double b) {
return a + b;
}
}
public class Main {
public static void main(String[] args) {
Operacion operacion = new Operacion();
System.out.println("Suma int: " + operacion.sumar(3, 7));
System.out.println("Suma double: " + operacion.sumar(2.5, 4.3));
}
}La sobrecarga permite usar el mismo método para distintos tipos de datos, facilitando la versatilidad en el código.
10. Clases Abstractas
Objetivo: Familiarizarse con el uso de clases abstractas para definir una estructura base que otras clases deben implementar.
Solución:
abstract class Figura {
abstract double calcularArea(); // Método abstracto
}
public class Rectangulo extends Figura {
double ancho, alto;
public Rectangulo(double ancho, double alto) {
this.ancho = ancho;
this.alto = alto;
}
@Override
double calcularArea() {
return ancho * alto;
}
}
public class Main {
public static void main(String[] args) {
Rectangulo rectangulo = new Rectangulo(5, 3); // Creación de objeto Rectángulo
System.out.println("Área del rectángulo: " + rectangulo.calcularArea());
}
}Las clases abstractas permiten crear una estructura general que otras clases deben cumplir, aportando orden y organización.
¡Buen trabajo completando estos ejercicios! La programación orientada a objetos te permite pensar en términos de organización y modularidad, y dominarla en Java te abrirá muchas puertas en el desarrollo de software. Sigue practicando y aprendiendo, ¡la constancia es clave! Para más teoría y recursos, explora W3Schools.
Preguntas Frecuentes
¿Por qué usamos el encapsulamiento en Java?
El encapsulamiento protege los datos dentro de una clase y permite que solo sean modificados de manera controlada mediante métodos específicos (getters y setters).
¿Qué es una clase abstracta y cuándo se utiliza?
Una clase abstracta es una clase base que contiene métodos abstractos que deben ser implementados en clases derivadas. Se usa cuando se necesita una estructura común que guíe a otras clases.
¿Qué diferencia hay entre una clase y un objeto?
Una clase es una plantilla que define atributos y comportamientos, mientras que un objeto es una instancia de esa clase, con valores propios.
Conclusión
La programación orientada a objetos en Java ayuda a crear aplicaciones modulares y organizadas. Con estos ejercicios, has explorado clases, objetos, encapsulamiento y otros conceptos clave que te permitirán desarrollar proyectos de manera eficiente y estructurada. ¡Sigue practicando y desarrollando tus habilidades en Java!
Encuentra mas ejercicios de Java en el siguiente boton
