2 Classes and Objects

From Classes to Objects

Object-oriented programs model a system as interacting objects that combine data with operations on that data. A class describes the common structure and behavior of a kind of object, while each object is a particular instance with its own identity and state.

A useful distinction is:

• A class is a template describing what objects of a kind can contain and do.

• An object is one concrete entity created according to that template.

• The same class can produce many objects, each with separate instance data.

For example, a BankAccount class might define an account number, an owner, a balance, and operations such as depositing or withdrawing money. The class describes the capabilities of accounts; it does not represent one specific account until an object is created.

Takeaway: Classes describe common structure and behavior; objects are the individual entities that use that description.

Creating Instances and Sharing References

Creating a concrete object from a class is called Instantiation. A class can be used to create multiple objects with the same available fields and methods but different field values.

For example, two bank accounts may be created with different account numbers and balances. Calling a deposit operation on one account changes that account's balance, while the other account remains unchanged, because each object has its own instance state.

A variable that refers to an object generally stores a reference rather than the complete object directly. This makes it possible for two variables to refer to one object. If first and second both refer to the same account, a deposit made through second is visible when the balance is examined through first.

Takeaway: Creating objects gives a class concrete instances, and references determine which object an operation affects.

Fields, State, and Encapsulation

A field is data associated with a class or object. An instance field belongs separately to each object, whereas a static or class field belongs to the class and may be shared among all its objects.

The values of an object's instance fields at a particular time make up its state. A bank account's state might include an account number, a balance, and an open or closed status. Methods can read this state or change it.

A well-designed class protects valid state by checking inputs before changing fields. For example, a withdrawal operation can reject a nonpositive amount or an amount larger than the permitted balance. Keeping internal fields private and exposing controlled operations supports encapsulation.

Takeaway: State records an object's current data, and controlled access helps preserve valid state.

Methods and Behavior

A method is a function defined within a class. It expresses behavior associated with the class or with a particular object. Methods may read state, modify state, validate input, coordinate with other objects, return a result, or perform an action without returning a value.

An instance method operates on a particular object. Within such a method, this or an equivalent keyword commonly identifies the current object, so this.balance means the balance belonging to the object on which the method was called. Languages differ in the exact syntax; Python methods conventionally receive the instance as a first parameter named self.

A class or static method operates at the class level and does not require a particular instance. Shared fields and static methods are most appropriate when the data or operation genuinely belongs to the class as a whole.

Takeaway: Methods turn stored data into controlled behavior, with instance methods acting on particular objects and class-level methods acting on the class.

Initialization and Valid Objects

A constructor runs when a new object is created. Its purpose is to establish the object's initial state and ensure that required values are present. A typical creation process obtains storage, establishes default values, performs available field initialization, runs the constructor, and returns a reference to the initialized object; the exact order depends on the language.

Constructors should establish class invariants: conditions that must remain true for every valid object. If a bank account cannot have a negative opening balance, its constructor should reject or correct a negative input rather than create an invalid account.

A class may provide multiple constructors with different parameter lists. This practice is called constructor overloading. Constructors may also supply default values when callers omit some initialization details.

Takeaway: Initialization is more than assigning values; it establishes the conditions that make an object valid from the beginning.

Identity, Equality, and Mutation

Object identity distinguishes one object from another independently of field values. Two separately created accounts can have the same account number and balance while still being different objects. If a second variable is assigned a reference to the first object, both variables designate one object and therefore share its identity.

This distinction matters especially for mutable objects. When two references designate the same object, a state change through either reference is visible through the other. By contrast, two separate objects with equal contents can change independently.

Languages may distinguish identity equality from value equality. Identity equality asks whether references designate the same object, while value equality asks whether objects contain equivalent values. The exact default and comparison rules depend on the language and type.

Takeaway: Equal contents do not necessarily mean the same object; references and identity determine whether changes are shared.

The Object Lifecycle

An object's lifecycle begins with a class definition and proceeds through creation, initialization, use, and possible mutation. If no live part of the program can reach the object through a reference, the object has lost reachability.

The final handling of an unreachable object depends on the language's memory-management model. In garbage-collected languages such as Java and .NET languages, an unreachable object can eventually be reclaimed automatically, but reclamation is not necessarily immediate. In systems with manual memory management or deterministic resource management, a programmer or ownership system may control when storage and resources are released.

Memory reclamation is not a substitute for explicitly managing external resources such as files, sockets, or database connections. Those resources should generally be released through the language's resource-management mechanisms.

Takeaway: Object lifetime includes both memory and resource responsibilities, and the precise cleanup process is language-dependent.

Putting the Ideas Together

Consider a Counter class with a private value field. Its constructor accepts a starting value and replaces a negative start with zero. An increment method adds one to the field, and a currentValue method returns the current value.

If counterA is created with a starting value of three, then counterB is assigned a reference to counterA, both variables designate the same object. Calling increment through counterB changes the shared object's value. Reading through counterA then produces four.

This compact example brings the concepts together:

• The class defines structure and behavior.

• The object reference identifies a particular instance.

• The private field stores state.

• The constructor establishes an initial valid value.

• Methods provide controlled operations.

• Two variable names can refer to one object, so mutation through one name is visible through the other.

Takeaway: Understanding the connection among class, reference, state, constructor, method, and identity explains the behavior of many object-oriented programs.

• aliasing