Java Classes

Ludovic Deneuville

OOP Principles

  • Encapsulation
  • Inheritance
  • Polymorphism

Encapsulation

  • Attributes: Fields
    • define the state of an object
  • Methods: Behaviors
    • define the actions an object can perform

A class 🚲

Bike.java
public class Bike {
    // Attributes
    private String color;
    private int speed;
    private boolean pannierRacks;

    // Constructor
    public Bike(String color, boolean pannierRacks) {
        this.color = color;
        this.speed = 0;
        this.pannierRacks = pannierRacks;
    }

    // Method
    public void accelerate(int increment) {
        if (increment > 0) {
            this.speed += increment;
        }
    }

    // Getter
    public int getSpeed() {
        return this.speed;
    }
}

Attributes

Bike.java
public class Bike {
    // Attributes
    private String color = "yellow";    // default value if not specified by the constructor
    private int speed;
    private boolean pannierRacks;

    private static int nbBikes = 0;
}
  • static: class attribute

Reminder: Attributes Accessiblility

Modifier Same Class Same Package Subclasses Everywhere
public ✅ ✅ ✅ ✅
protected ✅ ✅ ✅ ❌
default (no modifier) ✅ ✅ ❌ ❌
private ✅ ❌ ❌ ❌

Constructor

Bike.java
public class Bike {
    public Bike(String color, boolean pannierRacks) {
        this.color = color;
        this.speed = 0;
        this.pannierRacks = pannierRacks;
    }
}
  • this : Refers to the current object

Create a Bike Object

Bike greenBike = new Bike("Green", true);
  • Bike: type of the variable
  • greenBike: name of the variable
  • new: Memory allocation
  • Bike(…): constructor call

Default Constructor

  • If no constructor is provided
Bike myBike = new Bike();
  • with default values
    • color: null
    • pannierRacks: false

Create a copy

Bike greenBike = new Bike("Green", true);
Bike otherBike = greenBike;
  • otherBike is it a copy of greenBike?
  • No, it refer to the same Bike object
  • How to create a copy?

Call a method

// Create a Bike object calling the constructor
Bike greenBike = new Bike("Green", true);

// Call methods
greenBike.accelerate(5);
System.out.println(greenBike.getSpeed());

Main method

  • Entry point
  • Generally in a class called Main
public static void main(String[] args) {
    // Program logic here
}

Using args

  • String[] args: arguments passed when running the program
Main.java
public static void main(String[] args) {
    int limit = Integer.parseInt(args[0]);

    for (int i = 0; i <= limit; i++) {
        System.out.println(i);
    }
}
  • javac Main.java
  • java Main 8

Inheritance

Parent class

Vehicle.java
public class Vehicle {
    protected String color;
    protected int speed;

    public Vehicle(String color) {
        this.color = color;
        this.speed = 0;
    }
}

Subclass

  • extends: inherit
  • super(): constructor of the parent class
  • super.foo(): method foo() of the parent class
  • super does not allow access to the private attributes of the parent class
Bike.java
public class Bike extends Vehicle {
    private boolean pannierRacks;

    // Constructor
    public Bike(String color) {
        super(color);
        this.pannierRacks = pannierRacks;
    }
}

Abstract

  • abstract classes: cannot be instantiated
  • abstract methods: Declared without implementation, must be overridden by subclasses
Vehicle.java
public abstract class Vehicle {
    protected String color;
    protected int speed;

    public Vehicle(String color) {
        this.color = color;
        this.speed = 0;
    }

    public abstract void honk();  // abstract method to be implemented in subsclasses

    public void accelerate(int increment) {
        this.speed += increment;
    }
}

Override method

Bike.java
public class Bike extends Vehicle {
    private boolean pannierRacks;

    // Constructor
    public Bike(String color) {
        super(color);
        this.pannierRacks = pannierRacks;
    }

    @Override
    public abstract void honk(){
        System.out.println("Dring")
    }

    @Override
    public void accelerate(int increment) {
        this.speed += increment + 2;
    }

Polymorphism

Substitution

Main.java
Bike bike1 = new Bike();
Bike bike2 = new Bike();
Scooter scooter1 = new Scooter();
Scooter scooter2 = new Scooter();

List<Vehicle> vehicles = List.of(bike1, bike2, scooter1, scooter2);

// Accelerate all vehicles
for (Vehicle vehicle : vehicles) {
    vehicle.accelerate(10);
}

Overloading

Bike.java
public class Bike extends Vehicle {
    private boolean pannierRacks;

    ...

    public void accelerate(int increment) {
        this.speed += increment;
    }
    
    public void accelerate() {
        this.speed += 5;
    }
        
    public void accelerate(double increment) {
        this.speed += increment.intValue();
    }

JavaDoc

  • Clarity: Provides clear and consistent documentation
  • Maintainability: Makes it easier to understand and maintain code
  • Accessibility: Generates HTML documentation that can be easily shared and viewed

Javadoc comments are enclosed in /** and */.

Placed immediately before the element being documented (class, method, field, etc.)

Example

Bike.java
/**
 * Represents a Bike, a type of Vehicle.
 */
public class Bike extends Vehicle {
    private boolean pannierRacks;

    /**
     * Constructs a Bike with the given color
     */
    public Bike(String color) {
        super(color);
        this.pannierRacks = false;
    }

    /**
     * Produces the sound of a bike's honk (dring).
     */
    @Override
    public void honk() {
        System.out.println("Dring");
    }

    /**
     * Accelerates the bike by the given increment, plus an additional 2 units.
     *
     * @param increment The amount to increase the speed by.
     */
    @Override
    public void accelerate(int increment) {
        this.speed += increment + 2;
    }

    /**
     * Checks if the bike has pannier racks.
     *
     * @return true if the bike has pannier racks, false otherwise.
     */
    public boolean hasPannierRacks() {
        return pannierRacks;
    }