Ejercicio "Dado"

Crear la clase Dado. Al constructor se le pasará el número de caras que tendrá el dado. Además, tendrá una función tirarDado(), que devuelve un número aleatorio que debe estar entre 1 y el número de caras del dado, para que funciones como cualquier dado.

public class Dado {
    private int caras;
    public Dado(int lados) {
        caras = lados;
    }
    public int tirarDado() {
        int aux;
        aux = (int) (Math.random()*caras+1);
        return aux;
    }
}

Ejercicio "Fracción"

Crear la clase Fraccion, que tendrá los atributos y funciones necesarios para realizar las operaciones básicas que se pueden realizar con fracciones.

public class Fraccion {
    private int numerador;
    private int denominador;
    public Fraccion(int num){
        this(num, 1);
    }
    public Fraccion(int num, int den){
        if (den == 0)
            throw new RuntimeException();
        numerador = num;
        denominador = den;
    }
    public Fraccion inversa() {
        Fraccion aux;
        aux = new Fraccion(denominador, numerador);
        return aux;
    }
    public Fraccion producto(Fraccion f) {
        Fraccion resultado;
        int numRes, denRes;
        numRes = f.numerador * numerador;
        denRes = f.denominador * denominador;
        resultado = new Fraccion(numRes, denRes);
        return resultado;
    }
    @Override
    public String toString() {
        return numerador+"/"+denominador;
    }
    public Fraccion opuesta() {
        Fraccion aux;
        aux = new Fraccion(-numerador, denominador);
        return aux;
    }
    public static int mcd(int num1, int num2) {
        int aux;
        //Algoritmo de Euclides
        while (num2 != 0){
            aux = num1;
            num1 = num2;
            num2 = aux % num2;
        }
        return num1;
    }
    public static int mcm(int num1, int num2) {
        int mcm;
        int a=num1, b=num2;
        while (num1 != num2){
            if (num1>num2)
                num1 = num1-num2;
            else
                num2 = num2-num1;
        }
        mcm = a*b/num2;
        return mcm;
    }
    public Fraccion suma(Fraccion f2) {
        Fraccion resultado;
        int minimo, num;
        minimo = mcm(denominador, f2.denominador);
        num = (minimo/denominador)*numerador + (minimo/f2.denominador)*f2.numerador;
        resultado = new Fraccion(num, minimo);
        return resultado;
    }
    public boolean equals(Fraccion f2) {
        return numerador==f2.numerador & denominador==f2.denominador;
    }
    public int compareTo(Fraccion f2) {
        double prim, segun;
        int res;
        prim = (double)numerador/denominador;
        segun = (double)f2.numerador/f2.denominador;
        if (prim < segun)
            res = -1;
        else if (prim > segun)
            res = 1;
        else
            res = 0;
        return res;
    }
    public Fraccion simplificar() {
        int divisor;
        divisor = mcd(numerador, denominador);
        numerador = numerador/divisor;
        denominador = denominador/divisor;
        
        return this;
    }
}

Ejercicio "Potenciómetro"

Crear la clase Potenciómetro, que tendrá varias clases y atributos, de manera que funcione como cualquier potenciómetro, por ejemplo, como los de una vitrocerámica.

public class Potenciometro {
    private int[] valores;
    private int actual;
    public Potenciometro(int[] tabla) {
        valores = tabla;
        actual = 0;
    }
    public void apagar() {
        actual = 0;
    }
    public void subir() {
        if (actual < valores.length-1)
            actual++;
    }
    public void bajar() {
        if (actual > 1)
            actual--;
    }
    public int consultar() {
        return valores[actual];
    }
    @Override
    public String toString() {
        StringBuffer aux = new StringBuffer();
        int i;
        for (i=0; i

Ejercicio "Pasajeros al tren"

Implementar las siguientes clases: 

Pasajero que representa un pasajero del tren. Sólo se almacenará su nombre y tendrá las funciones: constructora (que lo inicializa) y getNombre() que devuelve el nombre del pasajero.

VagonPasajeros que representa un vagón de pasajeros,tendrá información sobre los pasajeros que transporta o podría transportar.

Tiene como atributo, una tabla asientos que representa los asientos del tren, de modo que cada elemento de la tabla puede estar libre u ocupada por un objeto pasajero. 

Sus métodos serán:

• VagonPasajeros(int capacidad)

es el único constructor y recibe el número de asientos para crear la tabla que inicialmente esta vacía.

• void subir(Pasajero pasajero)

acomoda al pasajero en el vagón, los asientos se llenan en orden según lleguen pasajeros, si no hay asientos libres debe lanzarse una excepción (RuntimeException).

• Pasajero bajar(String nombre)

recibe el nombre del pasajero que debe apearse, lo elimina del vagón y devuelve el objeto correspondiente.

Tranvia, que tendrá información sobre los pasajeros que transporta o podría transportar en cada uno de sus vagones.

Tiene un atributo privado... una tabla vagones, de modo que cada elemento de la tabla debe contener un objeto VagonPasajeros.

Sus métodos serán:

• Tranvia()

para construir un tranvía de cuatro vagones.

• Tranvia(int numVagones)

para construir un tranvía con numVagones vagones

• Pasajero bajar(String nombre, int vagon)

para eliminar al pasajero indicado, del vagón indicado y retornarlo como resultado.

Si no existe ningún pasajero con el nombre indicado, se retornará null.

nota.- los vagones se numeran desde uno en adelante.

• int subir(Pasajero p,int vagon)

Para intentar subir al pasajero indicado, en el vagón indicado.

Si este vagón está lleno, se intentará en los siguientes.

Si no quedan más vagones detrás, se continuará intentando desde el primer vagón.

Si finalmente no se consigue subir al pasajero a ningún vagón, se lanzará una excepción RuntimeException indicando en un texto el problema.

Si el vagón solicitado no existe, se lanzará una excepción RuntimeException indicando en un texto el problema.

La función retornará el número del vagón al que haya conseguido subir al pasajero.

CLASE PASAJERO

public class Pasajero {
    private String nombre;
    Pasajero (String s){
        nombre = s;
    }
    public String getNombre(){
        return nombre;
    }
}

CLASE VAGONPASAJEROS

public class VagonPasajeros {
    private Pasajero[] asientos;
    private Nodo primero = null;
    private Nodo ultimo = null;
    private class Nodo {
        public int asiento;
        public Nodo sig;
    }
    VagonPasajeros (int capacidad){
        asientos = new Pasajero[capacidad];
        for (int i=0; i < asientos.length; i++){
            Nodo nuevo = new Nodo();
            nuevo.asiento = i;
            nuevo.sig = null;
            if (primero == null)
                primero = nuevo;
            else
                ultimo.sig = nuevo;
            ultimo = nuevo;
        }
    }
    public void subir (Pasajero pasajero){
        if (lleno()){
            throw new RuntimeException("El vagón está lleno");
        }
        asientos[primero.asiento] = pasajero;
        primero = primero.sig;
    }
    public Pasajero bajar (String nombre){
        int i=0;
        boolean encontrado = false;
        Nodo nuevo;
        Pasajero aux = null;
        while (i<asientos.length & !encontrado){
            if (asientos[i] != null && nombre.equalsIgnoreCase(asientos[i].getNombre())){
                aux = new Pasajero(asientos[i].getNombre());
                asientos[i] = null;
                nuevo = new Nodo();
                nuevo.asiento = i;
                nuevo.sig = null;
                if (primero == null)
                    primero = nuevo;
                else
                    ultimo.sig = nuevo;
                ultimo = nuevo;
                encontrado = true;
            }
            i++;
        }
        return aux;
    }
    private boolean lleno(){
        return primero == null;
    }
}

CLASE TRANVIA

public class Tranvia {
    private VagonPasajeros[] tranvia;
    Tranvia(){
        this(4);
    }
    Tranvia (int numVagones){
        tranvia = new VagonPasajeros[numVagones];
        for (int i=0; i<tranvia.length; i++){
            tranvia[i] = new VagonPasajeros(2);
        }
    }
    public int subir (Pasajero p, int vagon){
        vagon = vagon-1;
        int contador = 0;
        boolean sentado = false;
        if (vagon<0 || vagon>=tranvia.length){
            throw new RuntimeException("El vagón no existe.");
        }
        while (contador<tranvia.length & !sentado){
            try{
                sentado = true;
                tranvia[vagon].subir(p);
            }
            catch(RuntimeException e){
                sentado = false;
            }
            vagon=(vagon+1)%tranvia.length;
            contador++;
        }
        if (!sentado)
            throw new RuntimeException("El tranvía está lleno.");
        if (vagon == 0)
            vagon = tranvia.length;
        return vagon;
    }
    public Pasajero bajar (String nombre, int vagon){
        vagon = vagon-1;
        return tranvia[vagon].bajar(nombre);
    }
}

Ejercicio "Cola dinámica"

Crear la clase ColaFrasesDin. Se tratará de una cola dinámica, es decir, que no tendrá un tamaño fijo, sino que éste irá variando según se añadan o eliminen objetos de la cola.

Para poder realizar la cola dinámica, emplearemos un objeto Nodo, que contendrá el dato a almacenar en cada lugar de la cola y la referencia al siguiente nodo que le sigue.

public class ColaFrasesDin {
    private Nodo primero = null;
    private Nodo ultimo = null;
    private class Nodo {
        public String dato;
        public Nodo sig;
    }
    public void acolar (String frase){
        Nodo nuevo = new Nodo();
        nuevo.dato = frase;
        nuevo.sig = null;
        if (primero == null)
            primero = nuevo;
        else
            ultimo.sig = nuevo;
        ultimo = nuevo;
    }
    public String desacolar (){
        String aux;
        aux = primero.dato;
        primero = primero.sig;
        return aux;
    }
    public boolean vacia (){
        return primero == null;
    }
}

Ejercicio invertir tabla

Crear una función que invierta el contenido de una tabla de String que recibe como atributo, utilizando un objeto PilaFrase.

public static void invertir (String[] tabla){
    int i;
    PilaFrases aux = new PilaFrases(tabla.length);
    for (i=0; i<tabla.length; i++){
        aux.push(tabla[i]);
    }
    for (i=0; i<tabla.length; i++){
        tabla[i] = aux.pop();
    }
}

Ejercicio "Pila" y "Cola"

Crear las clases "PilaFrases" y "ColaFrases", que permitan crear, como su nombre indica, una pila y una cola, respectivamente, de String. Cada clase tendrá los atributos necesarios y las funciones que permitan trabajar con los objetos PilaFrases y ColaFrases, modificándolos o, simplemente, consultando determinados datos.

PilaFrases

public class PilaFrases {
    private String[] frases;
    private int cima;
    PilaFrases(){
        frases = new String[10];
        cima = -1;
    }
    PilaFrases(int numero){
        frases = new String[numero];
        cima = -1;
    }
    public void push (String frase){
        if (cima < frases.length){
            cima++;
            frases[cima] = frase;
        }
    }
    public String pop (){
        cima--;
        return frases[cima+1];
    }
    public boolean empty(){
        /*boolean vacia;
        if (cima == -1)
            vacia = true;
        else
            vacia = false;*/
        return cima == -1;
    }
    public boolean full(){
        /*boolean llena;
        if (cima == (frases.length-1))
            llena = true;
        else
            llena = false;*/
        return cima == (frases.length-1);
    }
}

ColaFrases

public class ColaFrases {
    private String[] tabla;
    private int primero, ultimo;
    ColaFrases(){
        this(10);
    }
    ColaFrases(int tamaño){
        tabla = new String[tamaño+1];
        primero = 0;
        ultimo = -1;
    }
    public boolean llena(){
        return sig(sig(ultimo)) == primero;
    }
    public boolean vacia(){
        return sig(ultimo) == primero;
    }
    private int sig(int actual){
        return (actual+1)%tabla.length;
    }
    public void acolar(String frase){
        if (this.llena())
            throw new IndexOutOfBoundsException("La cola está llena");
        ultimo = sig(ultimo);
        tabla[ultimo] = frase;
    }
    public String desacolar(){
        String aux;
        if (this.vacia())
            throw new IndexOutOfBoundsException("La cola está vacía");
        
        aux = tabla[primero];
        primero = sig(primero);
        return aux;
    }
}

Ejercicio crear clase "BotellaLitro"

Crear la clase BotellaLitro, con varios atributos que indican su estado y diferentes funciones que permiten modificar su estado, consultar su estado y realizar otras operaciones.

public class BotellaLitro {
    public static final float CAPACIDAD = 1.0F;
    public static final int MEDIA = 6;
    public static final int NORMAL = 12;
    public static final int EXTRA = 24;
    private boolean estaCerrada;
    private float contenido;
    public static String unidad = "litros";
    public void abrir(){
        estaCerrada = false;
    }
    public void cerrar(){
        estaCerrada = true;
    }
    public float contenido(){
        return contenido;
    }
    public boolean estaCerrada(){
        return (estaCerrada);
    }
    @Override
    public String toString(){
        String aux;
        if (!estaCerrada)
            aux="abierta";
        else
            aux="cerrada";
        return ("La botella está "+aux+" y tiene "+contenido+" "+unidad);
    }
    public void vaciar(){
        if (!estaCerrada)
            contenido = 0;
    }
    public void llenar(){
        if (!estaCerrada)
            contenido = CAPACIDAD;
    }
    public float añadir(float cantidad){
        float sobra;
        if (!estaCerrada){
            sobra = cantidad - (CAPACIDAD - contenido);
            if (sobra >=0)
                contenido = CAPACIDAD;
            else{
                sobra = 0;
                contenido = contenido + cantidad;
            }
        }
        else
            sobra = cantidad;
        return (sobra);
    }
    public float extraer(float cantidad){
        float extraido;
        if (!estaCerrada){
            if (cantidad <= contenido){
                extraido = cantidad;
                contenido = contenido - extraido;
            }
            else{
                extraido = contenido;
                contenido = 0;
            }   
        }
        else
            extraido = 0F;
        return (extraido);
    }
    public static BotellaLitro[] cajaDeBotellas(int unidades){
        BotellaLitro[] caja = new BotellaLitro[unidades];
        int i;
        if (!(unidades == MEDIA | unidades == NORMAL | unidades == EXTRA))
            caja = null;
        else
            for(i=0; i<caja.length; i++){
                caja[i] = new BotellaLitro();
                caja[i].llenar();
                caja[i].cerrar();
            }
        return (caja);
    }
    public float diferencia(BotellaLitro bot2){
        float diferencia;
        if (contenido < bot2.contenido)
            diferencia = bot2.contenido - contenido;
        else
            diferencia = contenido - bot2.contenido;
        return diferencia;
        //OTRA FORMA:
        //return Math.abs(contenido - bot2.contenido);
    }
    public boolean equals(BotellaLitro bot2){
        boolean iguales;
        if (contenido == bot2.contenido)
            iguales = true;
        else
            iguales = false;
        return iguales;
        //OTRA FORMA:
        //return contenido == bot2.contenido;
    }
    public int compareTo(BotellaLitro bot2){
        int a;
        if (contenido < bot2.contenido)
            a = -1;
        else if (contenido == bot2.contenido)
            a = 0;
        else
            a = 1;
        return a;
    }
}