Bueno, en principio para muchos de nosotros (los repetidores…) la herencia nos parece fácil…”el hijo tiene todos los atributos del padre”,ya que tenemos la ventaja de haberlo estudiado en RDA; pero en algunas aplicaciones hay un poco más de tela…..
Ejercicio 1
Suponemos que no hay mucho que contar en este apartado, ya que es implementar el constructor y en el método toString() retornar una sentencia (recordar que para los modificadores hay que hacerlos como la práctica anterior).
- ¿Qué pasaría si se cambiara protected por private en nuestra jerarquía de clases?
Para los que no sabian responder esta pregunta, si se cambia protected por private, las clases derivadas de esta, solo podrían acceder a sus atributos a tráves de sus métodos de acceso y no se heredaría.
Ejercicio 2
Este ejercicio es igual que el anterior con la unica diferencia que hereda de la clase Miembro, y hereda sus atributos. A la hora de crear el constructor, debemos llamar a los atributos heredados mediante super, y a los parámetros propios de la clase, llamarlos normalmente(this.).
Ejercicio 3
Para los que estuvieron en el grupo de Alberto Cortes, nos explicaron para que servía StringBuffer().
StringBuffer ret=new StringBuffer();
ret.append(” TIPO = “+ tipo);
return ret.toString();
Todo este código puede ser reemplazado por:
return “TIPO = “+tipo;
como lo hemos hecho en los apartados anteriores.
- ¿Para que sirve entonces StringBuffer?
A nivel usuario, hace lo mismo que poner lo explicado anteriormente, pero a nivel computacional, cuando tiene que concatenar 2 Strings, no los suma, sino que crea un tercer String del tamaño total de la suma de los 2 anteriores, y los añade… por lo que al compilar, la máquina tarda más.
Lo que hace StringBuffer es crear un String variable de tamaño, por lo que al concatenar Strings, este se hace más grande y añade el siguiente… por lo que la máquina tarda menos en compilar y no crea Strings adicionales.
La clase método se realiza igual que la clase Atributo, solo que en toString() hay que añadir un for e ir metiendo todos los parametros. (Creemos conveniente utilizar el StringBuffer aquí, que existen muchas concatenaciones). Nosotras lo hemos hecho asi para quienes os sirva:
public String toString() {
StringBuffer ret = new StringBuffer();
ret.append(“Nombre: “+nombre+”, Modificador: “+Modificador.toString(modificadores)+”Tipo Retorno”+tipoRetorno);
if (parametros != null)
for(int i =0;i<parametros.length;i++)
ret.append(“Parametro “+i+ “: “+parametros[i]);
return ret.toString();
}
Ejercicio 4
La clase Constructor hereda de Método, según se nos da en el enunciado. Pero nos encontramos con un problema, Constructor no tiene tipoRetorno, por lo que a la hora de heredarlo, tendríamos que añadir “” en el espacio que corresponde a tipoRetorno de la clase Metodo.
Alberto nos ha recomendado que no hagamos esto porque a parte de que requiere más trabajo, un constructor no es un método (suena mal) y lo ideal, es que Constructor herede de Miembro aunque sea redundante.
Se haría como la clase Metodo pero sin tipoRetorno.
Ejercicio 5
Esta clase hereda de la clase Object. Es de la que heredan todas por defecto cuando el usuario no especifica de que clase se hereda. (Se explicó en clase)
Este ejercicio no nos ha dado tiempo a terminarlo, no porque sea extenso, sino porque hay que entender bien el código haciendo uso del API, para poder entender para que servía cada método.
Nos encontramos con cosas “extrañas” como esta: o.getClass().getName() ; (que quiere decir, que el objeto “o”, el nombre (get.Name()) de la clase donde nos encontramos(getClass())… y asi todos… que nos ha llevado su tiempo descifrarlo…), aún así no podemos decir mucho porque no estamos muy seguras…
