OO design & Java Fundamental Period

Summary of the last lectures

We know how to :

Design and create classes
Define properties and methods for those classes
Control the flow of our program and repeat statements

We saw basic (default) constructors , and how to call it through a java code to create new instances

How to construct complex objects? How to take advantages of the inheritance mechanism? What is the Abstraction concept

Constructors : recall

Definition
A constructor is a dedicated mechanism that is necessary to construct the object. The mechanism of using a constructor to build a new instance is called instantiation
Parameters
The constructor can take parameters, like a method, to initialize the current instance with a particular value

Constructors : schema

package fr.tbr.exercises;

/**
 * Example of a car, constructor with
 * a "color" parameter
 * @author Tom
 */
public class Car {
	private String color;

	public Car(String color) {
		this.color = color;
	}

}

Class vs Instance

Notice in the previous example the this keyword.
this allows to access to the current instance values
An instance is a representation with some particular values of the class, Examples:
- A blue car is a representation of the class Car
- You are representations of the Human class.
  The class Human, is describing the shape of each Human. You are a specific representation (with your own characteristics) of this class

Class vs Instance (2)

The this keyword can be used in any non-static methods

Example: interest calculation in the bank account system

/**
 * return the calculated interest on one year
 * warning, this method updates the balance with the result of that computation
 * @return the interest
 */
public double calculateInterest(){
	double	result = this.interestRate * this.balance;
    this.balance += result; //equivalent to this.balance = this.balance + result
    return result;
}

To precise whether you are using a local variable or a class field, the this keyword is strongly recommended

Taking advantage of inheritance

The inheritance mechanism should always represent a IS-A relationship
When it applies, this relationship allows to factor a lot of code
Example: Inheritance from quadrilateral to rectangle


public class Quadrilateral {

	private double sideA;
	private double sideB;
	private double sideC;
	private double sideD;
    /*...*/
	public double calculatePerimeter(){
		return this.sideA + this.sideB
        + this.sideC + this.sideD;
	}

}

public class Rectangle extends Quadrilateral{
 public Rectangle(double height, double width)
 {
   super (height, height, width, width);
 }

}

Taking advantage of inheritance (2)

Notice the super keyword: it allows the access of the inherited Class (here the Quadrilateral Class)
As the Rectangle Class inherits from the Quadrilateral class, you don't have to write the calculatePerimeter() method again

Warning: The inheritance mechanism allows natural code factoring, but if the relationship between inheriting objects is not a real IS-A relationship, the code maintenance can be very painful

Exercise

In the geometry example found here, add the Ellipse object and try to generalize the Circle class methods

Inheritance problems

When you are using inheritance you have to face several problems

You can't change the characteristics of a super object methods
You have to define clearly what methods can be overridden or not
You have to foresee that the behaviour of the overridden methods can be unpredictable