Ejercicios de Programación Orientada a Objetos en Java: Estudiantes, Libros y Vectores

Ejercicio 1: Clase Estudiante Universitario en Java

Se solicita implementar en Java la clase EstudianteUniversitario, la cual permitirá gestionar las notas de los estudiantes.

Funcionalidades Requeridas:

• Un constructor para cargar el nombre, número de matrícula e inicializar el array de las asignaturas como NO evaluadas.
• Métodos para consultar el DNI y el número de matrícula.
• Un método para consultar la nota de una asignatura a partir de su código.
• Un método para actualizar la nota de una asignatura.
• Un método para consultar si una asignatura está o no evaluada a partir de su código.

Implementación de un Método main

Implemente un método main que haga uso de la clase EstudianteUniversitario, solicitando al usuario el DNI y la matrícula para crear un nuevo estudiante.

Código de la Clase EstudianteUniversitario

public class EstudianteUniversitario {
    private int DNI;
    private int matricula;
    private double[] notas;
    private static final double NOEVALUADO = -1.0;

    public EstudianteUniversitario(int d, int m) {
        DNI = d;
        matricula = m;
        notas = new double[50];
        for (int i = 0; i < notas.length; i++)
            notas[i] = NOEVALUADO;
    }

    public int getDNI() {
        return DNI;
    }

    public int getMatricula() {
        return matricula;
    }

    public double nota(int codigo) {
        if (codigo < 0 || codigo >= 50)
            return -1.0;
        else
            return notas[codigo];
    }

    public void nota(int codigo, double nota) {
        if (nota < 0.0 || nota > 10.0)
            return;
        else
            notas[codigo] = nota;
    }

    public boolean evaluado(int codigo) {
        if (codigo < 0 || codigo >= 50) {
            System.out.println("Asignatura desconocida");
            return false;
        } else
            return notas[codigo] != NOEVALUADO;
    }

    // Ejemplo de main
    public static void main(String[] arg) {
        int valorDNI = Teclado.readInt();
        int valorMatricula = Teclado.readInt();
        EstudianteUniversitario nuevoEstudiante =
                new EstudianteUniversitario(valorDNI, valorMatricula);
        double n = 5.0;
        for (int i = 0; i < 10; i++) {
            nuevoEstudiante.nota(i, n);
            n++;
        }
        boolean evaluadoCalculo = nuevoEstudiante.evaluado(7);
        System.out.println(evaluadoCalculo);
    }
}

Ejercicio 2: Clases Libro y Librería en Java

Considerando la interfaz IArticulo y la clase CodigoBarras definidas en el mismo paquete, se desarrollarán las clases Libro y Libreria.

Clase Libro

Un libro está modelado por su precio (de tipo double), un código de barras (objeto de la clase CodigoBarras), un título, un autor y su ISBN.

Métodos:

• Un constructor sin argumentos que crea un libro con precio de 0 euros.
• Un constructor que toma como argumento el precio, código de barras, autor y título.
• Métodos para establecer y consultar su ISBN.
• Un método que devuelva el título del libro y el autor separados por una coma.

Clase Librería

Una librería está modelada por un array bidimensional de objetos de la clase Libro.

Código de la Clase Libro

class Libro implements IArticulo {
    private double precio;
    private CodigoBarras codigo;
    private String titulo, autor;
    private int[] isbn;

    public Libro() {
        precio = 0;
        codigo = new CodigoBarras(0);
        isbn = new int[10];
        for (int i = 0; i < isbn.length; i++) {
            isbn[i] = 0;
        }
    }

    public Libro(double precio, CodigoBarras codigo, String autor,
            String titulo) {
        if (precio >= 0) {
            this.precio = precio;
        }
        if (codigo != null) {
            this.codigo = codigo;
        }
        if (autor != null) {
            this.autor = autor;
        }
        if (titulo != null) {
            this.titulo = titulo;
        }
        isbn = new int[10];
        for (int i = 0; i < isbn.length; i++) {
            isbn[i] = 0;
        }
    }

    public double getPrecio() {
        return precio;
    }

    public void setPrecio(double p) {
        if (p > 0)
            precio = p;
    }

    public CodigoBarras getCodigoBarras() {
        return codigo;
    }

    public int[] getISBN() {
        return isbn;
    }

    public void setISBN(int[] is) {
        if (is == null || is.length != 10)
            return;
        for (int i = 0; i < is.length; i++) {
            if (is[i] < 0 || is[i] >= 10) {
                return;
            }
        }
        isbn = is;
    }

    public String tituloYAutor() {
        return titulo + ", " + autor;
    }
}

Código de la Clase Libreria

class Libreria {
    Libro[][] l;

    public Libreria(int numeroEstanterias, int tamanio) {
        l = new Libro[numeroEstanterias][tamanio];
        for (int i = 0; i < l.length; i++)
            for (int j = 0; j < l[i].length; j++)
                l[i][j] = null;
    }

    public void colocar(Libro ejemplar) {
        for (int j = 0; j < l[0].length; j++) {
            if (l[ejemplar.getCodigoBarras().getCodigo()][j] == null) {
                l[ejemplar.getCodigoBarras().getCodigo()][j] = ejemplar;
            }
        }
    }

    public Libro prestar(int[] is, CodigoBarras cod) {
        for (int j = 0; j < l[0].length; j++) {
            if (is == l[cod.getCodigo()][j].getISBN()) {
                Libro copia = l[cod.getCodigo()][j];
                l[cod.getCodigo()][j] = null;
                return copia;
            }
        }
        return null;
    }
}

Ejercicio 3: Clase Vector para Operaciones de Álgebra Vectorial en Java

Para realizar operaciones de álgebra vectorial, se modelan los vectores de tres dimensiones mediante la clase Vector.

Código de la Clase Vector

public class Vector {
    // Variable de ejemplar
    private double[] coordenadas = new double[3];

    // Creación de un vector a partir de tres coordenadas del extremo
    public Vector(double x, double y, double z) {
        coordenadas[0] = x;
        coordenadas[1] = y;
        coordenadas[2] = z;
    }

    // Método para calcular el módulo del vector
    public double modulo() {
        double modulo = 0.0;
        for (int i = 0; i < coordenadas.length; i++)
            modulo += coordenadas[i] * coordenadas[i];
        return (Math.sqrt(modulo));
    }

    // Devuelve la coordenada en la dirección x
    public double get_coordenada_x() {
        return coordenadas[0];
    }

    // Devuelve la coordenada en la dirección y
    public double get_coordenada_y() {
        return coordenadas[1];
    }

    // Devuelve la coordenada en la dirección z
    public double get_coordenada_z() {
        return coordenadas[2];
    }

    // Devuelve un escalar, producto de él mismo con otro vector
    public double ProductoEscalar(Vector n) {
        return (coordenadas[0] * n.get_coordenada_x() +
                coordenadas[1] * n.get_coordenada_y() +
                coordenadas[2] * n.get_coordenada_z());
    }

    public static void main(String[] args) {
        Vector vector1 = new Vector(1, 1, 1);
        Vector vector2 = new Vector(2, 2, 2);
        System.out.println("Módulo 1:" + vector1.modulo());
        System.out.println("Módulo 2:" + vector2.modulo());
        System.out.println("Producto escalar: " +
                vector1.ProductoEscalar(vector2));
    }
}

Ejercicio 4: Herencia e Interfaces con Animales en Java

Se presenta una estructura de clases e interfaces donde las clases Ave y Mamifero implementan la interfaz Animal.

Ejemplo de Uso en un Método main

public static void main(String[] args) {
    Animal[] a = new Animal[10];
    for (int i = 0; i < 10; i++) {
        if (Math.random() > 0.5) {
            a[i] = new Ave();
        } else {
            a[i] = new Mamifero();
        }
        a[i].nacer();
        if (a[i] instanceof Ave) {
            ((Ave) a[i]).empollar();
        }
        if (a[i] instanceof Mamifero) {
            ((Mamifero) a[i]).amamantar();
        }
    }
}