====== Examen Final - 75.07. Algoritmos y Programación III ======

**Cátedra:** Fontela\\
**Fecha:** Primer Oportunidad - Segundo Cuatrimestre 2006\\
**Día:** 14/12/2006

<note important>
Esta página está incompleta; podés ayudar completando el material.
</note>

===== Enunciado =====
==== Punto I ====
  - Implemente una clase ListaCircular, basándose en la clase LinkedList, de modo tal que se pueda recorrer en forma cíclica. Debe implementar el iterador correspondiente. Puede usar composición o herencia respecto de LinkedList.
  - Justifique por qué utilizó composición o herencia.
  - Haga el diagrama de clases correspondiente.
  - Escriba un método estático en una clase auxiliar, que imprima todos los elementos de una lista circular, utilizando el iterador implementado y el método toString de cada elemento.
  - Haga un diagrama de secuencia en UML para el método anterior.

==== Punto II ====
Explique todas las ventajas que conozca de los métodos incrementales (o iterativos) sobre el desarrollo en cascada. Nombre dos procesos de desarrollo iterativo.

==== Punto III ====
El uso de concurrencia en una aplicación asegura que la misma va a ejecutarse más rápidamente. ¿Verdadero o falso? Justifique.

===== Resolución =====


==== Punto I ====
{{:materias:75:07:circularlistclassdia.png|:materias:75:07:circularlistclassdia.png}}
<code java>
import java.util.Iterator;
import java.util.LinkedList;

public class CircularList<T> extends LinkedList<T>{

	public CircularList(){
		super();
	}

	public Iterator<T> iterator(){
		return new CircularIterator();
	}

	private Iterator<T> superIterator(){
		return super.iterator();
	}

	public boolean add(T t){
		return super.add(t);
	}

	class CircularIterator implements Iterator<T>{
		private Iterator<T> it;

		public CircularIterator(){
			it = superIterator();
		}

		public boolean hasNext() {
			if (size() > 0) return true;
			return false;
		}

		public T next() {
			if (!(it.hasNext())) it = superIterator();
			return it.next();
		}

		public void remove() {
			it.remove();
		}
	}
}

</code>

La razón por la cual se utiliza herencia es que esa relación permite la reutilización de todos los métodos de LinkedList. Dado que el único método que es necesario reescribir es iterator, se evita la implementación de los demás, los cuales sólo deberían delegar en los de la clase padre. Además, conceptualmente una ListaCircular "es una" LinkedList.

<code java>
import java.util.Collection;
import java.util.Iterator;

public class CollectionDisplayer {

	public static void showCollection(Collection collection){
		int max = collection.size();
		Iterator it = collection.iterator();
		for (int i = 1; i <= max; ++i){
			System.out.println(it.next()); //El método toString es llamado implícitamente
		}
	}
}
</code>
<note important>
Falta diagrama de secuencias
</note>

===== Discusión =====

<note warning>
Si ves algo que te parece incorrecto en la resolución y no te animás a cambiarlo, dejá tu comentario acá.
</note>