08 Objects and Encapsulation

The Object-Oriented Model

Object-oriented Java programs model entities as objects. Each object combines three ideas:

• State: the data stored in its fields.

• Behavior: the operations provided by its methods.

• Identity: the fact that it is a distinct instance.

A class defines the structure and behavior that objects of that type can have. An object is one instance created from the class. For example, BankAccount can describe what an account stores and does, while each individual account has its own owner and balance.

A reference variable identifies an object; it does not contain the object's fields directly. A reference may also contain null, which means that it identifies no object.

Takeaway: A class is a blueprint, an object is an instance, and an object combines state, behavior, and identity.

State, Behavior, and this

A field is a variable declared inside a class, and fields represent an object's state. A BankAccount class might declare private String owner and private double balance. Each object normally has its own copy of each instance field. Two BankAccount objects can therefore have different owners and balances; changing one object's balance does not automatically change the other's.

An instance method describes behavior for one particular object. For example, deposit changes the receiving account's balance, while getBalance reports it. Calls such as account.deposit(50.0) and account.getBalance() use the reference before the dot to identify the receiving object.

Inside an instance method or constructor, this identifies the receiving object. In the statement this.owner = owner, this.owner means the object's field, while owner means the parameter.

Takeaway: Fields store state, and instance methods provide behavior for a specific object.

Creating and Initializing Objects

A constructor initializes a newly created object. It has the same name as its class, has no return type, and runs when new creates an object. A constructor can require values needed for valid initial state, such as an owner and a starting balance.

The expression BankAccount account = new BankAccount("Maya", 100.00) illustrates two roles: the new expression creates and initializes a BankAccount object, and account stores a reference to it.

A class can provide multiple constructors with different parameter lists. This is constructor overloading. For example, a Point class might provide Point() and Point(int x, int y). The no-argument constructor can delegate to the other constructor with this(0, 0), allowing both creation paths to establish complete state.

If a class declares no constructor, Java can provide a default no-argument constructor. Once the class declares any constructor, a no-argument constructor must be declared explicitly if it is still needed.

Takeaway: Constructors establish initial state, and overloaded constructors offer multiple valid creation paths.

Invoking Instance Methods

An instance method is invoked through an object reference with the dot operator. For example, BankAccount account = new BankAccount("Maya", 100.00) followed by account.deposit(40.00) changes the account, and double amount = account.getBalance() retrieves its balance.

The reference before the dot determines which object's state the method can access or modify. The same method can therefore produce different results when invoked on different objects. If a starts with a balance of 20.00 and b starts with a balance of 90.00, then a.deposit(10.00) and b.deposit(10.00) affect separate objects.

A method may return a value, such as getBalance, or return void, such as deposit. It may also accept arguments and use conditional logic to reject invalid operations.

Takeaway: The dot operator connects a method call to the particular object whose behavior is being requested.

References and Aliasing

Aliasing occurs when multiple reference variables identify the same object. Assigning one reference to another copies the reference, not the object. For example, after BankAccount original = new BankAccount("Maya", 100.00) and BankAccount alias = original, both variables refer to the same account. If alias.deposit(25.00) is called, original.getBalance() observes the updated balance, 125.0.

This differs from assigning primitive values. If int first = 10, int second = first, and second = 20, then first remains 10 while second is 20, because the primitive value was copied.

To create a distinct object, use another constructor call rather than assigning an existing reference. For example, BankAccount a = new BankAccount("A", 10.00) and BankAccount b = new BankAccount("A", 10.00) create two separate objects with independent state.

Takeaway: Reference assignment shares an object; it does not make an independent object copy.

Reference Safety

A reference can contain null, which means it refers to no object. For example, BankAccount account = null creates a reference whose value is null, not a BankAccount object.

Calling an instance method through null, as in account.getBalance(), causes a NullPointerException because there is no receiving object. Code should ensure that a reference identifies a valid object before invoking its instance methods.

Declaring a reference also does not create an object. BankAccount account only declares a reference; a constructor call such as BankAccount account = new BankAccount("Maya", 100.00) is needed before the reference can be used to invoke an instance method.

Takeaway: A declared reference and an object are different things, and null cannot receive a method call.

Encapsulation and Invariants

Encapsulation combines an object's data with the methods that manage it while limiting inappropriate access. Fields are usually declared private so code outside the class cannot change them directly. Instead of allowing an assignment such as account.balance = -500.00, the class exposes controlled methods.

An withdraw method can check that an amount is positive and does not exceed the balance before changing the field. A caller can then use the method's result to determine whether the operation succeeded, rather than directly modifying the balance.

An invariant is a condition that should remain true for every valid object. For a bank account, a useful invariant is that the balance cannot become negative. Private fields and validating methods help preserve that rule.

A class does not need to provide a setter for every field. If unrestricted modification could violate an invariant, the field should have no public setter or should be changed only through carefully designed operations.

Takeaway: Encapsulation protects invariants by hiding implementation details and exposing a controlled public interface.

Putting the Ideas Together

A complete Temperature class illustrates the pattern. It can contain a private double celsius field, a constructor that assigns the initial value with this.celsius = celsius, a getCelsius method, a toFahrenheit method, and an increase method that accepts only nonnegative changes.

For a temperature of 20.0, calling temperature.increase(5.0) changes the stored Celsius value to 25.0. The Fahrenheit conversion follows

so a Celsius value of 25.0 produces 77.0 degrees Fahrenheit.

The private field stores state. The constructor establishes the initial value, getCelsius provides controlled access, toFahrenheit computes a result from the state, and increase changes the state only when the argument is nonnegative.

The example connects the main ideas: a class defines the structure, a constructor initializes an object, a reference identifies the object, methods provide behavior, and private state is changed through controlled operations.

Takeaway: A well-designed class makes valid operations easy and invalid state changes difficult.

Practical Checklist

Use these checks when reading or writing Java object-oriented code:

1. Class or object? A class defines a type; an object is a created instance.

2. Reference or object? A reference identifies an object but does not contain its fields.

3. Created or merely declared? A declaration alone does not create an object; use new and a constructor call.

4. Same object or separate objects? Assigning one reference to another creates an alias; a second constructor call creates a separate object.

5. Valid state? Keep fields private and use methods that preserve the class's invariants.

6. Safe receiver? Check that a reference is not null before invoking an instance method.

The central design principle is to make each object responsible for protecting and managing its own state through a clear public interface.