Caso de estudio Estudiante

La simplificación se propone específicamente en la clase Estudiante y en este

caso radica en almacenar apenas el nombre, apellidos y solamente el valor de las
notas de las asignaturas aprobadas, así como la identificación del grupo al que
pertenece, el promedio y un método que permita ir adicionando las respectivas
notas. Seguidamente se muestra un diagrama de clases donde se representa el
diseño de esta variante de la clase Estudiante:
Estudiante
string nombre
string apellidos
string grupo
uint[] notas
...
+ double Promedio();
+ void AdicionarNota(uint nota) ...

Caso de estudio Clase

Codificar una variante de la clase Estudiante donde se implementen el
constructor y el método AdicionarNota. En una primera variante se asume que al
crearse las instancias de la clase Estudiante no se tiene ninguna nota y que el
arreglo notas va creciendo de uno en uno a través de AdicionarNota como se
muestra en el listado siguiente.
public class Estudiante
{
string nombre;
string apellidos;
string grupo;
uint[] notas = new uint[0];
public Estudiante(string nombre, string apellidos, string grupo)
{
this.nombre = nombre;
this.apellidos = apellidos;
this.grupo = grupo;
}
public void AdicionarNota(uint nota)
{
uint[] tempNotas = new uint[notas.Length+1];
notas.CopyTo(tempNotas, 0);
notas = tempNotas;
notas[notas.Length - 1] = nota;
}
}

Situación de análisis
Analice el segmento de código siguiente
{
...
Estudiante e = new Estudiante(...);
e.AdicionarNota(5);
...
}

Pregunta: 1.¿Qué sucede si mantenemos el mismo constructor y no inicializamos

el campo notas?
Pregunta: 2. ¿Cómo evitar la problemática anterior?

Caso de estudio: clase Traductor de palabras Ejemplo: Definir una clase que
permita “traducir” palabras de Español a Inglés y Portugués (idea original en [24])
El elemento principal en la solución de este ejemplo es la determinación de la
organización en memoria del “diccionario” que permitirá realizar la traducción. Aún
cuando existen Estructuras de Datos (Parte III) o tipos de dato específicos para la
representación de este tipo de información, en esta solución se aborda una
representación muy simple para ejemplificar una aplicación interesante de los
arreglos e indexers. En la siguiente figura se muestra un ejemplo de la
representación en memoria de la propuesta de diccionario que se desea
implementar:
Del análisis de la figura se concluye que las palabras podrían ser representadas
en arreglos por idiomas, donde en la i-ésima posición de cada arreglo se
encuentra una palabra en cada uno de los respectivos idiomas. En un primer
refinamiento la clase Traductor quedaría como se muestra en la siguiente figura.
Sugerimos definir las instancias de esta clase con un máximo de palabras
predeterminado a través del constructor. A partir de una instancia traducir de
Traductor, En términos de funcionalidades sugerimos insertar las palabras de la
siguiente forma: Traducir[“palabra“] = “word“; o Traducir[“palabra“, Inglés] =
“word“;
En el caso de las palabras en portugués se tiene una única opción:
Traducir[“palabra“, Portugués] = “palavra“; Esto quiere decir que inglés es la
traducción por defecto por lo que puede o no especificarse. Análogamente la
traducción de las palabras podría realizarse de la siguiente forma:
Console.WriteLine(Traducir[“palabra“]);
Console.WriteLine(Traducir[“palabra“, Inglés);
Console.WriteLine(Traducir[“palabra“, Portugués);
El análisis de las especificaciones anteriores conlleva a la necesidad de utilizar
enumeraciones (para los idiomas) e indexers como se muestra en la variante de
implementación que se muestra a continuación:
Public enum Idioma
{
Inglés, Portugués
}
public class Traductor
{
string[] español; string[] inglés; string[] portugués;
int cantPalabras;
public Traductor(uint maxPalabras)
{
 español = new string[maxPalabras]; inglés = new string[maxPalabras];
portugués = new string[maxPalabras];
}
public bool DiccionarioLLeno()
{
...
} public string this[string palabra]
{
get
{
return this[palabra, Idioma.Inglés];
}
set
{
this[palabra, Idioma.Inglés] = value;
}
}
public string this[string palabra, Idioma idioma]
{
get
{
...
}
set
{
...
}
}
Corresponde ahora la implementación de las secciones get y set definidas con
anterioridad. En el caso de set se necesita determinar la ubicación de la palabra
en español (algoritmo de búsqueda, método posición) y posteriormente con el
índice obtenido se puede retornar la traducción. Note que existen casos
excepcionales cuando no existe la palabra a traducir o no existe traducción hasta
entonces en el diccionario. El caso de la sección set aumenta la complejidad
porque de forma similar a get primero hay que determinar si existe la palabra en
español y luego si ya existe entonces la traducción. Seguidamente se muestran
variantes de implementaciones de las secciones get y set definidas con
anterioridad.
get
{
string tempStr = null;
int i = Posición(palabra);
if (i != -1)
switch (idioma)
{
case Idioma.Inglés: tempStr = inglés[i]; break;
default: tempStr = portugués[i]; break;
}
else
throw new Exception("Palabra no encontrada");
if (tempStr == null) throw new Exception("No existe traducción");
else
return tempStr;
}
Set
{
int i = Posición(palabra); if (i == -1)
{
if (DiccionarioLLeno())
throw new Exception("Diccionario lleno ...");
i = cantPalabras++;
español[i] = palabra.ToUpper();
}
switch (idioma)
{
case Idioma.Inglés:
if (inglés[i] != null) throw new Exception("Ya existe traducción al inglés de " +
palabra);
else
inglés[i] = value.ToUpper();
break;
default:
if (portugués[i] != null) throw new Exception("Ya existe traducción al
portugués " + palabra);
else
portugués[i] = value.ToUpper(); break;
}
}

Tarea implemente los métodos Posición y DiccionarioLleno ,muestre a

continuación la línea de código.