Java Fundamentals

Summary of the last lectures

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

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;
  }

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

Exercise

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

Inheritance 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

Abstract Classes: Introduction

• Problem: Sometimes you want to define a class that provides common behavior, but it doesn't make sense to instantiate it directly
• Example: A generic "Shape" class - you never want just a "Shape", you want a Circle, Rectangle, etc.
• Solution: Use abstract classes

Abstract Classes: Syntax

public abstract class Shape {
    protected String color;

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

    // Abstract method - no implementation
    public abstract double calculateArea();

    // Concrete method - has implementation
    public String getColor() {
        return this.color;
    }
}

• Use abstract keyword for the class
• Can contain abstract methods (no implementation)
• Can contain concrete methods (with implementation)

Abstract Classes: Implementation

public class Circle extends Shape {
    private double radius;

    public Circle(String color, double radius) {
        super(color);  // Call parent constructor
        this.radius = radius;
    }

    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;
    }
}

• Subclasses must implement all abstract methods
• Use @Override annotation to indicate you're implementing an abstract method

Interfaces: Introduction

• Limitation of inheritance: Java doesn't support multiple inheritance
• Problem: What if a class needs to have multiple "types" of behavior?
• Solution: Use interfaces

Interfaces: Syntax

public interface Drawable {
    // All methods in interfaces are implicitly public and abstract
    void draw();
    double getArea();

    // Since Java 8: default methods with implementation
    default void display() {
        System.out.println("Drawing shape with area: " + getArea());
    }
}

• Use interface keyword instead of class
• Methods are implicitly public abstract
• Can have default methods (since Java 8) with implementation
• Can have static methods

Interfaces: Implementation

public class Rectangle extends Shape implements Drawable, Comparable<Rectangle> {
    private double width;
    private double height;

    public Rectangle(String color, double width, double height) {
        super(color);
        this.width = width;
        this.height = height;
    }

    @Override
    public double calculateArea() {
        return width * height;
    }

    @Override
    public void draw() {
        System.out.println("Drawing a " + color + " rectangle");
    }

    @Override
    public double getArea() {
        return calculateArea();
    }

    @Override
    public int compareTo(Rectangle other) {
        return Double.compare(this.calculateArea(), other.calculateArea());
    }
}

Abstract Classes vs Interfaces

When to Use Which?

Polymorphism with Interfaces

public class ShapeDemo {
    public static void main(String[] args) {
        // Polymorphism: treat all shapes uniformly
        List<Shape> shapes = new ArrayList<>();
        shapes.add(new Circle("Red", 5.0));
        shapes.add(new Rectangle("Blue", 4.0, 6.0));
        shapes.add(new Triangle("Green", 3.0, 4.0));

        // Calculate total area using polymorphism
        double totalArea = 0;
        for (Shape shape : shapes) {
            totalArea += shape.calculateArea();  // Calls correct method
            System.out.println(shape.getClass().getSimpleName() +
                             " area: " + shape.calculateArea());
        }

        System.out.println("Total area: " + totalArea);
    }
}

Real-World Example: Geometry System

// Abstract base class
public abstract class Shape {
    protected String color;

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

    public abstract double calculateArea();
    public abstract double calculatePerimeter();
}

// Interface for drawable objects
public interface Drawable {
    void draw();
    default String getDescription() {
        return "A drawable shape";
    }
}

// Concrete implementation
public class Circle extends Shape implements Drawable, Comparable<Circle> {
    private double radius;

    public Circle(String color, double radius) {
        super(color);
        this.radius = radius;
    }

    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;
    }

    @Override
    public double calculatePerimeter() {
        return 2 * Math.PI * radius;
    }

    @Override
    public void draw() {
        System.out.println("Drawing a " + color + " circle with radius " + radius);
    }

    @Override
    public int compareTo(Circle other) {
        return Double.compare(this.radius, other.radius);
    }
}

Exercise: Geometry System

Create a complete geometry system with the following:

1. Create an abstract Shape class with:
   • A color field
   • Abstract methods: calculateArea() and calculatePerimeter()
   • A concrete method: getColor()
2. Create a Drawable interface with a draw() method
3. Implement these concrete classes:
   • Circle (radius)
   • Rectangle (width, height)
   • Triangle (base, height)
4. Create a ShapeManager class that:
   • Stores a list of shapes
   • Calculates the total area of all shapes
   • Finds the shape with the largest area
   • Draws all shapes

The Object Class: The Root of All Classes

• In Java, every class implicitly extends java.lang.Object
• Even when you don't write extends Object, Java does it automatically
• The Object class provides several important methods that all objects inherit:

toString(): String Representation

• By default, toString() returns: ClassName@hexHashCode
• This is not very useful for debugging or logging!

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

// Without overriding toString()
Person p = new Person("Alice", 25);
System.out.println(p);  // Output: Person@1a2b3c4d  (not helpful!)

toString(): Overriding

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + "}";
    }
}

// Now we get useful output
Person p = new Person("Alice", 25);
System.out.println(p);  // Output: Person{name='Alice', age=25}

// toString() is called automatically in many situations:
System.out.println("User: " + p);  // String concatenation
String.format("User: %s", p);      // Format strings

equals(): Logical Equality

• == compares references (are they the same object in memory?)
• equals() compares values (are they logically equivalent?)

Person p1 = new Person("Alice", 25);
Person p2 = new Person("Alice", 25);
Person p3 = p1;

// Reference comparison
System.out.println(p1 == p2);   // false (different objects)
System.out.println(p1 == p3);   // true (same reference)

// Without overriding equals(), it behaves like ==
System.out.println(p1.equals(p2));  // false (by default)

equals(): Overriding

public class Person {
    private String name;
    private int age;

    @Override
    public boolean equals(Object obj) {
        // 1. Check if same reference
        if (this == obj) return true;

        // 2. Check if null or different class
        if (obj == null || getClass() != obj.getClass()) return false;

        // 3. Cast and compare fields
        Person other = (Person) obj;
        return age == other.age &&
               Objects.equals(name, other.name);
    }
}

// Now logical comparison works
Person p1 = new Person("Alice", 25);
Person p2 = new Person("Alice", 25);
System.out.println(p1.equals(p2));  // true!

hashCode(): The Contract with equals()

• hashCode() returns an integer "fingerprint" of the object
• Critical rule: If two objects are equals(), they must have the same hashCode()
• This is essential for HashMap, HashSet, etc.

@Override
public int hashCode() {
    return Objects.hash(name, age);
}

// Complete equals/hashCode contract:
Person p1 = new Person("Alice", 25);
Person p2 = new Person("Alice", 25);

System.out.println(p1.equals(p2));              // true
System.out.println(p1.hashCode() == p2.hashCode()); // MUST be true!

Why hashCode() Matters for Collections

// Without proper hashCode(), HashSet doesn't work correctly!
Set<Person> people = new HashSet<>();

Person p1 = new Person("Alice", 25);
Person p2 = new Person("Alice", 25);  // Same values as p1

people.add(p1);
people.add(p2);  // Should be ignored (duplicate)

// Without hashCode() override:
System.out.println(people.size());  // 2 (WRONG! Both were added)

// With proper hashCode() override:
System.out.println(people.size());  // 1 (Correct! Duplicate detected)

• HashSet uses hashCode() to find the "bucket" for an object
• Then uses equals() to check for duplicates in that bucket
• If hashCodes differ, equals() is never even called!

The final Keyword

The final keyword can be applied to:

final Variables (Constants)

public class Circle {
    // final static = class-level constant (by convention UPPER_CASE)
    public static final double PI = 3.14159265359;

    // final instance variable - must be initialized once
    private final double radius;

    public Circle(double radius) {
        this.radius = radius;  // OK: initialized in constructor
    }

    public void setRadius(double r) {
        // this.radius = r;  // ERROR: cannot reassign final variable
    }

    public double getArea() {
        return PI * radius * radius;
    }
}

// Usage
final int maxAttempts = 3;
// maxAttempts = 5;  // ERROR: cannot reassign

final Methods and Classes

// final method - cannot be overridden
public class BankAccount {
    private double balance;

    // Subclasses cannot change this security-critical method
    public final void validateTransaction(double amount) {
        if (amount <= 0) {
            throw new IllegalArgumentException("Invalid amount");
        }
    }
}

// final class - cannot be extended
public final class SecurityUtils {
    public static String hashPassword(String password) {
        // ...
    }
}

// This would cause a compile error:
// public class HackedSecurityUtils extends SecurityUtils { }  // ERROR!

Exercise: Implementing Object Methods

Update your Shape classes to properly implement Object methods:

1. Override toString() in the Circle class to return: "Circle[color=red, radius=5.0]"
2. Override equals() to compare circles by color and radius
3. Override hashCode() to be consistent with equals
4. Test your implementation:

   Circle c1 = new Circle("red", 5.0);
   Circle c2 = new Circle("red", 5.0);
   Circle c3 = new Circle("blue", 5.0);
   
   System.out.println(c1);              // Should print nicely
   System.out.println(c1.equals(c2));   // Should be true
   System.out.println(c1.equals(c3));   // Should be false
   
   Set<Circle> circles = new HashSet<>();
   circles.add(c1);
   circles.add(c2);  // Should not add (duplicate)
   System.out.println(circles.size());  // Should be 1

Key Takeaways

• Object Class Methods: toString(), equals(), hashCode()
• The final Keyword: Constants, prevent override, prevent inheritance
• Abstract vs Interfaces: IS-A shared behavior vs CAN-DO contracts
• Polymorphism: Treat different types uniformly
• Records (Java 16): Concise immutable data classes
• Pattern Matching instanceof (Java 16): Combine type check + cast
• Sealed Classes (Java 17): Controlled inheritance hierarchies