IPOO 2 cuatrimestre 2015 Departamento de Ciencias e Ingeniería

Introducción a la Programación Orientada a Objetos Sonia Rueda Encapsulamiento y Abstracción
IPOO 2 cuatrimestre 2015 Departamento de Ciencias e Ingeniería de la Computación UNIVERSIDAD NACIONAL DEL SUR 2017

Encapsulamiento La evolución de los lenguajes de programación está fuertemente ligada a la evolución de las metodologías de desarrollo de software. Un lenguaje que soporte la metodología orientada a objetos debe soportar el concepto de encapsulamiento. En la POO el encapsulamiento es el mecanismo que permite esconder los detalles de la implementación de una clase, de modo que las clases que la usan sólo conozcan su funcionalidad. Así, una clase puede ser usada como una caja negra, sabiendo qué hace, pero no cómo lo hace. IPOO 2 cuatrimestre 2015

Modificadores de Acceso
En Java los modificadores de acceso determinan encapsulamiento de los miembros de la clase. Un miembro que se declara privado sólo puede ser usado dentro de la misma clase. Si un miembro se define como público es visible desde el exterior de la clase. Declararemos como privados los atributos, de modo que la representación de los datos quede encapsulada. Declararemos como públicos los métodos que estén especificados en el diagrama de clases. Los métodos auxiliares, en general, los definiremos como privados. IPOO 2 cuatrimestre 2015

Caso de Estudio: Estación Meteorológica
En una estación meteorológica se miden y registran valores de distintas variables meteorológicas que luego se usan para hacer predicciones. El diseñador del sistema elaboró un diagrama de clases que incluye a una clase TempMinEstacion . La clase encapsula a una estructura de datos que mantiene los valores de las temperaturas mínimas de cada día registradas en un período de n días y brinda servicios para: Calcular la mayor temperatura registrada Calcular el promedio de las temperaturas Calcular en cuántos días heló Decidir si hubo heladas IPOO 2 cuatrimestre 2015 Introducción a la Programación Orientada a Objetos

8 3.5 12 -1 3.5 10 -2 Mayor = 12 Promedio = 4,8 Cantidad de heladas = 2 Hubo Heladas = si IPOO 2 cuatrimestre 2015

El diseñador decidió que los datos se mantengan en un arreglo de n componentes, cada una de las cuales corresponde a la temperatura de un día del período. El arreglo es una estructura de datos, agrupa a una secuencia de elementos, todos del mismo tipo. Como la clase encapsula a la estructura de datos, el arreglo no es visible fuera de la clase TempMinEstacion. Las clases Clientes pueden crear objetos de clase TempMinEstacion y enviarles mensajes para calcular el promedio del período, determinar la mayor temperatura, etc. IPOO 2 cuatrimestre 2015 Introducción a la Programación Orientada a Objetos

La clase TempMinEstacion no brinda servicios para leer o mostrar datos. Toda la entrada y salida se hace desde las clases Clientes. TempMinEstacion brinda servicios para establecer el valor que corresponde a la temperatura de un día y retornar la temperatura almacenada para un día dado. Desde las clases Clientes el primer día se referencia con el valor 1 y el último día del período corresponde al valor n. IPOO 2 cuatrimestre 2015 Introducción a la Programación Orientada a Objetos

TempMinEstacion TempMinEstacion (cant : entero) Crea una estructura para mantener las temperaturas de cant días, requiere cant>0 float [] tMin <<constructores>> TempMinEstacion (cant : entero) <<comandos>> establecerTempMin (d:entero, t : real) establecerTempMin (d : entero t : real) requiere 1<=d<=cantDias() La temperatura del día 1 corresponde al subíndice 0 en el arreglo. 8 3.5 12 -1 3.5 10 -2 tMin length 7

TempMinEstacion obtenerTempMin(d:entero) :real Requiere 1<=d<=cantDias() float [] tMin <<consultas>> obtenerTempMin(d : entero):real cantDias () : entero mayorTempMin () : real promedioTempMin () : real cantHeladas() : entero huboHeladas () : boolean mayorTempMin () : real Retorna la mayor temperatura del período cantHeladas() : entero Cuenta la cantidad de días que heló Todas las consultas que procesan la estructura requieren que se haya asignado una temperatura a cada día. El primer día es el día 1. El período tiene al menos un día. huboHeladas () : boolean Retorna true si heló algún día

class TempMinEstacion { /* Todas las consultas que procesan la estructura requieren que se haya asignado una temperatura a cada día.El primer día es el día 1.El período tiene al menos un día.*/ private float [] tMin; //Constructor /*Crea una estructura para mantener las temperaturas de cant días, cant>0 */ public TempMinEstacion(int cant) { tMin= new float[cant] ; } ...

//Comandos public void establecerTempMin(int dia, float t){ /*Requiere 1<=dia<=cantDias()*/ tMin[dia-1]=t; } La temperatura de dia corresponde al subíndice dia-1 n el arreglo. Observemos que no establecemos controles ni requisitos sobre el valor de la temperatura.

// Consultas public float obtenerTempMin(int dia){ /*Requiere 1<=dia<=cantDias()*/ return tMin[dia-1]; } public int cantDias(){ return tMin.length;

public float promedioTempMin(){ /*Computa el promedio de temperaturas de un período con al menos un día*/ float prom=0, suma=0; for (int i=0;i<cantDias();i++) suma=suma+tMin[i]; prom=suma/cantDias(); return prom; } Recorrido Exhaustivo

Algoritmo mayorTempMin DS mayor mayor  temperatura minima del primer día para cada día a partir del segundo si temperatura mínima del día > mayor mayor  temperatura mínima del día Aunque el algoritmo se plantea para un problema específico puede generalizarse como un patrón reusable. El recorrido es independiente de la representación de los datos, siempre que las componentes puedan recorrerse secuencialmente.

public float mayorTempMin(){ /*Retorna la mayor temperatura del período*/ float mayor=tMin[0]; for (int i=1;i<cantDias();i++) if (tMin[i]>mayor) mayor=tMin[i]; return mayor; } Verificar con una clase tester considerando que la mayor temperatura sea la primera y la última

public float mayorTempMin(){ /*Retorna la mayor temperatura del período*/ float mayor=-1000; for (int i=0;i<cantDias();i++) if (i==0) mayor = tMin[0]; else if (tMin[i]>mayor) mayor=tMin[i]; return mayor; } Observe que esta solución es correcta y eficiente pero las estructuras de control no son adecuadas. La condición i==0 siempre se verifica una vez, en la primera iteración.

public int cantHeladas(){ //Cuenta la cantidad de días que heló int cant=0; for (int i=0;i<cantDias();i++) if (tMin[i]<0) cant++; return cant; } Verificar considerando que no haya heladas, que todos los días sean heladas, que el primer día haya helado, que el último haya helado

public boolean huboHeladas(){ /*Retorna verdadero si algún día heló*/ return cantHeladas() > 0; } Observemos que la solución es correcta pero no eficiente

public boolean huboHeladas(){ /*Retorna true si algún día heló */ boolean encontre=false; int i=0; while ((i<cantDias()) && (!encontre)) if (tMin[i]<0)encontre=true; else i++; return encontre; } Recorrido NO Exhaustivo Verificar considerando que no haya heladas, que todos los días sean heladas, que el primer día haya helado, que sólo el último haya helado

El arreglo está encapsulado, todo el acceso desde la clase cliente se realiza a través de los servicios ofrecidos por la clase proveedora. La cantidad de elementos del arreglo se define en el momento de la creación y corresponde a la cantidad de días del período. Para las clases cliente, el primer día se denota con 1. A cada día del período se le ha asignado una temperatura en el momento que se ejecuta una consulta. La entrada y salida se realiza desde la clase cliente.

Diseñe e implemente una clase tester que brinde un servicio para leer las temperaturas y para probar la funcionalidad de la clase TempMinEstacion En la página de la materia está disponible una clase tester parcial, queda como ejercicio completarla con casos de prueba adecuados para cada servicio.

class TestTempMinEstacion { public static void main(String[] args) { // Tester para una semana int cant =7; TempMinEstacion est; … } La variable est mantiene una referencia a un objeto de clase TempMinEstacion. La clase TestTempMinEstacion no conoce la representación interna de los datos, el arreglo no es visible.

class TestTempMinEstacion { public static void main(String[] args) { // Tester para una semana int cant =7; TempMinEstacion est; est = leerTempMinEst(cant) ; System.out.println("Muestra la estación "); mostrarTempMinEst(est) ; System.out.println("Promedio Estación" est.promedioTempMin() ); }

public static TempMinEstacion leerTempMinEst(int cant) { float t ; TempMinEstacion e= new TempMinEstacion(cant); for (int i=1;i<= e.cantDias();i++){ System.out.println("Ingrese la "+ "temperatura del día "+i); t = ES.leerFloat(); e.establecerTempMin (i,t) ; } return e;

public static TempMinEstacion leerTempMinEst(int cant) { float t ; TempMinEstacion e; e = new TempMinEstacion(cant); … return e; } tMin e length 7

public static void mostrarTempMinEst (TempMinEstacion e){ for (int i=1;i<= e.cantDias(); i++) System.out.println(" " + e.obtenerTempMin(i)); }

class Estacion { public static void main(String[] args) { // Tester para una semana int cant =7; float promSur,promNor; TempMinEstacion estSur,estNor,est; estSur = leerTempMinEst(cant) ; estNor = leerTempMinEst(cant) ; promSur =estSur.promedioTempMin(); promNor =estNor.promedioTempMin(); if (promSur >= promNor) est = estSur; else est = estNor; … } estSur, estNor y est mantienen referencias a objetos de clase TempMinEstacion.

import java.io.*; class TesterValoresDesdeArchivo { public static void main (String[] args) { TempMinEstacion est; int cantD = 7; est = iniTemp(7); mostrarTempMinEst(est); System.out.println("Promedio periodo = "+ est.promedioTempMin()); System.out.println("Mayor minima = "+ est.mayorTempMin()); System.out.println("Cantidad de heladas = "+ est.cantHeladas()); } …

public static TempMinEstacion iniTemp (int n) { String ruta="temp.txt"; TempMinEstacion e = new TempMinEstacion(n); try { BufferedReader in = new BufferedReader(new FileReader(ruta)); String str; int dia= 1; while (((str = in.readLine())!= null)&& (dia<=e.cantDias())){ float f= (float)Float.valueOf(str); e.establecerTempMin (dia,f) ; dia++; } catch (IOException err) { System.out.println ("Error al leer el archivo"); return e;

Agregue los siguientes servicios a la clase TempMinEstación Computar la cantidad de días en los que la temperatura fue mayor a un valor dado Computar la primera temperatura mayor a una dada; si no existe retornar el mismo valor recibido. Computar el número de día que corresponde la primera temperatura mayor a una dada, si no existe retornar 0. Decidir si hubo al menos dos días seguidos con temperatura mayor a una dada

contarMayores(t:real):entero Computa la cantidad de días con temperaturas mayores a t TempMinEstacion float [] tMin <<consultas>> contarMayores(t:real):entero primerMayor(t:real): real diaPrimerMayor(t:real): entero dosSeguidos(t:real):boolean primerMayor(t:real): real Computa la primera temperatura mayor a t, si no hay una mayor a t retorna t diaPrimerMayor(t:real): entero Computa el día en el que se produjo la primera temperatura mayor a t Si no hubo ninguna retorna 0 dosSeguidos(t:real):boolean Decide si hubo al menos dos días seguidos con temperaturas mayores t

Computar la cantidad de días en los que la temperatura fue mayor a un valor dado 8 3.5 11 -1 13.5 10 -2 si t=5.5 debe computar 4 si t=15 debe computar 0 si t=-5 debe computar 7

8 3.5 11 -1 13.5 10 -2 5.5 t contador

8 3.5 11 -1 13.5 10 -2 5.5 t contador 1

8 3.5 11 -1 13.5 10 -2 5.5 t contador 2

8 3.5 11 -1 13.5 10 -2 5.5 t contador 3

8 3.5 11 -1 13.5 10 -2 5.5 t contador 4

Algoritmo contarMayores DE t DS contador para cada día del período si la temperatura es mayor a t incrementar un contador 8 3.5 11 -1 13.5 10 -2 5.5 t contador 4

public int contarMayores(float t){ //Computa la cantidad de temperaturas mayores a t int cont = 0; for (int dia=0;dia<cantDias();dia++) if (tMin[dia] > t) cont++; return cont; } Recorrido exhaustivo Algunos Casos de Prueba t=5.5 6.2 2.1 4.2 -2.0 5.5 11.1 -4.2 9.0 2.2 2.1 -4.2 9.0 5.5 0.1 -4.2 3.0

Algoritmo contarMayores DE t DS contador para cada día del período si la temperatura es mayor a t incrementar un contador El algoritmo permite identificar las estructuras de control. public int contarMayores(float t){ //Computa la cantidad de temperaturas mayores a t int cont = 0; for (int dia=0;dia<cantDias();dia++) if (tMin[dia] > t) cont++; return cont; } Nuevamente es un patron reusable

Planteo Recursivo Contar los mayores a t del período de 7 días requiere contar los mayores de los 6 primeros días 8 3.5 11 -1 13.5 10 -2 5.5 t

Planteo Recursivo Contar los mayores a t del período de 6 días requiere contar los mayores de los 6 primeros días y sumar 1 8 3.5 11 -1 13.5 10 -2 5.5 t

Planteo Recursivo Caso trivial: La cantidad de temperaturas mayores a t en un período vacío, es 0 Caso recursivo: La cantidad de temperaturas mayores a t en un período de n días, es la cantidad de temperaturas mayores a t en n-1 días, más 1 si la temperatura del día n es mayor a t. Caso recursivo: La cantidad de temperaturas mayores a t en un período de n días, es la cantidad de temperaturas mayores a t en n-1 días, si la temperatura del día n no es mayor a t.

public int contarMayores(float t){ /*Computa la cantidad de temperaturas mayores a t*/ return cMayores(t,cantDias()); } private int cMayores(float t,int n){ int cont=0; if (n>0) if (tMin[n-1] > t) cont = cMayores(t,n-1)+1; else cont = cMayores(t,n-1); return cont;

Computar la primera temperatura mayor a una dada; si no existe devolver el mismo valor recibido. 8 3.5 11 -1 13.5 10 -2 primerMayor(9) computa 11

Computar la primera temperatura mayor a una dada; si no existe devolver el mismo valor recibido. 8 3.5 11 -1 13.5 10 -2 primerMayor(9)

8 3.5 11 -1 13.5 10 -2 primerMayor(9)

Algoritmo primerMayor DE t DS pri para cada día del período y mientras no encuentre una temperatura mayor a t si la temperatura del día es mayor a t pri = temperatura del día 8 3.5 11 -1 13.5 10 -2 primerMayor(9) computa 11 y termina

Algoritmo primerMayor DE t DS pri para cada día del período y mientras no encuentre una temperatura mayor a t si la temperatura del día es mayor a t pri = temperatura del día 8 3.5 11 -1 13.5 10 -2 primerMayor(15) computa 15 y termina

public float primerMayor(float t){ /*Computa la primera temperatura mayor a t, si no hay una mayor a t, retorna t*/ float pri = t; int dia=0; boolean encontro=false; while (dia < cantDias() && !encontro){ encontro = tMin[dia] > t; dia++;} if (encontro) pri = tMin[dia-1]; return pri; } 8 3.5 11 -1 13.5 10 -2 primerMayor(9) retorna 11 primerMayor(15) retorna 15

public float primerMayor(float t){ /*Computa la primera temperatura mayor a t, si no hay una mayor a t, retorna t*/ float pri = t; int dia=0; while (dia < cantDias() && pri == t) if (tMin[dia] > t) pri = tMin[dia]; else dia++; return pri; }

Computar el número de día que corresponde la primera temperatura mayor a una dada. Si en ningún día del período la temperatura es mayor a la dada, retorna 0. 8 3.5 11 -1 13.5 10 -2 diaMayor(9)

dia 1 8 3.5 11 -1 13.5 10 -2 diaMayor(9)

dia 2 8 3.5 11 -1 13.5 10 -2 diaMayor(9)

dia 3 8 3.5 11 -1 13.5 10 -2 diaMayor(9) Computa 3

8 3.5 11 -1 13.5 10 -2 diaMayor(15) Computa 0

Algoritmo diaMayor DE t DS pri para cada día del período y mientras no encuentre una temperatura mayor a t si la temperatura del día es mayor a t pri = día El algoritmo puede generalizarse en un patrón que se reuse para resolver otros problemas.

public int diaMayor(float t){ /*Computa el día en el que se produjo la primera temperatura mayor a t Si no hubo ninguna retorna 0*/ int pri= 0; int dia=0; boolean encontro=false; while (dia < cantDias() && !encontro){ encontro = tMin[dia] > t; dia++;} if (encontro) pri = dia; return pri; }

Decide si la temperatura de dos días seguidos fue mayor a t. 14.5 15 1 -1 8.5 10 -2 14.5 5 1 -1 8.5 11 12 14.5 5 1 -1 12.5 10.5 -2 si t=10 debe computar true 14.5 5 10 -1 12.5 10.5 15 si t=12 debe computar false Introducción a la Programación Orientada a Objetos

Algoritmo dosSeguidos DE t para todos los días del período excepto el último y mientras no se verifica la propiedad si la temperatura del día y la del día siguiente son mayores a t se verifica la propiedad Al implementar esta solución en Java es importante considerar la condición de terminación de la iteración, ya que el último elemento de la estructura no tiene un “siguiente”.

public boolean dosSeguidos (float t){ /*Decide si hay dos días seguidos con temperaturas mayores a t*/ boolean dos=false; for (int dia=0;dia<cantDias()-1 &&!dos; dia++) if ((tMin[dia]>t)&&(tMin[dia+1]>t)) dos = true; return dos; } Recorrido no exhaustivo

TempMinEstacion float [] tMin <<consultas>> obtenerTempMin(d : entero):real cantDias () : entero mayorTempMin () : real promedioTempMin () : real cantHeladas() : entero huboHeladas () : boolean … equals(e:TempMinEstacion):boolean equals(e:TempMinEstacion) :boolean Computa true si y solo sí coinciden las temperaturas de las dos estaciones día a día

Algunos Casos de Prueba 6.2 2.1 4.2 5.5 11.1 -4.2 9.0 6.2 2.1 4.2 9.0 5.5 0.1 -4.2 3.0 5.5 11.1 -4.2 9.0 5.5 11.1 -4.2 9.0

public boolean equals(TempMinEstacion e){ /*Computa true si y solo sí coinciden las temperaturas de las dos estaciones día a día*/ boolean iguales=cantDias()== e.cantDias(); float t; int i=0; while (i < cantDias() && iguales){ t = e.obtenerTemperatura(i+1); iguales = t == tMin[i]; i++; } return iguales; } Observe que e es una referencia a un objeto de clase TempMinEstacion, puede recibir cualquiera de los mensajes provistos por la clase. La variable tMin mantiene una referencia a un arreglo.

TempMinEstacion float [] tMin Computa la última temperatura mayor a t, si no hay ninguna retorna t <<consultas>> ultimaMayor(t:real):real huboMasNMayores(t:real,n:entero) :boolean huboNmayores(t:real,n:entero) Decide si hubo al menos n días con temperaturas mayores a t. Decide si hubo exactamente n días con temperaturas mayores a t.

Computa la última temperatura mayor a t, si no hay ninguna retorna t 8 3.5 11 11 -1 13.5 13.5 10 10 -2 ultimaMayor(9) Computa 10

public float ultimaMayor(float t){ /*Computa la última temperatura mayor a t o t*/ float ult= t; int i=cantDias()-1; while (i >= 0 && ult = t){ if (tMin[i] > t) ult = tMin[i]; else i--; } return ult;

Decidir si hubo al menos n temperaturas mayores a t 7.2 6.2 2.1 5.5 -2.0 t=5.5 n=3 Se recorre toda la estructura y no se encuentran 3 valores mayores a 5.5 t=5.5 n=3 7.2 2.2 8.1 -4.2 9.0 5.5 0.1 6.2 7.0 Se recorren los cinco primeros elementos, en los cinco primeros días hay 3 temperaturas mayores a 5.5 4.0 3.0 9.0 0.1 6.2 7.0 Se recorre toda la estructura, recién al analizar el último día se puede decidir que hay 3 temperaturas mayores a 5.5

Algoritmo huboMasNMayores DE t,n para cada día y mientras no se encuentren n mayores a t si la temperatura del dia es mayor a t incrementar un contador

public boolean huboMasNMayores(float t,int n){ /*Decide si hubo al menos n temperaturas mayores a t*/ int cont = 0; for (int i=0;i<cantDias()&&cont<n; i++) if (tMin[i] > t) cont++; return cont==n; } Recorrido no exhaustivo t=5.5 n=3 7.2 6.2 2.1 5.5 -2.0 7.2 2.2 8.1 -4.2 9.0 5.5 0.1 6.2 7.0 4.0 3.0 9.0 0.1 6.2 7.0

t=5.5 n=4 1.2 4.1 7.1 6.5 9.0 Cuando quedan solo 4 días por analizar, si la temperatura es menor que 5.5, es posible asegurar que no se cumple la propiedad, sin seguir recorriendo Modificar el código para interrumpir el recorrido cuando es posible asegurar que el arreglo no va a contener n valores mayores a t, aun sin haber llegado al último día.

public boolean huboMasNMayores(float t,int n){ /*Decide si hubo al menos n temperaturas mayores a t */ } El programador de la clase TempMinEstacion puede cambiar la implementación de los métodos, por ejemplo para mejorar la eficiencia, sin que la modificación afecte a las clases clientes.

Decidir si hubo exactamente n días con temperaturas mayores a t Algoritmo huboNMayores DE t,n para cada día y mientras no se encuentren más de n mayores si la temperatura es mayor a t incrementar un contador

public boolean huboNMayores(float t,int n){ /*Decide si hubo exactamente n temperaturas mayores a t*/ int cont = 0; for (int i=0;i<cantDias() && cont<n+1;i++) if (tMin[i] > t) cont++; return cont==n; } En este caso la iteración termina cuando es posible asegurar que la propiedad no se va a cumplir.

Observemos que hay tres estados posibles al terminar la iteración: Recorrió el período completo y no encontró n días con temperaturas mayores a t. Recorrió el período completo y encontró exactamente n días con temperaturas mayores a t. Recorrió m días (m<cantDias()) y encontró n+1 temperaturas mayores a t, se puede asegurar que la propiedad NO se cumple, sin terminar el recorrido.

TempMinEstacion Computa la última temperatura mayor a t en un período de cant días, si no hay ninguna retorna t (solución recursiva) float [] tMin <<consultas>> ultimaMayor(t:real):real huboMasNMayores(t:real,n:entero, cant:entero) :boolean Decide si hubo al menos n días con temperaturas mayores a t, en un período de cant días Requiere n > 0 (solución recursiva)

Computa la última temperatura mayor a t, si no hay ninguna retorna t Planteo recursivo Caso trivial: Si el número de días del período es 0, computa t. Caso trivial: Si la temperatura que corresponde al día cant es mayor a t, computa la temperatura de ese día. Caso recursivo: Si la temperatura que corresponde al día cant es menor o igual a t, computa la última temperatura mayor a t, en el período de los cant-1 primeros días

private float ultimaMayor (float t){ /*Computa la última temperatura mayor a t, en un período de cant días*/ return ultMayor(t,cantDias()); }

private float ultMayor (float t,int cant){ float ult; if (cant==0) ult = t; else if (tMin[cant-1] > t) ult = tMin[cant-1]; ult = ultimaMayor(t,cant-1); return ult; } Evalúa si la temperatura del último día del período verifica la propiedad Invoca recursivamente para computar la última temperatura mayor a t en un período de cant-1 días

Decide si hubo al menos n días con temperaturas mayores a t, en un período de cant días Planteo recursivo Caso trivial: Si el número de días del período es 0, computa falso Caso trivial: Si la temperatura del día cant es mayor a t y n es 1, computa true. Caso recursivo: Si la tempertura del día cant es menor o igual a t, decide si el período de los cant-1 primeros días tiene n temperaturas mayores a t. Caso recursivo: Si la tempertura del día cant es mayora t, decide si el período de los cant-1 primeros días tiene n-1 temperaturas mayores a t.

public boolean huboNMayores (float t,int n,int cant){ /*Decide si hubo al menos n días con temperaturas mayores a t, en un período de cant días */ boolean hubo; if (cant==0) hubo = false; else if (tMin[cant-1] > t) if(n==1) hubo = true; hubo = huboNMayores(t,n-1,cant-1); hubo = huboNMayores(t,n,cant-1); return hubo; }

tMin[cant-1] denota la temperatura del último día hubo = huboNMayores(t,n-1,cant-1); hubo toma el valor verdadero si hay n-1 temperaturas mayores a t, en el período de cant-1 días El planteo recursivo, como el algoritmo escrito en lenguaje informal, es una herramienta durante el diseño de la solución. Es conveniente familiarizarse con esta herramienta cuando los problemas son simples, de modo que al enfrentar problemas complejos estemos habituados a usarla. Una vez implementada la solución, es posible introducir algunos cambios, para mejorar la eficiencia, manteniendo la estructura del planteo.

public boolean huboNMayores (float t,int n,int cant){ /*Decide si hubo al menos n días con temperaturas mayores a t, en un período de cant días */ boolean hubo; if (cant<n) hubo = false; else if (tMin[cant-1] > t) if(n==1) hubo = true; hubo = huboNMayores(t,n-1,cant-1); hubo = huboNMayores(t,n,cant-1); return hubo; }

TempMinEstacion float [] tMin Decide si hubo al menos n días consecutivos con temperaturas mayores a t. Requiere n>0 <<consultas>> huboNConMayores(t:real,n:entero) :boolean periodoMasLargo(t:real):entero Computa la cantidad de días del período más largo con temperaturas mayores a t en días consecutivos.

public boolean huboNConMayores(float t,int n){ /*Decide si hubo al menos n temperaturas consecutivas mayores a t*/ } Dado el siguiente registro de temperaturas 5.5 11.1 8.2 4.0 6.1 -0.2 si t=5.5 y n = 2 debe computar true si t=5.5 y n = 3 debe computar false si t=-5 y n = 10 debe computar false

2.5 11.1 8.2 4.0 0.1 -0.2 4.8 5.2 5.1 -0.2 si t=4.5 y n = 3

2.5 11.1 8.2 4.0 0.1 -0.2 4.8 5.2 5.1 -0.2 si t=4.5 y n = 3 cont  1

2.5 11.1 8.2 4.0 0.1 -0.2 4.8 5.2 5.1 -0.2 si t=4.5 y n = 3 cont  2

2.5 11.1 8.2 4.0 0.1 -0.2 4.8 5.2 5.1 -0.2 si t=4.5 y n = 3 cont  0

2.5 11.1 8.2 4.0 0.1 -0.2 4.8 5.2 5.1 -0.2 si t=4.5 y n = 3 cont  1

2.5 11.1 8.2 4.0 0.1 -0.2 4.8 5.2 5.1 -0.2 si t=4.5 y n = 3 cont  2

2.5 11.1 8.2 4.0 0.1 -0.2 4.8 5.2 5.1 -0.2 si t=4.5 y n = 3 cont  3 Se satisface la propiedad

2.5 11.1 8.2 4.0 0.1 -0.2 4.8 5.2 5.1 -0.2 si t=4.5 y n = 4 cont  3 No se satisface la propiedad

Algoritmo huboNConMayores DE t, n para cada día del período y mientras no se verifique la propiedad si la temperatura es mayor a t incrementa el contador sino empieza a contar nuevamente Observemos que hemos establecido una condición muy general para la iteración. La estructura de este algoritmo modela la solución de muchos problemas.

Algoritmo huboNConMayores DE t, n para cada día del período y mientras no se encuentren n temperaturas consecutivas mayores a t si la temperatura es mayor a t incrementa el contador sino empieza a contar nuevamente

Algoritmo huboNConMayores DE t, n para cada día del período y mientras el contador es menor a n si la temperatura es mayor a t incrementa el contador sino empieza a contar nuevamente Esta versión es más refinada y más específica que las anteriores. La traducción a Java es más directa.

public boolean huboNConMayores(float t,int n){ /*Decide si hubo al menos n temperaturas consecutivas mayores a t*/ int cont = 0; for (int i=0;i<cantDias()&&cont < n;i++) if (tMin[i] > t) cont++; else cont = 0; return cont==n; } Recorrido no exhaustivo Establecer Casos de Prueba considerando especialmente que las n temperaturas mayores a t estén en las primeras posiciones o en las últimas de la estructura.

public int periodoMasLargo(float t){ /*Computa la cantidad de días del período más largo con temperaturas mayores a t en días consecutivos */ int cont = 0; int max =0; for (int i=0;i<cantDias();i++) if (tMin[i] > t) cont++; else{ if (cont > max) max = cont; cont = 0; } return max; ANALIZAR PARA QUÉ CASOS LA SOLUCIÓN NO ES CORRECTA

class TestMayoresValoresFijos { public static void main(String[] args) { TempMinEstacion est; int cantD =10; est=new TempMinEstacion(cantD); est.establecerTempMin(1,-1); est.establecerTempMin(2,6); est.establecerTempMin(3,12); est.establecerTempMin(4,5); est.establecerTempMin(5,8); est.establecerTempMin(6,12); est.establecerTempMin(7,7); est.establecerTempMin(8,4); est.establecerTempMin(9,-1); est.establecerTempMin(10,5);

System.out.println("Cantidad mayores a 5 = "+ est.contarMayores(5)); System.out.println("Hay 5 mayores a 5 = "+ est.huboMasNMayores(5,5)); System.out.println("Hay 8 mayores a 5 = "+ est.huboMasNMayores(5,8)); System.out.println("Hay 3 mayores a 10 = "+ est.huboMasNMayores(10,3)); System.out.println("Hay 3 consecutivos mayores a 5 “ + est.huboNConMayores(5,3)); System.out.println("Hay 5 consecutivos mayores a 5 "+ est.huboNConMayores(5,5)); System.out.println("Periodo mas largo a 5 "+ est.periodoMasLargo(5)); System.out.println("Periodo mas largo a 5 "+ est.periodoMasLargo(3)); }

TempMinEstacion Computa la mayor amplitud térmica entre 2 días consecutivos, requiere que el período tenga al menos 2 días. float [] tMin <<consultas>> mayorAmplitud():real huboMayorAmplitud(t:real):boolean todasAmplitudesCrecientes():boolean Decide si hubo alguna amplitud térmica entre días consecutivos, mayor a t. Decide si todas las amplitudes térmicas entre días consecutivos son crecientes, requiere que el período tenga al menos 2 días. Establecer Casos de Prueba para cada servicio

Algoritmo mayorAmplitud Calcula la amplitud entre los días 1 y 2 Calcula la amplitud entre los días 2 y 3 Compara y elige la mayor Calcula la amplitud entre los días 3 y 4 Compara la última calculada con la mayor y elige la mayor Calcula la amplitud entre los días 4 y 5 Calcula la amplitud entre los días 5 y 6 Debemos refinar esta versión identificando las estructuras de control.

Algoritmo mayorAmplitud DS mayor mayor  calcula amplitud entre los días 1 y 2 para cada día a partir del segundo amplitud  calcula amplitud con el día siguiente si amplitud > mayor mayor  amplitud

public float mayorAmplitud(){ /*Computa la mayor amplitud térmica entre 2 días consecutivos, requiere que el período tenga al menos 2 días*/ float may=Math.abs(tMin[0]-tMin[1]); for (int i=1;i<cantDias()-1; i++) if (Math.abs(tMin[i]-tMin[i+1]) > may) may = Math.abs(tMin[i]-tMin[i+1]); return may; } Recorrido Exhaustivo

Algoritmo huboMayorAmplitud DE a para cada día del periodo y mientras NO se verifique la propiedad amplitud  calcula amplitud con el día siguiente si amplitud > a se verifica la propiedad Nuevamente la condición de corte de la iteración es muy general. El algoritmo en sí mismo es muy general, la estructura podría no ser un arreglo

public boolean huboMayorAmplitud(float t){ //Decide si hay una amplitud mayor a t boolean hubo= false; for (int i=0;i< cantDias()-1 && !hubo;i++) hubo = Math.abs(tMin[i]-tMin[i+1]) > t; return hubo; } Recorrido NO Exhaustivo

Algoritmo todasAmplitudesCrecientes amplitud  calcula amplitud entre el primer y el segundo día para cada par de días días del periodo a partir del segundo y mientras se verifique la propiedad a  calcula amplitud con el día siguiente si amplitud >= a NO se verifica la propiedad sino amplitud a

public boolean todasAmplitudesCrecientes(){ //Requiere un período de al menos 2 dias boolean todas= true; float a1=Math.abs(tMin[0]-tMin[1]); for (int i=1;i<cantDias()-1&&todas;i++){ float a2 = Math.abs(tMin[i]-tMin[i+1]); if (a1 >= a2) todas = false; a1 = a2; } return todas; Recorrido NO Exhaustivo

Requieren la misma cantidad de temperaturas en las dos estaciones TempMinEstacion float [] tMin Cuenta en cuántos días la diferencia absoluta entre las temperaturas de las dos estaciones es mayor a t <<consultas>> mayoresDiferencias (tme:TempMinEstacion, t:real ) : entero hayDiferenciaMayor (tme:TempMinEstacion, t: real) : boolean mayorDiferencia (tme:TempMinEstacion ) :real menorEntreEstaciones (tme:TempMinEstacion): TempMinEstacion Decide si en dos estaciones, en algún día, la diferencia absoluta entre temperaturas es mayor a t Computa la mayor diferencia absoluta entre dos estaciones, en el mismo día. Genera una estación con la menor temperatura mínima de cada día, entre dos estaciones dadas Reciben y/o retornan un objeto de la clase TempMinEstacion

//Comandos public void establecerTempMin(int dia, float t){ /*Requiere 1<=d<=cantDias() */ tMin[dia-1]=t; } // Consultas public float obtenerTempMin(int dia){ /*Requiere 1<=d<=cantDias() */ return tMin[dia-1]; }

6 12 -2 8 7.5 4.5 5 4 2 5 8.5 10 11 Si t = 5 mayorTempMin debe retornar 3 para cada día d del período t1 temperatura del día d de Estación 1 la estación que recibe el mensaje t2  temperatura del día d de Estación 2 la estación que pasa como parámetro si abs(t1-t2) > t contcont+1

6 12 -2 8 7.5 4.5 5 4 2 5 8.5 10 11 Si t = 5 mayorTempMin debe retornar 3 para cada día d del período t1 tMin[d] t2  tme.obtenerTempMin(d+1) si abs(t1-t2) > t contcont+1 tMin es un arreglo las componentes se acceden usando un subíndice. tme es un objeto de clase TempMinEstacion, las componentes se acceden con los servicios provistos por la clase

public int mayoresDiferencias(TempMinEstacion tme, float t ){ /*Cuenta en cuantos días la diferencia absoluta entre las temperaturas de las dos estaciones es mayor a t Requiere la misma cantidad de temperaturas en las dos estaciones*/ int cont = 0; float t1,t2; for (int d = 0; d<cantDias() ; d++){ t1 = tMin[d]; t2 = tme.obtenerTempMin(d+1); if(Math.abs(t1-t2)> t) cont++; } return cont; }

public int mayoresDiferencias(TempMinEstacion tme, float t ){ /*Cuenta en cuantos días la diferencia absoluta entre las temperaturas de las dos estaciones es mayor a t Requiere la misma cantidad de temperaturas en las dos estaciones */ int cont = 0; for (int d = 0; d<cantDias() ; d++) if(Math.abs(tMin[d]-tme.obtenerTempMin(d+1))>t) cont++; return cont; } Si la clase cliente no cumple con la responsabilidad de que las dos estaciones tengan la misma cantidad de elementos se va a producir un error de aplicación o de ejecución (si la cantidad de días de tme es menor que cantDias()).

class TestTempMinEstacion { public static void main(String[] args) { int cantD =0; cantD = leerCantDias () ; TempMinMaxEstacion estS,estN; estS = leerTempEst(cantD) ; estN = leerTempEst(cantD) ; System.out.println("Muestra la estación "); mostrarTempEst(estS) ; mostrarTempEst(estN) ; System.out.println(“Diferencias mayores a 5 = “ estS.mayoresDiferencias(estN,5) ); … }

estN 6 12 -2 8 7.5 4.5 tMin length 7 estS 5 4 2 5 8.5 10 11 tMin length 7

public boolean hayDiferenciaMayor(TempMinEstacion tme, float t ){ /*Decide si en dos estaciones en algún día la diferencia absoluta entre temperaturas es > t Requiere la misma cantidad de temperaturas en las dos estaciones */ boolean hay = false; for (int d = 0; d<cantDias() && !hay; d++) if(Math.abs(tMin[d]- tme.obtenerTempMin(d+1))> t) hay = true; return hay; } La clase Proveedora puede establecer una excepción para considerar el caso de que la clase Cliente no cumpla con su responsabilidad.

public float mayorDiferencia (TempMinEstacion tme){ /*Computa la mayor diferencia absoluta entre dos estaciones, en el mismo día asume que se registraron por lo menos dos días. Requiere la misma cantidad de temperaturas en las dos estaciones */ float mayor = 0; for (int d = 0; d<cantDias(); d++) if(Math.abs(tMin[d]-tme.obtenerTempMin(d+1))> mayor) mayor = Math.abs(tMin[d] tme.obtenerTempMin(d+1)); return mayor; }

public TempMinEstacion menorEntreEstaciones(TempMinEstacion tme){ /*Genera una Estación con la menor temperatura mínima de cada día entre dos estaciones dadas. Requiere la misma cantidad de temperaturas en las dos estaciones*/ TempMinEstacion tMenor = new TempMinEstacion(cantDias()); for (int d = 0; d<cantDias() ; d++) if(tMin[d]<tme.obtenerTempMin(d+1)) tMenor.establecerTempMin(d+1,tMin[d]); else tMenor.establecerTempMin (d+1,tme.obtenerTempMin(d+1)); return tMenor; }

Aunque la programación es una actividad creativa, la estrategia de reconocer la analogía entre problemas aparentemente diferentes, favorece el proceso de resolución. Hemos propuesto un conjunto de patrones de algoritmos que pueden usarse para hallar la solución de distintos problemas. Introducción a la Programación Orientada a Objetos

IPOO 2 cuatrimestre 2015 Departamento de Ciencias e Ingeniería

Presentaciones similares

Presentación del tema: "IPOO 2 cuatrimestre 2015 Departamento de Ciencias e Ingeniería"— Transcripción de la presentación:

Presentaciones similares

Sobre el proyecto

Feedback

Iniciar la sesión

Autorizarse a través de una red social:

IPOO 2 cuatrimestre 2015 Departamento de Ciencias e Ingeniería

Presentaciones similares

Presentación del tema: "IPOO 2 cuatrimestre 2015 Departamento de Ciencias e Ingeniería"— Transcripción de la presentación:

Presentaciones similares

Sobre el proyecto

Feedback