DEDA_U2_A2_JCM

Actividad 2. Identificación de errores en métodos de ordenación DEDA_U2_A2_JCM

Prof: Carmen Gómez Pérez Alumno: Javier Chávez Mociños

La siguiente actividad te permitirá identificar errores en la codificación de un caso práctico en el que se han utilizado métodos de ordenación. Caso: Patentes Las antiguas patentes (de automóviles), por ejemplo PL7812, están compuestas por un string de dos caracteres, en el ejemplo PL, y por un número entero de cuatro dígitos, en el ejemplo 7812. Suponga que exista una clase Patente y otra TablaDePatentes de la siguiente forma: public class Patente { private String letras ; private int numero ; public Patente () {} public String obtLetras () { return letras ; } public int obtNumero () { return numero ; } } public class TablaDePatentes { private String [] tabla ; public TablaDePatentes () { tabla = new String [9999]; } public boolean buscar (Patente patente ) {} otros métodos } La idea es que TablaDePatentes almacena en el atributo tabla todas las patentes autorizadas a estacionarse en el campus San Joaquín. En particular, si la patente PL7812 está autorizada, entonces tabla [7812] = ‘‘PL’’, y si la patente JK2345 está autorizada, entonces tabla [2345] = ‘‘JK’’. Además, si dos o más patentes autorizadas tienen el mismo número, entonces sus pares de letras aparecen consecutivamente en el string correspondiente de tabla. Por ejemplo, si las patentes PL7812 y MB7812 están autorizadas, entonces tabla [7812] = ‘‘PLMB’’; y si las patentes JK2345, RC2345 y DW2345 están todas autorizadas, entonces tabla [2345] = ‘‘JKRCDW’’. Escriba el método buscar de la clase TablaDePatentes, que busca rápidamente la Patente en el atributo tabla, y devuelve true (verdadero) si patente está en tabla, y false (falso) en caso contrario. Criterios de solución: Lo primero que tenemos que hacer es declarar el método como nos indican en el enunciado. Luego, con los métodos de la clase Patente, obtenemos las letras y los números que la componen. Con el número de la patente obtenemos lo almacenado en el arreglo y luego debemos recorrer este string obteniendo substring de largo 2 e ir comparando cada substring con las letras de la patente a buscar. Si coincide con alguno retornamos true, de lo contrario retornamos false. Posible solución: public boolean buscar (Patente patente ) { int num = patente. obtNumero (); String letras = patente . obtLetras (); String validas = tabla [ num ]; if( validas != null ){ int largo = validas . length (); int k = 1; while (k < largo ) { if ( letras . equals ( validas . substring (k - 1, k + 1))) return true; k = k + 2; } } return false ; }

Ahora: 1. Crea un proyecto nuevo en NetBeans. 2. Transcribe el código que se encuentra líneas arriba. 3. Identifica los errores en el código. 4. Con comentarios (// o /*, */) documenta los errores encontrados y realiza las correcciones necesarias para que el programa pueda funcionar correctamente. 5. Una vez corregido el código, ejecuta el programa. 6. Si la ejecución ha sido correcta guarda el archivo con los comentarios realizados. 7. Documenta el código explicando de forma breve pero concisa las partes del mismo donde se ha empleado algún método de ordenación, señala de forma puntual qué método de ordenación se ha empleado y por qué.

public class Patente { private String letras; private int numero; public Patente(String letra, int num) { //Creamos el constructor pasandole como parametros las letras y numeros this.letras = letra; this.numero = num; } public String obtLetras() { return this.letras; } public int obtNumero() { return this.numero; } } Aqui te faltaba un getTabla para trabajar con ella desde otra clase public class TablaDePatentes { private Patente[] tabla;

public TablaDePatentes() { tabla = new Patente[2]; //Hacemos el array de tamaño 2 para no volvernos locos. No es muy eficiente hacer un array de 9999 posiciones como tenias } public Patente[] getTabla(){ return this.tabla; } /** * */ public boolean buscar(Patente patente) {

int num = patente.obtNumero(); String letras = patente.obtLetras(); boolean encontrado = false; int len = tabla.length; for (int i = 0; i < tabla.length && encontrado == false; i++) { //El bucle seguira iterando hasta que acabe la tabla o hasta que encontrado == true. if (tabla[i].obtLetras().equals(letras)) { //Comparamos las dos primeras posiciones del resultado de la tabla que coincida con las letras if (tabla[i].obtNumero()==num) { //Comparamos las 3 ultimas posiciones del resultado de la tabla que coincida con las letras encontrado = true; //Al encontrarlo, encontrado == true por lo tanto sale del bucle y retorna el encontrado==true, si este caso nunca se da retornata encontrado == false; } } } return encontrado; } } Y una clase PRINCIPAL public class Principal { /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub Patente patente = new Patente("PV", 1415); //Creamos una patente con los siguientes datos Patente patente2 = new Patente("HM", 1515); //Lo mismo de arriba TablaDePatentes ClaseTablaPatente = new TablaDePatentes(); //Creamos algo de tipo TablaDePatentes Patente[] tabla = ClaseTablaPatente.getTabla(); //Hacemos uso del getTable() que te comentado antes para trabajar con el array Patente[ ] tabla[0] = patente; //Añadimos las patentes creadas mas arriba tabla[1] = patente2; //Lo mismo Patente patenteParaBuscarTRUE = new Patente("PV", 1415); //Creamos una patente que buscaremos que dara TRUE al ser igual que la primera creada Patente patenteParaBuscarFALSE = new Patente("SP", 1111); //Creamos otra patente que buscaremos que dara FALSE al no existir arriba System.out.println(ClaseTablaPatente.buscar(patenteParaBuscarTRUE)); //Hacemos uso del metodo buscar con la patente que devolvera true System.out.println(ClaseTablaPatente.buscar(patenteParaBuscarFALSE)); //Y lo mismo para la de false. } }