Introducción a la Programación Orientada a Objetos Sonia Rueda Genericidad IPOO 2 cuatrimestre 2018 Departamento de Ciencias e Ingeniería de la Computación UNIVERSIDAD NACIONAL DEL SUR 2018

Genericidad Matriz Elemento [] [] m <<constructor>> Matriz (fMax,cMax : entero) <<comandos>> establecerElem (f,c : entero, elem : Elemento ) invertirFilas(f1,f2:entero) establecerElem (f,c : entero, elem : Elemento) Asume que la posición es válida invertirFilas(f1,f2:entero) Intercambia mf1,j por mf2,j Para 0<=j<NCol Asume que se verificó que f1 y f2 son válidas

Genericidad Matriz Elemento [] [] m <<consultas>> existePos(f,c : entero) : boolean hayNulos():boolean obtenerNFil () : entero obtenerNCol () : entero obtenerElem (f,c : entero) : Elemento equals(mp:Matriz): boolean todosNeutros():boolean equals(mp:Matriz):boolean Compara en profundidad todosNeutros():boolean Retorna verdadero sí y solo sí cada elemento cumple la propiedad esNeutro Todos los recorridos requieren que todas las componentes estén ligadas.

Genericidad class Matriz{ protected Elemento [][] m; public Matriz(int fMax,int cMax){ m = new Elemento [fMax][cMax]; } Matriz encapsula a una estructura genérica, los elementos del arreglo m pueden ser instancias de cualquier clase concreta que extienda a la clase Elemento.

Genericidad invertirFilas(1,3); Toda las componentes de la matriz son de un mismo tipo, pueden ser objetos de clase Racional, o Robot o cualquier otra clase. Usamos los colores para diseñar el algoritmo.

Genericidad Planteo Recursivo Caso trivial? invertirFilas(1,3);

Genericidad Planteo Recursivo invertirFilas(1,3); Caso trivial en una matriz con una única columna se intercambian los elementos de las filas 1 y 3 m[1,0] ↔ m[3,0] invertirFilas(1,3);

Genericidad Planteo Recursivo invertirFilasAux(1,3,col); Caso trivial en una matriz con una única columna se intercambian los elementos de las filas 1 y 3 m[1,0] ↔ m[3,0] invertirFilasAux(1,3,col); La implementación recursiva requiere un parámetro adicional que indique la cantidad de columnas

Generalizando el caso trivial Genericidad Algoritmo Recursivo Caso trivial si col es 0 Intercambiar m[f1,0] y m[f2,0] invertirFilasAux(f1,f2,col); Generalizando el caso trivial

Genericidad Algoritmo Recursivo invertirFilasAux(f1,f2,col); Caso trivial si col es 0 Intercambiar m[f1,0] y m[f2,0] Caso recursivo Intercambiar m[f1,col] y m[f2,col] invertirFilasAux(f1,f2,col-1) invertirFilasAux(f1,f2,col);

Genericidad Algoritmo Recursivo invertirFilasAux(f1,f2,col); Caso trivial si col es 0 Intercambiar m[f1,0] y m[f2,0] Caso recursivo Intercambiar m[f1,col] y m[f2,col] invertirFilasAux(f1,f2,col-1) invertirFilasAux(f1,f2,col);

Genericidad Algoritmo Recursivo invertirFilasAux(f1,f2,col); Caso trivial si col es 0 Intercambiar m[f1,0] y m[f2,0] Caso recursivo Intercambiar m[f1,col] y m[f2,col] invertirFilasAux(f1,f2,col-1) col = 3 invertirFilasAux(f1,f2,col);

Genericidad Algoritmo Recursivo invertirFilasAux(f1,f2,col); Caso trivial si col es 0 Intercambiar m[f1,0] y m[f2,0] Caso recursivo Intercambiar m[f1,col] y m[f2,col] invertirFilasAux(f1,f2,col-1) col = 2 invertirFilasAux(f1,f2,col);

Genericidad Algoritmo Recursivo invertirFilasAux(f1,f2,col); Caso trivial si col es 0 Intercambiar m[f1,0] y m[f2,0] Caso recursivo Intercambiar m[f1,col] y m[f2,col] invertirFilasAux(f1,f2,col-1) col = 2 invertirFilasAux(f1,f2,col);

Genericidad Algoritmo Recursivo invertirFilasAux(f1,f2,col); Caso trivial si col es 0 Intercambiar m[f1,0] y m[f2,0] Caso recursivo Intercambiar m[f1,col] y m[f2,col] invertirFilasAux(f1,f2,col-1) col = 1 invertirFilasAux(f1,f2,col);

Genericidad Algoritmo Recursivo invertirFilasAux(f1,f2,col); Caso trivial si col es 0 Intercambiar m[f1,0] y m[f2,0] Caso recursivo Intercambiar m[f1,col] y m[f2,col] invertirFilasAux(f1,f2,col-1) col = 1 invertirFilasAux(f1,f2,col);

Genericidad Algoritmo Recursivo invertirFilasAux(f1,f2,col); Caso trivial si col es 0 Intercambiar m[f1,0] y m[f2,0] Caso recursivo Intercambiar m[f1,col] y m[f2,col] invertirFilasAux(f1,f2,col-1) col = 0 invertirFilasAux(f1,f2,col);

Genericidad Algoritmo Recursivo invertirFilasAux(f1,f2,col); Caso trivial si col es 0 Intercambiar m[f1,0] y m[f2,0] Caso recursivo Intercambiar m[f1,col] y m[f2,col] invertirFilasAux(f1,f2,col-1) col = 0 invertirFilasAux(f1,f2,col);

Genericidad public void invertirFilas (int f1,int f2){ invertirFilasAux (f1,f2,obtenerNCol()-1); } private void invertirFilasAux(int f1,int f2, int col){ if (c>=0){ intercambiar(f1,f2,col); invertirFilasAux (f1,f2,col-1); private void intercambiar(int f1,int f2, int col){ Elemento e = m[f1][col]; m[f1][col] = m[f2][col]; m[f2][col] = e;

Genericidad public boolean equals (Matriz mat){ boolean iguales=true; for (int f=0;f<obtenerNFil()&& iguales;f++) for (int c=0;c<obtenerNCol()&&iguales;c++) iguales= m[f][c].equals(mat.obtenerElem(f,c)); return iguales; }

Genericidad public boolean todosNeutros (){ boolean todos=true; for (int f=0;f<obtenerNFil()&&todos;f++) for (int c=0;c<obtenerNCol()&&todos;c++) todos = m[f][c].esNeutro(); return todos; }

Genericidad public boolean todosNeutros (){ return todosNeu (obtenerNFil()-1); } private boolean todosNeu(int f){ boolean es = true; if (f>=0) es = filaNeutros(f,obtenerNCol()-1) && todosNeu (f-1); return es; private boolean filaNeutros(int f,int c){ if (c>=0) es = m[f][c].esNeutro() && filaNeutros(f,c-1);

Genericidad abstract class Elemento { abstract public boolean esNeutro(); abstract public boolean equals(Elemento e); } class Pixel extends Elemento { private int r,b,g; … public boolean esNeutro(){ return r==b& b==g; public boolean equals (Elemento e) { Pixel p = (Pixel) e; return r==p.obtenerR()& b == p.obtenerB() & g==p.obtenerG(); public boolean esRojo () { return r!=0& b==0 & g==0;

Genericidad abstract class Elemento { abstract public boolean esNeutro(); abstract public boolean equals(Elemento e); } class Racional extends Elemento { private int num,den; … public boolean esNeutro(){ return num==0; public boolean equals (Elemento e) { public Racional suma (Racional R) {

Genericidad public boolean todosNeutros (){ boolean todos=true; for (int f=0;f<obtenerNFil()&&todos;f++) for (int c=0;c<obtenerNCol()&&todos;c++) todos = m[f][c].esNeutro(); return todos; } La matriz es genérica porque la implementación de las operaciones como todosNeutros no depende del tipo de las componentes, no significa que las componentes pueden ser de cualquier tipo.

Genericidad Error de compilación public boolean todosNeutros (){ for (int f=0;f<obtenerNFil()&&todos;f++) for (int c=0;c<obtenerNCol()&&todos;c++) todos = m[f][c].esNeutro(); return todos; } Error de compilación

Genericidad Si la matriz contiene componentes nulas o no ligadas public boolean todosNeutros (){ boolean todos=true; for (int f=0;f<=obtenerNFil()&&todos;f++) for (int c=0;c<obtenerNCol()&&todos;c++) todos = m[f][c].esNeutro(); return todos; } Si la matriz contiene componentes nulas o no ligadas Error de ejecución

Genericidad Matriz Elemento [] [] m <<constructor>> establecerElem (f,c : entero, elem : Elemento) Asume que la posición es válida <<constructor>> Matriz (fMax,cMax : entero) <<comandos>> establecerElem (f,c : entero, elem : Elemento ) ordenarCreciente() ordenarCreciente() Reacomoda las filas de modo que los elementos de la primera columna queden ordenados de manera creciente

Genericidad

Genericidad Buscar el menor elemento de la primera columna. Intercambiar la fila con el menor elemento en la primera columna, con la primera fila La primera fila ya está acomodada

Genericidad Buscar el menor elemento de la primera columna, a partir de la segunda fila. Intercambiar la fila con el menor elemento en la primera columna, con la segunda fila La segunda fila ya está acomodada

Genericidad public void ordenarCreciente(){ Elemento mayor= null; for (int f1=0;f<obtenerNFil()-1;f1++){ mayor = f1; for (int f2=f1+1;f<obtenerNFil();f2++) if (m[f2][0].esMayor(m[mayor][0]) mayor = f2; intercambiar (f1,mayor,0); }

Genericidad abstract class Elemento { abstract public boolean esNeutro(); abstract public boolean equals(Elemento e); abstract public boolean esMayor(Elemento e); }

Genericidad Imagen Matriz Elemento [] [] m <<Constructor>> Imagen (nf,nc:entero) <<consultas>> tieneRojo():boolean <<constructor>> Matriz (fMax,cMax : entero) <<comandos>> Todos los recorridos requieren que todas las componentes estén ligadas. Todos los recorridos requieren que todas las componentes estén ligadas.

Genericidad Pixel p=(Pixel)m[f][c]; tiene = p.esRojo(); class Imagen extends Matriz{ public Imagen (int nf, int nc){ super (nf,nc); } public boolean tieneRojo(){ boolean tiene = false; for (int f=0;c<obtenerNFil()&&!tiene;f++){ for (int c=0;c<obtenerNCol()&&!tiene;c++){ Pixel p=(Pixel)m[f][c]; tiene = p.esRojo(); return tiene;

Genericidad Error de ejecución Pixel p=(Pixel)m[f][c]; class testImagen { … Imagen im= new Imagen (2,30); Pixel p1 = new Pixel(100,0,0); Racional p2 = new Racional(1,2); for (int j=0;j<30;j++) im.establecerElem(0,j,p1); for (int j=0;j<30;j++) im.establecerElem(1,j,p2); boolean pixelRojo = im.tieneRojo(); Pixel p=(Pixel)m[f][c]; tiene = p.esRojo(); Error de ejecución

establecerElem hayNulos equals todosNeutros *equals *esNulo *esNeutro Matriz *Elemento equals esNulo esNeutro esRojo IPOO 2 cuatrimestre 2018 Imagen Pixel tieneRojo

Genericidad MatrizRacionales Matriz Elemento [] [] m <<Constructor>> MatrizRacionales (nf,nc:entero) <<consultas>> sumaFila(f:entero):Racional <<constructor>> Matriz (fMax,cMax : entero) <<comandos>> Todos los recorridos requieren que todas las componentes estén ligadas. Todos los recorridos requieren que todas las componentes estén ligadas.

Genericidad Racional r2=(Racional)m[f][c]; r1.suma(r2); class MatrizRacionales extends Matriz{ public MatrizRacionales (int nf, int nc){ super (nf,nc); } public Racional sumaFila (int f){ Racional r1=new Racional (0,0); for (int c=0;c<obtenerNCol();c++){ Racional r2=(Racional)m[f][c]; r1.suma(r2); return r1;

establecerElem hayNulos equals todosNeutros *equals *esNulo *esNeutro Matriz *Elemento equals esNulo esNeutro suma IPOO 2 cuatrimestre 2018 MatrizRacionales Racional sumaFila

Genericidad Error de ejecución class testMatrizRacionales { … MatrizRacionales mrac= new MatrizRacionales(2,3); Pixel p1 = new Pixel(100,120,100); Racional p2 = new Racional(1,2); for (int j=0;j<3;j++) mrac.establecerElem(0,j,p1); for (int j=0;j<3;j++) mrac.establecerElem(1,j,p2); Racional suma = mrac.sumaFila (0); Error de ejecución

Genericidad Racional r2=(Racional)m[f][c]; r1.suma(r2);} class MatrizRacionales extends Matriz{ public MatrizRacionales (int nf, int nc){ super (nf,nc); } public Racional sumaFila (int f){ Racional r1=new Racional (0,0); for (int c=0;c<obtenerNCol();c++){ if m[f][c] instanceOf Racional{ Racional r2=(Racional)m[f][c]; r1.suma(r2);} return r1;

Genericidad Error de aplicación class testMatrizRacionales { … MatrizRacionales mrac= new MatrizRacionales(2,3); Pixel p1 = new Pixel(100,120,100); Racional p2 = new Racional(1,2); for (int j=0;j<3;j++) mrac.establecerElem(0,j,p1); for (int j=0;j<3;j++) mrac.establecerElem(1,j,p2); Racional suma = mrac.sumaFila (0); Error de aplicación Evitar el error de ejecución no es una ventaja si el error de aplicación persiste y pasa desapercibido