Java Programming · Week 6

Objects and Wrapper Classes

Step 1 of 5

Java Guided Tutorials - Objects and Wrapper Classes

What You'll Learn

Welcome to our Java Objects and Wrapper Classes Tutorial! This lesson explores how to create and work with objects — instances of classes that model real-world entities — and how wrapper classes let you use primitive data types in object-oriented contexts.

Lesson Overview:

Object Basics: Creating objects with the new keyword, understanding state and behavior, and the this keyword.
Wrapper Classes: Wrapping primitives into objects with Integer, Double, Boolean, and more, plus autoboxing and unboxing.
Object Methods: Instance methods vs static methods, accessors (getters) and mutators (setters), and overriding toString().
Object Comparison: Reference equality with == vs content equality with .equals(), and the hashCode() contract.

By the end of this lesson, you'll be comfortable creating objects, using wrapper classes, writing instance methods, and comparing objects correctly — skills essential for real-world Java development, collections, and generics.

1. Object Basics

What is an Object?

In Java, an object is an instance of a class. Think of a class as a blueprint and the object as the actual thing built from that blueprint. Objects have state (attributes/fields) and behavior (methods). You create objects using the new keyword, which allocates memory and calls a constructor.

Creating an Object:

ClassName objectName = new ClassName();

Key Components of an Object:

State (Instance Variables): Fields that hold the object's data.
Behavior (Instance Methods): Methods that operate on the object's data.
Identity: Each object has a unique memory address.

The this Keyword:

Inside an instance method, this refers to the current object. It is often used to distinguish instance variables from constructor or method parameters with the same name.

Example: Car Class

public class Car {
    // Instance variables (state)
    String brand;
    String model;
    int year;

    // Constructor
    public Car(String brand, String model, int year) {
        this.brand = brand;
        this.model = model;
        this.year = year;
    }

    // Instance method (behavior)
    public void startEngine() {
        System.out.println("The " + this.brand + " " + this.model + " is starting...");
    }

    public static void main(String[] args) {
        Car myCar = new Car("Toyota", "Corolla", 2022);
        myCar.startEngine();
    }
}

Key Points:

Objects are created with new followed by a constructor call.
Instance variables define the object's state; instance methods define its behavior.
The this keyword refers to the current object and disambiguates fields from parameters.
Each object gets its own copy of instance variables.

Starter code

public class Car {
    // Step 1: Declare instance variables: brand (String), model (String), year (int)

    // Step 2: Create a constructor that takes brand, model, and year
    //         Use 'this' to assign the parameters to the instance variables

    // Step 3: Create an instance method startEngine() that prints
    //         "The " + brand + " " + model + " is starting..."

    public static void main(String[] args) {
        // Step 4: Create a Car object with brand "Toyota", model "Corolla", year 2022
        // Step 5: Call the startEngine() method on your object
    }
}

Write your code here

Make it print The Toyota Corolla is starting...

Did it work?

Your program should print this:

The Toyota Corolla is starting...

Paste what you got:

2. Wrapper Classes

What are Wrapper Classes?

Wrapper classes are Java classes that "wrap" primitive data types into objects. They are essential because many Java features — like collections (ArrayList, HashMap) and generics — work only with objects, not primitives. Each primitive type has a corresponding wrapper class.

Primitive to Wrapper Mapping:

Primitive Type	Wrapper Class	Example
`int`	`Integer`	`Integer i = 5;`
`double`	`Double`	`Double d = 3.14;`
`boolean`	`Boolean`	`Boolean b = true;`
`char`	`Character`	`Character c = 'A';`
`long`	`Long`	`Long l = 100L;`
`float`	`Float`	`Float f = 2.5f;`

Autoboxing and Unboxing:

Autoboxing is the automatic conversion of a primitive type to its corresponding wrapper class. Unboxing is the reverse — converting a wrapper object back to its primitive. Java handles these conversions automatically.

// Autoboxing: int -> Integer
int num = 42;
Integer wrapped = num;  // Java auto-boxes

// Unboxing: Integer -> int
Integer value = 100;
int primitive = value;  // Java auto-unboxes

Useful Wrapper Methods:

Integer.parseInt("123") — converts a String to an int
Integer.valueOf(123) — returns an Integer object
Integer.MAX_VALUE — the maximum int value (2147483647)
String.valueOf(123) — converts any value to a String

Example: WrapperExample

public class WrapperExample {
    public static void main(String[] args) {
        // Parsing a string to an integer
        String numberStr = "123";
        int parsed = Integer.parseInt(numberStr);
        System.out.println("Parsed number: " + parsed);

        // Using Integer.MAX_VALUE
        System.out.println("Maximum value of Integer: " + Integer.MAX_VALUE);

        // Autoboxing example
        Integer a = 42;        // autoboxing
        int b = a;             // unboxing
        System.out.println("Autoboxed: " + a + ", Unboxed: " + b);
    }
}

Key Points:

Wrapper classes let you use primitives where objects are required (e.g., in collections).
Autoboxing and unboxing happen automatically — you rarely need to manually wrap/unwrap.
Wrapper classes provide useful constants (MAX_VALUE, MIN_VALUE) and utility methods (parseInt, valueOf).

Starter code

public class WrapperExample {
    public static void main(String[] args) {
        // Step 1: Declare a String variable "numberStr" with value "123"
        // Step 2: Parse it to an int using Integer.parseInt() and print it
        // Step 3: Print the maximum value of Integer using Integer.MAX_VALUE
    }
}

Write your code here

Make it print Parsed number: 123 Maximum value of Integer: 2147483647

Did it work?

Your program should print this:

Parsed number: 123
Maximum value of Integer: 2147483647

Paste what you got:

3. Object Methods

Instance Methods vs Static Methods

Instance methods belong to an object and can access instance variables. They are called on a specific object. Static methods belong to the class itself and cannot access instance variables directly. This section focuses on instance methods.

Accessors and Mutators (Getters and Setters):

Accessors (getters) retrieve the value of a private field. Mutators (setters) update the value of a private field, often with validation. These methods follow the JavaBeans naming convention.

public class Person {
    private String name;

    // Accessor (getter)
    public String getName() {
        return name;
    }

    // Mutator (setter)
    public void setName(String name) {
        this.name = name;
    }
}

Method Overriding and toString():

Method overriding allows a subclass to provide a specific implementation of a method already defined in its superclass. A common method to override is toString(), which returns a string representation of an object.

Example: Rectangle Class

public class Rectangle {
    private double length;
    private double width;

    // Constructor
    public Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }

    // Accessors
    public double getLength() { return length; }
    public double getWidth() { return width; }

    // Mutators
    public void setLength(double length) { this.length = length; }
    public void setWidth(double width) { this.width = width; }

    // Instance method: calculate area
    public double calculateArea() {
        return length * width;
    }

    // Instance method: calculate perimeter
    public double calculatePerimeter() {
        return 2 * (length + width);
    }

    // Instance method: check if square
    public boolean isSquare() {
        return length == width;
    }

    // Override toString()
    @Override
    public String toString() {
        return "Rectangle[" + length + " x " + width + "]";
    }

    public static void main(String[] args) {
        Rectangle rect = new Rectangle(5.0, 3.0);
        System.out.println("Area: " + rect.calculateArea());
        System.out.println("Perimeter: " + rect.calculatePerimeter());
        System.out.println("Is Square? " + rect.isSquare());
    }
}

Key Points:

Instance methods operate on an object's state; they are called on an instance, not on the class.
Getters and setters follow the getFieldName() / setFieldName() naming convention.
Override toString() to provide a meaningful text representation of your objects.
Method overriding lets subclasses customize inherited behavior.

Starter code

public class Rectangle {
    // Step 1: Declare private instance variables: length (double), width (double)

    // Step 2: Create a constructor that takes length and width

    // Step 3: Create getter and setter methods for length and width

    // Step 4: Create an instance method calculateArea() that returns length * width

    // Step 5: Create an instance method calculatePerimeter() that returns 2 * (length + width)

    // Step 6: Create an instance method isSquare() that returns true if length == width

    public static void main(String[] args) {
        // Step 7: Create a Rectangle with length 5.0 and width 3.0
        // Step 8: Print the area, perimeter, and whether it's a square
    }
}

Write your code here

Make it print Area: 15.0 Perimeter: 16.0 Is Square? false

Did it work?

Your program should print this:

Area: 15.0
Perimeter: 16.0
Is Square? false

Paste what you got:

4. Object Comparison

Reference Equality vs Content Equality

In Java, there are two ways to compare objects:

== (Reference Equality): Checks whether two references point to the same memory location — i.e., they are the exact same object.
.equals() (Content Equality): Checks whether two objects have the same logical content. By default, equals() behaves like ==, but you can override it to define custom equality logic.

The hashCode() Contract:

Whenever you override equals(), you must also override hashCode() to maintain the general contract: equal objects must have equal hash codes. This is critical for objects used in hash-based collections like HashMap or HashSet.

Example: Person Class with equals() and hashCode()

import java.util.Objects;

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

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

    // Override equals() to compare name and age
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Person person = (Person) obj;
        return age == person.age && Objects.equals(name, person.name);
    }

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

    public static void main(String[] args) {
        Person p1 = new Person("Alice", 25);
        Person p2 = new Person("Alice", 25);
        Person p3 = p1;  // p3 references the same object as p1

        // Reference equality
        System.out.println("p1 == p2: " + (p1 == p2));
        System.out.println("p1.equals(p2): " + p1.equals(p2));
        System.out.println("p1 == p3: " + (p1 == p3));
    }
}

Best Practices:

Always override both equals() and hashCode() — never one without the other.
Use Objects.equals() for null-safe field comparisons in your equals() method.
Use Objects.hash() for a simple, correct hashCode() implementation.
Use == for checking if two references point to the same object; use .equals() for logical comparison.

Starter code

import java.util.Objects;

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

    // Step 1: Create a constructor that takes name and age

    // Step 2: Override equals() to compare both name and age
    //         Use Objects.equals() for null-safe comparison

    // Step 3: Override hashCode() using Objects.hash()

    public static void main(String[] args) {
        // Step 4: Create two Person objects with name "Alice" and age 25
        // Step 5: Create a third reference that points to the first object
        // Step 6: Print results of == and .equals() comparisons
    }
}

Write your code here

Make it print p1 == p2: false p1.equals(p2): true p1 == p3: true

Did it work?

Your program should print this:

p1 == p2: false
p1.equals(p2): true
p1 == p3: true

Paste what you got:

PreviousMethods NextArrays