Module 1: Classes, Objects, and Access

Module Overview

Learn about fundamental object-oriented programming concepts in Java, including classes, objects, and access modifiers.

Learning Objectives

• Define instance variables to store the internal state of an object
• Implement a class with multiple constructors to allow optional constructor arguments
• Explain the relationship between a class and an object
• Implement code to instantiate an object by calling a constructor with and without parameters
• Declare variables of the correct types to store referenced objects
• Explain the scope of visibility of a class's public and private member variables
• Implement code to call an instance method and use its returned value
• Implement code to call an instance method that has a void return type
• Recall that calling a method executes the statements in the method before continuing
• Define the behavior of an object through a method written in the class
• Implement an instance method that reads the value of one of its class's instance variables
• Implement an instance method that modifies the value of one of its class's instance variables
• Implement an instance method with a reference to the current object using the keyword, "this"
• Explain the scope of visibility of a local variable declared at the top of a method
• Explain the scope of visibility of a local variable declared within a code block
• Explain the scope of visibility of a method parameter variable

Key Concepts Explained

Classes are templates for creating objects. They define the structure and behavior that the objects will have.

Instance Variables

Instance variables store the state of an object. Each object created from a class has its own copy of these variables.

public class Person {
    // Instance variables
    private String name;
    private int age;
}

Constructors

Constructors initialize objects when they are created. You can have multiple constructors to provide different ways to create objects.

public class Person {
    private String name;
    private int age;
    
    // Default constructor
    public Person() {
        this.name = "Unknown";
        this.age = 0;
    }
    
    // Parameterized constructor
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

Access Modifiers

Access modifiers control the visibility of class members (variables and methods).

• private: Accessible only within the same class
• public: Accessible from any class
• protected: Accessible within the same package and subclasses
• default: Accessible only within the same package

Object Instantiation

Creating an object from a class is called instantiation. You use the "new" keyword followed by a constructor call.

// Creating objects
Person person1 = new Person(); // Using default constructor
Person person2 = new Person("John", 25); // Using parameterized constructor

Instance Methods

Instance methods define the behavior of objects. They can access and modify the object's state.

public class Person {
    private String name;
    private int age;
    
    // Constructor
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    // Instance method that returns a value
    public String getName() {
        return this.name;
    }
    
    // Instance method that modifies state
    public void setAge(int age) {
        this.age = age;
    }
    
    // Instance method with void return type
    public void greet() {
        System.out.println("Hello, my name is " + this.name);
    }
}

Common Patterns and Best Practices

Encapsulation

One of the key principles of OOP is encapsulation - hiding the internal state of an object and requiring all interaction to be performed through well-defined methods.

// Good encapsulation
public class BankAccount {
    private double balance; // Private instance variable
    
    public double getBalance() {
        return balance;
    }
    
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }
    
    public boolean withdraw(double amount) {
        if (amount > 0 && balance >= amount) {
            balance -= amount;
            return true;
        }
        return false;
    }
}

Object Composition

Building complex objects by combining simpler ones is a powerful design technique.

public class Address {
    private String street;
    private String city;
    private String zipCode;
    
    // Constructor, getters, and setters
}

public class Person {
    private String name;
    private Address address; // Object composition
    
    // Constructor, getters, and setters
}

Practice Exercises

Complete these exercises to reinforce your understanding of classes, objects, and access modifiers.

Exercise 1: Create a Car Class

Create a Car class with the following features:

• Private instance variables for make, model, year, and fuelLevel
• Multiple constructors (default and parameterized)
• Methods to drive (decreases fuel level) and refuel (increases fuel level)
• Getters and setters for all instance variables

Exercise 2: Bank Account Management

Create a BankAccount class with:

• Private instance variables for accountNumber, balance, and owner
• Methods for deposit, withdraw, and transfer
• Appropriate validation to ensure balance doesn't go negative

Guided Projects

Complete these exercises to reinforce your understanding of classes, objects, and access modifiers.

Mastery Task 4 - Constructing Classes

./gradlew test --tests com.adventure.MT4

./gradlew checkstyleMain