Ejercicios con Clases en Java

Última actualización: octubre 2024

Tabla de contenidos

Aquí te dejo varios ejercicios con Clases en Java, para que puedas practicar lo aprendido en post anteriores. No explico la solución, sencillamente muestro una posible solución, pero mi recomendación es que intentes hacer los ejercicios sin mirar mi solución, y que la consultes sólo si te atascas.

Ejercicio 1: La clase Pais

Crea una clase llamada Pais.

La clase debe tener los siguientes parámetros (recuerda que los parámetros deben ser declarados como privados por cuestiones de seguridad):

nombre (tipo String): Es el nombre del pais.
población (tipo long): Número de habitantes del pais.
PIB (tipo double): Representa el producto interior bruto en millones de €

La clase tiene un único constructor con todos los parámetros.

La clase tiene todos los métodos getters y setters.

Además, tendrá un método que devuelva el PIB per cápita, calculado dividiendo el PIN en € por la población. (Ten en cuenta que tienes que usar el PIB en €)

Un posible código solución sería:

public class Pais {
    private String nombre;
    private long población;
    private double PIB;

    //Constructores
    public Pais(String nombre, long población, double PIB) {
        this.nombre = nombre;
        this.población = población;
        this.PIB = PIB;
    }
    //getters y setters
    public String getNombre() {
        return nombre;
    }
    public void setNombre(String nombre) {
        this.nombre = nombre;
    }
    public long getPoblación() {
        return población;
    }
    public void setPoblación(long población) {
        this.población = población;
    }
    public double getPIB() {
        return PIB;
    }
    public void setPIB(double PIB) {
        this.PIB = PIB;
    }
    // métodos
    public double PIBPerCapita(){
    return (this.PIB*1000000)/this.población;
    }
}

Ejercicio 2: La clase proyecto

Crea un clase llamada proyecto con los siguientes parámetros, que puedes llamarles como quieras:

Primer parámetro: Descripción del Proyecto.
Segundo parámetro: Duración del Proyecto en días.
Tercer parámetro: El dinero que ganas trabajando un día en ese Proyecto. Vamos tu tarifa diaria.

La clase Proyecto tendrá un constructor con los tres parámetros, que tienen que ser declarados como privados. Con lo que tendrás que implementar los métodos getters y setters.

La clase cuenta también con un método que calcula el dinero que ganaras trabajando en el Proyecto. Para este cálculo, sencillamente multiplicas el Segundo parámetro por el tercero.

Una posible solución sería:

public class Proyecto {
    private String descripcion;
    private int duracion;
    private int tarifaDiaria;

    public Proyecto(String descripcion, int duracion, int tarifaDiaria) {
        this.descripcion = descripcion;
        this.duracion = duracion;
        this.tarifaDiaria = tarifaDiaria;
    }
    public String getDescripcion() {
        return descripcion;
    }
    public void setDescripcion(String descripcion) {
        this.descripcion = descripcion;
    }
    public int getDuracion() {
        return duracion;
    }
    public void setDuracion(int duracion) {
        this.duracion = duracion;
    }
    public int getTarifaDiaria() {
        return tarifaDiaria;
    }
    public void setTarifaDiaria(int tarifaDiaria) {
        this.tarifaDiaria = tarifaDiaria;
    }
    public int dineroGanado(){
        return this.getDuracion()*this.getTarifaDiaria();
    }
}

Ejercicio 3: Trabajando con la clase Casa

Usando la clase Casa definida como:

public class Casa {
    private double metrosCuadrados;
    private boolean jardin;
    
//constructores
    public Casa(double metrosCuadrados, boolean jardin) {
        this.metrosCuadrados = metrosCuadrados;
        this.jardin = jardin;
    }
//métodos
    public double precio (double m2, boolean jardin){
        double pr=m2*1000;
        if (jardin){
            pr=pr+5000;
        }
        return pr;
    }
//métodos getters y setters
    public double getMetrosCuadrados() {
        return metrosCuadrados;
    }
    public void setMetrosCuadrados(double metrosCuadrados) {
        this.metrosCuadrados = metrosCuadrados;
    }
    public boolean isJardin() {
        return jardin;
    }
    public void setJardin(boolean jardin) {
        this.jardin = jardin;
    }
}

Codifica un programa java que pregunte al usuario cuantos metros cuadrados tiene su casa y si tiene jardín. Con esos datos, el programa debe calcular el precio de la casa y dibujar el valor en la pantalla. Para calcular el precio debes emplear el método precio de la clase Casa.

Un posible ejemplo de ejecución sería:

run:
Por favor, introduce los metros cuadrados de tu casa: 
1000
La casa, tiene jardin? (true/false)
true
El precio de la casa es: 1005000.0
BUILD SUCCESSFUL (total time: 11 seconds)

Y una posible solución para nuestro método main, sería:

import java.util.Scanner;

public class EjercicioClases {

    public static void main(String[] args) {
        Scanner sc1 = new Scanner (System.in);
        Scanner sc2 = new Scanner (System.in);
        System.out.println("Por favor, introduce los metros cuadrados de tu casa: ");
        double m2=sc1.nextDouble();
        System.out.println("La casa, tiene jardin? (true/false)");
        boolean tieneJardin = sc2.hasNextBoolean();
        
        Casa casa1 = new Casa (m2, tieneJardin);
        System.out.println("El precio de la casa es: "+casa1.precio(m2, tieneJardin));

        sc1.close();sc2.close();
    }
}

Ejercicio 4: Clases Persona y Estudiante

Crea una clase que se llame Persona con las siguientes características:

Parámetros: nombre (tipo String) y añoNacimiento (tipo int). Declarados como privados.
Un constructor que acepte todos los parámetros.
Un método llamado edad que devuelve la edad de la persona. A este método hay que pasarle un parámetro (tipo int): el año actual, y calcula la edad de la persona restando al año actual el año de Nacimiento.

Crea además una clase denominada Estudiante que herede de la clase Persona, que sería la superclase. La clase Estudiante debe además tener las siguientes características:

Un parámetro adicional llamado carrera de tipo String.
Un constructor que acepte todos los parámetros, incluidos los heredados de la superclase.
Un método llamado dibujarDatos que dibuje por pantalla todos los datos del objeto Estudiante en cuestión.

Entonces en el método main, programa las siguientes acciones:

Pide al usuario, suponiendo que se trata de un estudiante, que introduzca sus datos: los tres parámetros de la clase Estudiante.
Crea un objeto Estudiante con dichos datos.
Utiliza el método dibujarDatos para pintar por pantalla los datos del estudiante.
Utiliza el método edad heredado de la superclase para pintar por pantalla la edad del estudiante.

Un posible output sería:

run:
Por favor, introduce tu nombre
Marta
En que año naciste?
1998
Que carrera estás cursando?
Marketing
El nombre del estudiante es: Marta
Nacio en el año: 1998
Y está estudiando la carrera: Marketing
El estudiante Marta tiene 22 años
BUILD SUCCESSFUL (total time: 12 seconds)

Y un posible código solución:

Clase Persona:

public class Persona {
    private String nombre;
    private int añoNacimiento;
//constructor
    public Persona(String nombre, int añoNacimiento) {
        this.nombre = nombre;
        this.añoNacimiento = añoNacimiento;
    }
//getters and setters
    public String getNombre() {
        return nombre;
    }
    public void setNombre(String nombre) {
        this.nombre = nombre;
    }
    public int getAñoNacimiento() {
        return añoNacimiento;
    }
    public void setAñoNacimiento(int añoNacimiento) {
        this.añoNacimiento = añoNacimiento;
    }
//métodos
    public int edad(int añoActual){
        return añoActual-this.añoNacimiento;
    }
}

Clase Estudiante:

public class Estudiante extends Persona {
    private String carrera;

    public Estudiante(String carrera, String nombre, int añoNacimiento) {
        super(nombre, añoNacimiento);
        this.carrera = carrera;
    }
    public void dibujarDatos(){
        System.out.println("El nombre del estudiante es: "+this.getNombre());
        System.out.println("Nacio en el año: "+this.getAñoNacimiento());
        System.out.println("Y está estudiando la carrera: "+this.carrera);
    }
}

Clase principal (con el método main):

import java.util.Scanner;

public class EjercicioClases {

    public static void main(String[] args) {
        Scanner sc1 = new Scanner (System.in);
        System.out.println("Por favor, introduce tu nombre");
        String nombre = sc1.nextLine();
        Scanner sc2 = new Scanner (System.in);
        System.out.println("En que año naciste?");
        int añoNac = sc2.nextInt();
        Scanner sc3 = new Scanner (System.in);
        System.out.println("Que carrera estás cursando?");
        String carrera = sc3.nextLine();
        
        Estudiante est = new Estudiante (carrera,nombre,añoNac);
        est.dibujarDatos();
        System.out.println("El estudiante "+est.getNombre()+" tiene "+est.edad(2020)+" años");
        sc1.close();sc2.close();sc3.close();
    }
}

Ejercicio 5: Traslado Población a Planeta habitable

Crea una clase llamada Planeta con un único parámetro de tipo double llamado añosLuz. Este parámetro representa los años luz de distancia a los que se encuentra el planeta de la Tierra.

Crea un método que devuelva los días de viaje necesario para alcanzar el planeta, suponiendo que en un día recorremos 10 años luz

Crea una clase llamada PlanetaHabitable que herede de la clase Planeta. La clase PlanetaHabitable tiene un único parámetro de tipo double llamado CapacidadPobladoresEnMillones, que representa la máxima capacidad en millones de habitantes que puede asumir ese planeta

Crea un método que devuelva el número de naves espaciales necesarias para trasladar todas las personas necesarias para poblar el planeta a su máxima capacidad. La capacidad de pasajeros de la nave es un parámetro que se pasa al método.

El programa tiene que pedir al usuario que introduzca por teclado los siguientes datos:

1.- distancia en años luz a la que se encuentra un planeta habitable

2.- Máxima población que admite el planeta en millones de habitantes

3.- Capacidad de ocupantes de las naves espaciales en millones de habitantes

Con la información introducida por el usuario, utilizando los métodos de las clases, indicar por pantalla cuantos días se tardan en alcanzar el planeta y cuantas naves serían necesarias para trasladar a todas las personas necesarias para poblarlo en su máxima capacidad.

Y un posible código solución:

Clase Planeta

public class Planeta {
    private double añosLuz;
    public Planeta(double distanciaKM) {
        this.añosLuz = distanciaKM;
    }
    public double getAñosLuz() {
        return añosLuz;
    }
    public void setAñosLuz(double añosLuz) {
        this.añosLuz = añosLuz;
    }
    public double diasDeViaje(){
        return añosLuz/10;
    }
}

Clase PlanetaHabitable

public class PlanetaHabitable extends Planeta {
    private double CapacidadPobladoresEnMillones;

    public PlanetaHabitable(double CapacidadPobladoresEnMillones, double distanciaKM) {
        super(distanciaKM);
        this.CapacidadPobladoresEnMillones = CapacidadPobladoresEnMillones;
    }
    public double getCapacidadPobladoresEnMillones() {
        return CapacidadPobladoresEnMillones;
    }
    public void setCapacidadPobladoresEnMillones(double CapacidadPobladoresEnMillones) {
        this.CapacidadPobladoresEnMillones = CapacidadPobladoresEnMillones;
    }  
    public double NumeroNaves(double CapacidadNave){
        return (CapacidadPobladoresEnMillones/CapacidadNave)+1;
    }
}

Programa principal

import java.util.Scanner;

public class TrasladoPoblacionAPlanetaHabitable {

    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        double distancia,poblacion,capacidadNave;
        System.out.println("¿A cuantos años luz de distancia se encuentra el planeta?");
        distancia= sc.nextDouble();
        System.out.println("¿Qué población admite el planeta?");
        poblacion=sc.nextDouble();
        System.out.println("¿Qué capacidad tiene una nave?");
        capacidadNave=sc.nextDouble();
        PlanetaHabitable destino = new PlanetaHabitable (poblacion, distancia);
        System.out.println("Tardamos "+destino.diasDeViaje()+" dias de viaje en alcanzar el planeta");
        System.out.println("Necesitamos "+destino.NumeroNaves(capacidadNave)+" naves para alcanzar el planeta");
    }
}

Ejercicio 6: Clases Barco y Motora

1.- Crea una clase llamada Barco con dos parámetros: eslora y manga. Ambos son del tipo double y tienen que estar declarados como privados.

2.- Crea otra clase llamada Motora que herede de Barco. La clase Motora tiene un único parámetro: Potencia en caballos de vapor (ponle el nombre que quieras). Este parámetro es de tipo double y tiene que declararse como privado

3.- Programa un método en la clase Motora que presente por pantalla todos los datos de un objeto Motora

4.- Programa un segundo método en la clase Motora que devuelva los litros de combustible que se necesitan para recorrer una distancia. Los litros es una variable tipo double.

A este método se le pasa la distancia (tipo double) a recorrer como parámetro. El cálculo de los litros necesarios es: ((eslora+manga)/potencia)*millas

5.- En el método main:

Pide al usuario que introduzca los datos de manga, eslora, potencia y distancia que quiere recorrer.

Crea un objeto de tipo Motora con los datos introducidos por el usuario.

Presenta por pantalla los datos de la Motora utilizando el método de la clase

Indica por pantalla cuantos litros de combustible necesita la motora para recorrer la distancia deseada. Emplea para ello el método de la clase.

Una posible solución:

1.- Clase Barco

public class Barco {
    private double eslora;
    private double manga;

    public Barco(double eslora, double manga) {
        this.eslora = eslora;
        this.manga = manga;
    }
    public double getEslora() {
        return eslora;
    }
    public double getManga() {
        return manga;
    }
}

Clase Motora

public class Motora extends Barco {
    private double Potencia_CV;

    public Motora(double Potencia_CV, double eslora, double manga) {
        super(eslora, manga);
        this.Potencia_CV = Potencia_CV;
    }

    public double getPotencia_CV() {
        return Potencia_CV;
    }

    public void setPotencia_CV(double Potencia_CV) {
        this.Potencia_CV = Potencia_CV;
    }

    public double litros(double millas){
        return ((this.getEslora()+this.getManga())/this.getPotencia_CV())*millas;
    }
    public void datos(){
    System.out.println("Eslora = "+this.getEslora());
    System.out.println("Manga = "+this.getManga());
    System.out.println("Potencia = "+this.getPotencia_CV()+" CV");
    }
}

Y la clase principal:

import java.util.Scanner;

public class ClasesBarcoMotora {

    public static void main(String[] args) {
        System.out.println("Introduce la manga de la motora");
        Scanner sc = new Scanner(System.in);
        double manga = sc.nextDouble();
        System.out.println("Introduce la eslora de la motora");
        Scanner sc1 = new Scanner(System.in);
        double eslora = sc.nextDouble();
        System.out.println("Introduce la potencia en CV de la motora");
        Scanner sc3 = new Scanner(System.in);
        double CV = sc.nextDouble();
        System.out.println("Introduce la distancia que quieres navegar en Millas marinas");
        Scanner sc4 = new Scanner(System.in);
        double millas = sc.nextDouble();
        
        Motora mimotora = new Motora(CV,eslora,manga);
        System.out.println("La motora con las siguientes características:");
        mimotora.datos();
        System.out.println("Necesita "+mimotora.litros(millas)+" litros, para recorrer "+millas+" millas marinas");
    }
}

Ejercicio 7: Clases Punto y Rectangulo

Crea una clase llamada «Punto» que tenga los atributos «x» e «y». Crea otra clase llamada «Rectangulo», que tiene como parámetros dos objetos de tipo Punto.

La clase Rectangulo debe implementar un método que calcule el área del rectángulo a partir de sus dos parámetros Punto.

El programa debe crear dos objetos punto y presentar por pantalla el área del rectángulo formado por los dos puntos.

NOTA: Lógicamente el área se calcula multiplicando las diferencias entre las coordenadas x e y de ambos puntos.

Por ejemplo:

Punto 1: (3,5) y Punto 2: (1,1)
Diferencias coordenadas x = 2, diferencias coordenadas y = 4
Area = 8

Si alguna de las diferencias de coordenadas fuera igual a cero, se indica por pantalla que no puede calcularse el área.

Una posible solución:

En este caso introduzco una modificación en la solución. No planteo las distintas clases en ficheros dedicados, lo que me permitiría declararlas como públicas y que fueran accesibles desde otros ficheros, sino que las programo en el mismo fichero que la clase que contiene el método main, con lo que no pueden ser declaradas como publicas y no serán accesibles desde otros ficheros.

class Punto {
    int x;
    int y;

    public Punto(int x, int y) {
        this.x = x;
        this.y = y;
    }
}

class Rectangulo {
    Punto punto1;
    Punto punto2;

    public Rectangulo(Punto punto1, Punto punto2) {
        this.punto1 = punto1;
        this.punto2 = punto2;
    }

    public int calcularArea() {
        int diferenciaX = Math.abs(punto1.x - punto2.x);
        int diferenciaY = Math.abs(punto1.y - punto2.y);

        if (diferenciaX == 0 || diferenciaY == 0) {
            System.out.println("No se puede calcular el área porque una de las diferencias de coordenadas es igual a cero.");
            return -1;
        }

        return diferenciaX * diferenciaY;
    }
}

public class Main {
    public static void main(String[] args) {
        Punto punto1 = new Punto(3, 5);
        Punto punto2 = new Punto(1, 1);

        Rectangulo rectangulo = new Rectangulo(punto1, punto2);

        int area = rectangulo.calcularArea();
        if (area != -1) {
            System.out.println("Área del rectángulo: " + area);
        }
    }
}

NOTA:

Puedes encontrar más ejercicios para practicar con este tema en el siguiente repositorio de G itHub.

Este post es parte de la colección “Java”. Puedes ver el índice de esta colección aquí.