7 Objects and Classes

Objects and Classes

An object is a particular entity created while a Java program runs. It combines three related ideas:

• State: the information currently stored, such as an account owner and balance.

• Behavior: the actions the object can perform, such as depositing or withdrawing money.

• Identity: the fact that the object is a distinct entity, even if another object has identical data.

A class is the definition or blueprint for objects. It describes the data objects of that class contain and the operations they support. For example, a BankAccount class can describe accounts, while each BankAccount object stores its own account information.

A class body commonly contains fields for state, constructors for initialization, and methods for behavior.

Takeaway: A class defines what its objects are like; an object is a particular run-time instance with its own identity and state.

State: Instance and Class Fields

A field is a variable declared inside a class. It stores information associated with an object or with the class as a whole.

An instance field belongs separately to each object. For example, first and second can refer to two BankAccount objects created with new BankAccount("Maya", 500.00) and new BankAccount("Luis", 800.00). The two objects have the same class but different owner and balance values. Changing one object's balance does not normally change the other object's balance.

A class field is declared with static and is shared by all objects of the class. For example, private static int accountCount = 0; represents one count associated with the class rather than a separate count for every account.

Use instance fields for object-specific state and static fields for information associated with the class itself.

Takeaway: Decide whether a value belongs to one object or is shared by the class before choosing an instance field or a class field.

Behavior Through Methods

A method is a named block of code defined in a class. It describes behavior, can change fields, return information, perform an action without returning a value, or accept parameters.

For example, a deposit method can accept an amount and add it to the current object's balance only when the amount is valid. A withdraw method can reject an invalid amount or an amount greater than the current balance, while getBalance can return the current balance.

Methods are called with the dot operator. For example, account.deposit(50.00) invokes deposit for the object referred to by account, and account.getBalance() obtains information from that same object. Calling the method through a different reference operates on the other object's state.

Methods keep operations related to a concept together with the data those operations use.

Takeaway: Methods are the operations through which objects perform actions and expose useful information.

Creating and Initializing Objects

A constructor is special code that runs when a new object is created. It has the same name as its class, has no return type, initializes the new object's fields, and may receive parameters.

For example, public BankAccount(String owner, double openingBalance) can initialize an account's owner and opening balance. The expression new BankAccount("Maya", 500.00) creates and initializes the object by invoking that constructor.

The statement BankAccount account = new BankAccount("Maya", 500.00); has three distinct parts:

1. BankAccount account declares a reference variable whose type is BankAccount.

2. new BankAccount("Maya", 500.00) creates and initializes an object.

3. The assignment stores a reference to that object in account.

Inside a constructor or instance method, the this reference identifies the current object. Thus, this.owner means the current object's field, while owner by itself can mean a parameter with the same name.

If a class declares no constructor, Java can provide an implicit no-argument constructor subject to the rules of the superclass. Once a class declares a constructor, Java does not automatically provide another no-argument constructor. Constructor overloading allows multiple constructors when their parameter lists differ. For example, Point() can delegate to Point(int x, int y) by using this(0, 0).

Takeaway: Constructors establish the conditions an object should satisfy immediately after creation.

References, Types, and null

A reference variable has a class type and stores a reference to an object. The declaration BankAccount checking; declares the variable but does not create a BankAccount object. The variable must later be assigned an object, such as with checking = new BankAccount("Maya", 500.00);.

A class-type variable can also contain null, which means it refers to no object. For example, BankAccount account = null; does not provide an object on which an instance method can operate. Calling account.getBalance() in that state causes a NullPointerException at run time.

A class name can be used as a variable type, parameter type, field type, or return type. This allows a method to pass one meaningful concept, such as a BankAccount, rather than passing unrelated pieces of data separately.

Declaring a reference variable and creating an object are separate operations.

Takeaway: Always distinguish a reference from the object it identifies, and ensure the reference is not null before using it.

Encapsulation and Class Design

Encapsulation protects an object's internal state by controlling how other code can access or change it. A private field can be accessed directly only within its own class.

For example, outside code should not directly assign an invalid value to a private balance field. Instead, public methods such as account.deposit(100.00) and account.withdraw(25.00) can enforce the class's rules. A withdrawal method can reject an amount that is not positive or exceeds the current balance.

This design keeps the object responsible for preserving valid state and creates a small, understandable public interface. When designing a class, ask:

1. What concept does the class represent?

2. What state must each object remember?

3. What actions should the object perform?

4. What values are valid?

5. Which implementation details should remain hidden?

6. What must be true immediately after construction?

A well-designed class keeps related data and operations together, prevents invalid state, and exposes only the operations that other code needs.

Takeaway: Encapsulation hides implementation details and lets a class control the valid ways its state can change.

Putting the Parts Together

Consider a Student class with private name and credits fields. Its constructor establishes the initial state, addCredits changes the state only for valid input, and getCredits, getName, and isFullTime provide controlled access and useful behavior.

A typical sequence is Student student = new Student("Avery");, followed by student.addCredits(15);. The variable student refers to an instance of Student. The object begins with the state established by its constructor, and addCredits updates that object's credits. Query methods read the resulting state without exposing the fields for arbitrary direct modification.

In this example, Student is a class and a reference type, student is a reference variable, and the object created with new Student("Avery") is an instance of Student. The fields represent state, the methods provide behavior, and encapsulation controls how the state changes or is examined.

This pattern generalizes to other classes: define a concept, store its individual state in instance fields, initialize that state in constructors, provide behavior through methods, and protect the object's rules through controlled access.

Final takeaway: Read object-oriented Java by tracking four questions: what class defines the object, what state the object stores, what constructor created it, and which methods can validly change or examine that state.