Universidad Carlos III de Madrid

Como ya sabes, al inicializar un array debes fijar su dimensión. Esto es especialmente práctico cuando se va a manejar una estructura fija que no va a variar de tamaño con el tiempo, reduciendo su complejidad y tiempo de acceso y optimizando la memoria disponible. Si se trata de una estructura con dimensión variable en el tiempo (véase por ejemplo pilas o colas), si bien es viable implementarlas con arrays, su complejidad es mayor y a veces conviene sacrificarlas por una estructura más manejable.

Encapsular una clase, facilita la cohesión de la misma y su reutilización. Nos importa qué hace, cuál es su comportamiento (a través de sus métodos) y no como lo hace.

Observa que no se inicializa adecuadamente la variable resultado. Aunque parece que la variable resultado toma un valor para cada situación posible, caso que animal.estaClasificado() devuelva false, el método tratará de devolver una variable no inicializada. Recuerda declarar e inicializar todas las variables.

El problema está en el ámbito de resultado. Recuerda que el ámbito de variables, parámetros y clases viene ligado a los límites que fijan las llaves {}, los métodos y los identificadores de clase respectivamente.

Una clase derivada no sólo hereda una interfaz, sino también una estructura y un comportamiento. Por ese motivo es fundamental que se inicialice correctamente. Para garantizar ese comportamiento, se realiza una llamada al constructor de la clase base puesto que este posee los conocimientos para inicializar el objeto satisfactoriamente.

		
class Animal{
 String tipo;
 Animal (String tipo){this.tipo=tipo;}}

class Carnivoro extends Animal{
 String habitosAlimenticios;
 Carnivoro (String tipo, String habitos){
  super(tipo);	
  this. habitosAlimenticios = habitos;}}
					

Se trata de una técnica bastante usual y que te permite fácilmente implementar un diseño siguiendo una metodología y reduciendo el ámbito de errores (partes de un objeto base revisado y sólo hay posibilidad de incorporar errores sobre la funcionalidad añadida). Compruébalo.

A estas alturas probablemente conozcas las bondades de los mecanismos de herencia this, super y cast. Pero cuando partes de la clase base y quieres ubicarla en una clase hija específica (como por ejemplo para realizar una llamada concreta y única de la susodicha clase hija) necesitas emplear el método instanceOf. Veamos un ejemplo con las clases Animal, Carnívoro, Herbívoro y Omnívoro.

							
Animal animal = nextAnimal();
if (animal instanceOf Carnivoro){
 Carnivoro carnivoro = (Carnivoro) animal;	
 String[] presas = carnivoro.presasFavoritas();	
}						
					

De esta manera las constantes se convierten en unívocas y se evita que puedan ser modificadas. Recuerda las características de dichos identificadores. El identificador final confiere a una variable la propiedad de no permitir que sea sobreescrita. El identificador static que no se genere una nueva variable por cada instancia nueva del objeto.

Esto es así porque es capaz de es capaz de identificar listas únicas de tipos en sus argumentos. Aunque el identificador del método y el resultado (si procede) sean el mismo, si identifica listas únicas de tipos en sus argumentos (y no sólo son importantes tipos distintos, sino también el orden de los mismos) es capaz de referenciar adecuadamente el método.

Efectivamente, supongamos la clase Perro. Un perro tratado de una enfermedad puede tener el acceso prohibido a la carne, luego entonces puedes considerar una clase PerroHerbívoro que herede de Perro en su comportamiento, pero que sobreescriba el método esCarnivoro() para que satisfaga tus necesidades en esa circunstancia. Pero a su vez, puedes incluir un método sobrecargado esCarnivoro(estado), que considere la posibilidad de que el perro está recuperado y pueda comer de nuevo carne.

La composición consiste simplemente en crear un objeto a partir de otros ya existentes como parte estructural del primero. Un objeto Clase se compone de un array de objetos Alumno y un objeto Profesor. La herencia se basa en identificar una nueva clase como una variedad o tipo específico (es un/una) de una clase ya existente, por ejemplo, a partir de la clase Persona puedes desarrollar las clases Alumno y Profesor.

El método más sencillo es preguntarte si el nuevo objeto es un tipo de otro ya existente (herencia) o si más bien se compone de otro (u otros), en cuyo caso hablamos de composición.
Como ayuda extra para diferenciar y elegir en cada caso qué técnica emplear, puede orientarte el considerar si de las clases a reutilizar estás más interesado en conservar la interfaz (métodos públicos de una clase) original de las mismas (herencia) o no (composición). Como interfaz de las clases Alumno y Profesor puede interesarte mantener métodos originales de la clase Persona tales como nombre(), edad() u ocupacion() y a posteriori diseñar los característicos y específicos del nuevo tipo. Sin embargo parece lógico pensar que para el ejemplo Clase, su interfaz se constituirá de métodos tales como numeroAlumnos(), numeroMatricula(String nombreAlumno) o mediaAprobados(), que emplearán los métodos de las clases involucradas, pero no respetarán la interfaz original de los mismos.

Así es, cada una de ellas nos proporciona una metodología de implementación para plasmar las ideas conceptuales que nos sugiere un diseño. La herencia nos permite desarrollar a partir de una idea (clase base) perfectamente definida una serie de nuevos conceptos derivados de la anterior. La abstracción va más allá, facilitando el manejo de ideas más generales sin necesidad de definirlas (por conveniencia o necesidad) hasta que no hayamos alcanzado un nivel de especialización o especificación más tangible que se adecúe a nuestras necesidades. Por último, en cuanto al diseño de una interfaz, la idea que prevalece es definir un comportamiento específico y público, sin necesidad de modelarlo con más detalle, que satisfaga nuestros requisitos y que posteriormente implementaremos con una (o varias) clase diseñada a tal efecto.

Una de las características principales de las clases abstractas es que no pueden ser instanciadas. Por otro lado el identificador static aplicado a una variable impide que se cree una instancia de esta por cada instancia de la clase. Como ves son tal para cual. Sin embargo debes emplear sumo cuidado en el uso de este tipo de variables, pues por su condición de no instanciables su ámbito puede ser muy extenso (imagina su alcance con un identificador public). Es compartida, y lo que es peor, modificable, por cuantiosos objetos. Como consecuencia, será difícilmente calculable cual puede ser su valor en una situación concreta.

Como sabes, la orientación a objetos se fundamenta en la definición de entidades con características y comportamientos propios que intercambian información y operan entre ellas. Como ves, se trata de un diseño bastante modular de por sí que facilita la división de trabajo. Sin embargo, cuando la complejidad del diseño aumenta (multitud de clases, sobrecarga de métodos, relaciones complejas), una buena iniciativa consistiría en dedicar todo el tiempo que sea necesario en fijar, diseñar e implementar estudiadas interfaces que especifiquen con detalle la interacción entre las distintas clases para reducir las posibilidades de error, y no sólo a nivel funcional (necesito esta información para realizar esta operación), sino también a nivel operativo (necesito esta información, en este formato, para realizar esta operación).

Observa que una de las condiciones para que una clase implemente un interfaz es que implemente todos los métodos de esta y en este caso concreto uno de ellos es abstracto (y no se halla implementado), sin embargo, puesto que una interfaz no es más que un caso concreto de una clase donde todos los métodos son abstractos y se permite que interfaces hereden unas a otras, es lógico que el código anterior sea factible (siempre y cuando posteriormente el método sea implementado)

El coste de identificar y resolver un problema en la fase de implementación no sólo implica efectuar la modificación puntual y revisar todo el código ya realizado, sino que en muchos casos conlleva incluir "parches", modificar métodos e interfaces públicas, comportamientos y no olvides que los "parches" y el código de última hora a su vez ocultan nuevos errores y nuevos "parches".

El uso de interfaces permite polimorfismo empleando la palabra reservada implements y los distintos interfaces a implementar seguidos de comas, pero observa que en este caso concreto, el método leerSigBloque es equívoco pues coincide en identificador de método, tipo y número de parámetros, pero no así en comportamiento. Provocaría un error. Presta atención y procura emplear identificadores explícitos.

Observa que cuando se cumple la condición de igualdad (el nombre de la asignatura) no se incrementa el contador que recorre el array y por tanto se accederá continuamente al mismo componente, provocando un bucle infinito. Recuerda que a diferencia del bucle for, en el bucle while la actualización del contador no es implícita. Presta atención a la condición de parada de un bucle.

Observa que en este caso concreto, el empleo de una sentencia if bifurca inadecuadamente el flujo de la operación. La rama else tiene sus consecuencias, asegúrate cuando la emplees.

								
boolean multiplo2 = false;
boolean multiplo3= false;
if (valor%2==0){
 multiplo2=true;	
}
if (valor%3==0){
 multiplo3=true;		
}