Examen Parcial - 75.07. Algoritmos y Programación III

Cátedra: Fontela
Fecha: Primera Oportunidad - Primer Cuatrimestre 2005
Día: 17/05/05

Verdadero o Falso

1. Se denominan atributos de clase aquellos que tienen el mismo valor durante toda su existencia para cada objeto.
2. En la metodología incremental de desarrollo de software, el usuario final recién ve el sistema una vez que está terminado.
3. Un diagrama de clases representa las diferentes clases, interfaces y colaboraciones que componen un sistema y las relaciones que éstas poseen entre si.
4. Un elemento indica la aparición de un estimulo que puede disparar una transición de estados.

Selección Múltiple

Se debe elegir sólo una de las opciones. No es necesario justificar las respuestas, pero puede hacerlo si lo cree necesario. Por favor, marque la respuesta correcta directamente en esta hoja.

1. La relación entre “Lassie” y perro es:
   1. Una especialización.
   2. Una generalización.
   3. Una instanciación
   4. Una composición
   5. Todas las anteriores
   6. Ninguna de las anteriores
2. Un grafo de flujo sirve para:
   1. Realizar pruebas Alfa.
   2. Realizar pruebas de caja negra.
   3. Realizar pruebas de integración de caja blanca.
   4. Realizar pruebas de integración incremental de anchura.
   5. Realizar pruebas unitarias de caja blanca.
   6. Ninguno de las anteriores.

Desarrollo

1. Explique ventajas e inconvenientes del modelo de datos de referencias. Incluya una conclusión con su opinión sobre la conveniencia del mecanismo. Por favor, hágalo al dorso de esta hoja.
2. Se debe implementar una clase SuperArreglo que contenga un arreglo tipado cuyos elementos sean de tipo List.
   1. ¿Qué significa que los elementos sean de tipo List? (recordar que List es una interface)
   2. Defina los atributos de SuperArreglo e implemente los métodos:
      1. List get (int i) ⇒ devuelve la colección en la posición i
      2. Object get (int i, int j) ⇒ devuelve el elemento j-esimo de la colección en la posición i (recordar que hay un get(i) en List.
      3. void set (int i, List c) ⇒ coloca la colección c en la posición I, descartando lo que hubiera.
      4. void set (int i, int j, Object x) ⇒ coloco el elemento x en la posición j-ésima de la colección que está en la posición i, utilizando el add(x) de List.
3. Explicar qué ocurre si de la implementación anterior hacemos:
   1. SuperArreglo s = new SuperArreglo();
   2. s.set(0,new ArrayList());
   3. s.set(0, new LinkedList());
4. Declare un iterador que recorra una tras otra todas las colecciones del arreglo, implementando los métodos next() y hastNext(), e implemente el método iterator() en SuperArreglo.
5. ¿Podría haber resuelto el punto anterior con in Iterador[]? Si la respuesta es afirmativa, explique cómo. Si la respuesta es negativa, explique por qué.
6. Haga el diagrama de clases completo de su solución, incluyendo las clases heredadas y las interfaces implementadas, así como el iterador implementado.

Esta Solución fue subida por Gonzalo Soriano al grupo de yahoo de Sistemas_Fiuba

1. F
2. F
3. V
4. V

1. C
2. E

1. La ventaja del modelo de datos de referencia es que si hace falta memoria; pasa el recolector de basura; y todo objeto que no este referenciado es borrado. De esta forma, en caso de necesitar memoria; solo se va a estar usando la memoria que se necesite. La desventaja es que al hacer una copia o al comparar se hacen más complicado; ya que hay que usar los métodos equals() y copy(). Y en el caso de querer hacer comparaciones o copias profundas hay que redefinirlos. Esto es así; ya que las típicas sentencias ”=” y ”= =“solo comparan o igualan referencias.
2. 1. El hecho de que la clase SuperArreglo contenga elementos de tipo List significa que va a ser un arreglo tipado, que en cada posición va a tener colecciones que implementen la interfaz List. Como son ArrayList; Vector y todo tipo de listas. Dentro de cada elemento o posición del arreglo tipado va a haber una lista; o algo por el estilo.

/**Código distinto al de la solución propuesta por el autor del resto del resuelto**/
import java.util.*;
 
public class SuperArreglo {
	private ArrayList<List> arreglo;
 
	public SuperArreglo(){
		this.arreglo = new ArrayList<List>();
	}
 
	public List get(int i) throws ArrayIndexOutOfBoundsException{ //podría encapsularse en una Exception propia
		return arreglo.get(i);
	}
 
	public Object get(int i, int j) throws ArrayIndexOutOfBoundsException{ //podría encapsularse en una Exception propia
		List miSubLista = arreglo.get(i);
		return miSubLista.get(j);
	}
 
	public void set(int i, List c){
		arreglo.set(i, c);
	}
 
	public void set(int i, int j, Object x){
		List miSubLista = arreglo.get(i);
		miSubLista.set(j,x);	
	}
}

1. 1. SuperArreglo s = new SuperArreglo ' Creamos un SuperArreglo 's'.
   2. s.set(0, new ArrayList); ' Creamos un ArrayList y lo ponemos en la posición '0' de 's'
   3. s.set(0, new LinkedList); ' Creamos un LinkedList y lo ponemos en '0' de 's', descartando el ArrayList.
2. 
3. Si, en forma paralela a la creación del SuperArreglo creo un arreglo de iteradotes y a medida que agrego un elemento de tipo List; creo un iterador que lo apunte y lo guarde en el constructor de SuperArreglo(); y el otro en el “add(List c)”.
4.