Universidad Carlos III de Madrid

When initializing an array you have to set its size. This is especially useful when you have to handle a fixed structure that will not vary in size over time, reducing its complexity and access time, and optimizing the available memory. If you need a structure with variable size over time (see for example stacks or queues), it is feasible to implement it with arrays; however, it increases complexity, and sometimes it's better to use a more flexible structure.

Encapsulating a class facilitates its cohesion and its reuse. It is important what it's doing, which its behaviour is (through its methods); however, it doesn't matter how the class actually does these issues.

Notice that it does not initialize the result variable properly. Even though the result variable is set to a value for each situation, if animal.isClassified() returns false, the method will try to return a variable that is not initialized. Remember to declare and initialize all variables.

The problem is on the scope of the result variable. Remember that the scope of variables, parameters and classes are tied to the limits set by the braces (), methods and class identifiers, respectively.

A derived class not only inherits an interface, but also a structure and behaviour. For this reason, it's essential to initialize it properly. To ensure this behaviour, the derived class has to call to the constructor of the base class, since it has the skills to successfully initialize the object.

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

class Carnivore extends Animal{
 String foodHabits;
 Carnivore (String type, String habits){
  super(type);	
  this.foodHabits = habits;}	
}
					

This technique is quite usual, and allows you to easily implement a design following a methodology and reducing the level of errors (starting from a revised base object, you can only make errors in the added functionality). Try it.

By now you probably know the advantages of the inheritance mechanisms such as this, super and cast. But if you have a base class and you are trying to classify it in a specific child class (e.g. making a specific and unique call to the child class) you need to use the instanceOf method. Consider an example with the classes Animal, Carnivore, Herbivore y Omnivore.

						
Animal animal = nextAnimal();
if (animal instanceOf Carnivore){
 Carnivore carnivore = (Carnivore) animal;
 String[] preys = carnivore.favoritePreys();	
}						
					

This way the constants cannot be modified and remain unambiguous. Remember the characteristics of these identifiers. The final identifier prevents a variable from being overwritten. The static identifier avoids the generation of a new variable for each new instance of the object. A constant.

This is possible because Java is able to identify unique lists of types in their arguments. Although the method identifier and the result (if applicable) are the same, if Java identifies unique lists of types in its arguments (and not just different types, but also the order of them) it's able to refer the method appropriately.

Indeed, imagine the class Dog. A dog with a disease could not have access to meat, then you can consider a class HerbivoreDog that inherits its behavior from Dog. You can override the isCarnivore() method to fit your needs in that circumstance. You can also include an overloaded isCarnivore(state) method that considers the dog is recovered and can eat meat again.

The composition simply consists on creating an object from other existing objects as a structural part of it. A Classroom object are composed of an array of Pupil objects and a Professor object. Inheritance is based on identifying a new class as a specific variety or type from an existing class. For example, from the Person class, you can develop the Pupil and Professor classes.

The simplest way is asking yourself if the new object is a type of an already existing object(inheritance) or is composed by others; in this latest case, we have a composition.
For further help to differentiate and choose the suitable technique in each case, you can consider whether in the reusable classes you are more interested in preserving their original interface (inheritance) or not (composition). As an interface of Pupil and Professor classes, it could be interesting keeping the original methods of the class Person, such as name(), age() or occupation(), and design the specifics methods of the new type subsequently. But it seems logical to think that, for example, Classroom interface is formed with methods such as pupilsNumber (), pupilID(String pupilName) or passingMean() using the methods of the classes involved, but not using the original interface.

Each one of these techniques provides an implementation methodology to translate the conceptual ideas that a conceptual design suggests. Inheritance allows us to develop a set of new concepts from from an idea (base class) clearly defined. The abstraction goes further, facilitating handling of more general ideas without the need to define them (for convenience or necessity) until we have reached a higher level of specification that fits our needs. Finally, in the design of an interface, the prevailing idea is to define a specific and public behaviour, without the need to model it in more detail, that satisfies our requirements and then implement it with one (or several) class designed for that purpose.

One of the main features of abstract classes is that they can not be instantiated. In addition, the static identifier applied to a variable prevents the creation of an instance for each instance of the class. However, you have to be very careful using this kind of variables, because their non-instantiable condition makes their scope very large. Imagine their scope with a public condition; it will be shared and, what is worse, modified by many objects. As result, it's difficult to estimate what may be their value in a specific situation.

As you know, the object orientation is based on the definition of entities with characteristics and behaviors that operate and exchange information between them. This is a very modular design that facilitates the division of tasks. However, when the complexity of the design increases (many classes, overloaded methods, complex relationships, etc.), a good initiative is to dedicate the time to design and implement studied interfaces that specify in detail the interaction between the different classes to reduce the chance of error, not just at functional level (I need this information to perform this operation), but also at the operational level (I need this information, in this format, to perform this operation).

Notice that one of the conditions for a class to implement an interface is that it has to implement all its methods and, in this case, one of them is abstract (and is not implemented). However, since an interface is simply a class where all methods are abstract and it's allowed that interfaces inherit from another, it's logical that the code above is feasible (if the method is implemented later).

The cost of identifying and solving a problem in the implementation phase involves not only making modifications and reviewing all the code already done but, in many cases, the inclusion of "patches", the modification of dependent methods and public interfaces, behaviours, etc. And don't forget that "patches" and late code hide new bugs and new "patches".

The use of interfaces allows polymorphism using the keyword implements and various interfaces to be implemented followed by a comma, but notice that in this case, the methods readNextBlock are misleading because they have the same name, type and number of parameters, but not the same behaviour. It will cause an error. Pay attention and try to use explicit identifiers.

Notice that when the condition of equality is true (the name of the subject), the counter that runs through the array does not increase, and therefore will access the same component continuously, causing an infinite loop. Remember that, unlike the for loop, updating the counter in the while loop is not implicit. Pay attention to the stop condition of a loop.

Notice that in this case, the use of an if splits the flow of the operation improperly. The else branch has consequences; be sure when you use it.

		
boolean multiple2 = false;
boolean multiple3= false;
if (value%2==0){
 multiple2=true;	
}
if (value%3==0){
 multiple3=true;		
}