Ejercicio "Conjunto"

Crear la clase Conjunto<T>, que implementará la interfaz Set<T>. No se pondrá código a todas las funciones de Set<T>, tan sólo aquellas que nos interesan de momento.

Para almacenar todos los objetos que forman parte del conjunto, se empleará un ArrayList. Además, se creará la clase privada ParaRecorrerMiConjunto, alojada dentro de la clase Conjunto<T>, que implementa Iterator<T> y nos permite recorrer todos los elementos que forman parte del conjunto.

public class Conjunto<T> implements Set<T> {
    private ArrayList<T> datos;
    private class ParaRecorrerMiConjunto implements Iterator<T> {
        private int actual = -1;
        public boolean hasNext() {
            return actual < datos.size() - 1;
        }
        public T next() {
            if (!hasNext()) {
                throw new java.util.NoSuchElementException();
            }
            actual++;
            return datos.get(actual);
        }
        public void remove() {
            throw new UnsupportedOperationException("Not supported yet.");
        }
    }
    public Conjunto() {
        datos = new ArrayList<T>();
    }
    public void clear() {
        datos.clear();
    }
    @SuppressWarnings("element-type-mismatch")
    public boolean contains(Object o) {
        return datos.contains(o);
    }
    public int size() {
        return datos.size();
    }
    public boolean isEmpty() {
        return datos.isEmpty();
    }
    public boolean add(T e) {
        if (!datos.contains(e)) {
            return datos.add(e);
        }
        return false;
    }
    @SuppressWarnings("element-type-mismatch")
    public boolean remove(Object o) {
        return datos.remove(o);
    }
    @Override
    public String toString() {
        return datos.toString();
    }
    @Override
    public boolean equals(Object o) throws ClassCastException {
        Conjunto<T> aux = (Conjunto<T>) o;
        return this.datos.containsAll(aux.datos) & aux.datos.containsAll(this.datos);
    }
    public Iterator<T> iterator() {
        return new ParaRecorrerMiConjunto();
    }
    public Object[] toArray() {
        throw new UnsupportedOperationException("Not supported yet.");
    }
    public Object[] toArray(Object[] a) {
        throw new UnsupportedOperationException("Not supported yet.");
    }
    public boolean containsAll(Collection c) {
        throw new UnsupportedOperationException("Not supported yet.");
    }
    public boolean addAll(Collection c) {
        throw new UnsupportedOperationException("Not supported yet.");
    }
    public boolean retainAll(Collection c) {
        throw new UnsupportedOperationException("Not supported yet.");
    }
    public boolean removeAll(Collection c) {
        throw new UnsupportedOperationException("Not supported yet.");
    }
}

MODIFICACIÓN

Para que funcione realmente como un conjunto de cosas, modificaremos la clase ParaRecorrerMiConjunto, de manera que cada vez que se instancie un iterador para recorrer los elementos del conjunto, lo haga en orden aleatorio.

public class Conjunto3<T> implements Set<T> {
    private ArrayList<T> datos;
    private class ParaRecorrerMiConjunto implements Iterator<T>{
        private int actual=-1;
        private ArrayList<T> aux;
        ParaRecorrerMiConjunto(){
            aux = new ArrayList<T>(datos);
            Collections.shuffle(aux);
        }
        public boolean hasNext() {
            return !aux.isEmpty();
        }
        public T next() {
            if(!hasNext())
                throw new java.util.NoSuchElementException();
            actual++;
            return aux.get(actual);
        }
        public void remove() {
            throw new UnsupportedOperationException("Not supported yet.");
        }
    }
    public Conjunto3() {
        datos = new ArrayList<T>();
    }
    public void clear() {
        datos.clear();
    }
    @SuppressWarnings("element-type-mismatch")
    public boolean contains(Object o) {
        return datos.contains(o);
    }
    public int size() {
        return datos.size();
    }
    public boolean isEmpty() {
        return datos.isEmpty();
    }
    public boolean add(T e) {
        if (!datos.contains(e)) {
            return datos.add(e);
        }
        return false;
    }
    @SuppressWarnings("element-type-mismatch")
    public boolean remove(Object o) {
        return datos.remove(o);
    }
    @Override
    public String toString() {
        return datos.toString();
    }
    @Override
    public boolean equals(Object o) throws ClassCastException {
        Conjunto3<T> aux = (Conjunto3<T>) o;
        return this.datos.containsAll(aux.datos) & aux.datos.containsAll(this.datos);
    }
    public Iterator<T> iterator() {
        return new ParaRecorrerMiConjunto();
    }
    public Object[] toArray() {
        throw new UnsupportedOperationException("Not supported yet.");
    }
    public Object[] toArray(Object[] a) {
        throw new UnsupportedOperationException("Not supported yet.");
    }
    public boolean containsAll(Collection c) {
        throw new UnsupportedOperationException("Not supported yet.");
    }
    public boolean addAll(Collection c) {
        throw new UnsupportedOperationException("Not supported yet.");
    }
    public boolean retainAll(Collection c) {
        throw new UnsupportedOperationException("Not supported yet.");
    }
    public boolean removeAll(Collection c) {
        throw new UnsupportedOperationException("Not supported yet.");
    }
}

Ejercicio "Fracción" (modificación)

Modificar la clase Fraccion, de manera que implemente las interfaces Comparable y Reseteable, es decir, debe poner código a las funciones de esas interfaces. Como las interfaces se encuentran en otro paquete distinto a la clase Fraccion, se deben importar.
Además, se creará la excepción FraccionException, que se lanzará en el constructor de la clase Fraccion cuando el denominador sea 0.

EXCEPCIÓN: FraccionException

public class FraccionException extends ArithmeticException {
    public FraccionException(){
    }
    public FraccionException(String mensaje){
        super(mensaje);
    }
}

Las excepciones se programan normalmente con dos constructores:

• Uno por defecto, que no recibe nada.
• Otro que recibe un String, con el texto que queremos que se muestre si se lanza esa excepción.

Las excepciones pueden heredar de las existentes en Java, siempre que tenga sentido que así sea. Si queremos que la excepción no sea marcada, heredará de RuntimeException o de alguna de las que están dentro de ese conjunto.

CLASE: Fraccion

import interfaces.Comparable;
import interfaces.Reseteable;

public class Fraccion implements Comparable, Reseteable {
    private int numerador;
    private int denominador;
    public Fraccion(int num){
        this(num, 1);
    }
    public Fraccion(int num, int den){
        if (den == 0)
            throw new FraccionException();
        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 Fraccion simplificar() {
        int divisor;
        divisor = mcd(numerador, denominador);
        numerador = numerador/divisor;
        denominador = denominador/divisor;
        return this;
    }
    public int comparadoCon(Object obj) throws ClassCastException {
        Fraccion f2 = (Fraccion) obj;
        double prim, segun;
        int res;
        prim = numerador/(double)denominador;
        segun = f2.numerador/(double)f2.denominador;
        if (prim < segun)
            res = -1;
        else if (prim > segun)
            res = 1;
        else
            res = 0;
        return res;
    }
    public void reset() {
        numerador = 0;
        denominador = 1;
    }
}

Interfaces

Una interfaz (Java) es una colección de métodos, que no tendrán código, y de atributos, que serán públicos, estáticos y constantes. De esta manera, las clases que hereden de estás interfaces, se verán obligadas a ponerle código a las funciones, a no ser que se trate de clases abstractas.

Es en la documentación de la interfaz donde se especificará de forma concreta qué deben hacer los distintos métodos que la componen. Por ejemplo, la interfaz Comparable, de Java, contiene el método compareTo, que se define detalladamente aquí. Por lo tanto, si alguna clase implementa la interfaz Comparable, debe tener en cuenta la definición de su método para desarrollarlo de acuerdo con su fin.

Las interfaces pueden heredar de otras, en este caso se emplea "extends":

public class NombreInterface1 extends NombreInterface2 {
    //Aquí van los métodos y atributos de NombreInterface1
}

A continuación se muestran dos ejemplos de interfaces, que se utilizarán en algunos ejercicios realizados posteriormente:

public interface Comparable {
    int comparadoCon(Object obj) throws ClassCastException;
}

public interface Reseteable {
    void reset();
}

Cuando una clase hereda de una interfaz, es decir, cuando la implementa, se utiliza la palabra reservada "implements":

public class NombreClase implements NombreInterface {
    //Aquí va el código de NombreClase
}

Una clase puede implementar varias interfaces:

public class NombreClase implements NombreInterface1, NombreInterface2 {
    //Aquí va el código de NombreClase
}

REFERENCIAS:

• http://en.wikipedia.org/wiki/Interface_(Java)
• http://es.wikipedia.org/wiki/Interfaz_(Java)