2 Classes and Objects

Classes, objects, and instances

Object-oriented programming organizes software around objects that combine data with operations. A class describes the common structure and behavior, while each object is a concrete runtime value created from that description.

A Class defines a programmer-created type. It can specify:

• attributes, which hold named data;

• methods, which define operations; and

• initialization logic, which establishes a valid starting state.

An Object is a concrete value created from a class. Because it is an individual example of a class, it is also an Instance. For example, a BankAccount class can describe what every account has, such as an owner and balance, and what every account can do, such as deposit and withdraw money.

The class is reusable; it is not itself one particular bank account. Creating an individual account from it is called Instantiation.

Takeaway: A class describes a type, and an object is one created instance of that type.

Attributes and object state

An Attribute is a named value associated with a class or one of its objects. The collection of an object's attribute values at a particular moment is its State.

For an account, owner and balance can be instance attributes. If one account has a balance of $500$ and another has a balance of $2000$, their states differ even though both objects come from the same class.

A class can also provide shared data. A class attribute such as currency = "USD" is associated with the class and can be visible through its instances. By contrast, instance attributes belong to individual objects and are appropriate for values that vary from object to object.

Be careful with mutable class attributes such as lists or dictionaries. Because the same mutable value can be shared, a change made through one instance may be visible through other instances. Data that should be independent usually belongs on the instance.

Takeaway: Attributes represent data, state is the data's current arrangement, and instance data should be used for values that must remain independent.

Methods and behavior

A Method is a function associated with a class. It defines behavior that an object can perform or that can be performed on its behalf. Dot notation places the object before the method name, as in account.withdraw(100).

In Python, an instance method conventionally receives the instance as its first parameter, usually named self. When the method is called through an object, Python supplies that argument automatically.

Methods can:

• return information without changing state;

• change state, such as increasing an account balance;

• validate input and reject invalid operations; or

• coordinate several internal operations.

Using a method instead of directly changing an attribute can preserve the object's rules. For example, a withdrawal method can reject an amount greater than the current balance, preventing an invalid state.

Takeaway: Methods are the behavior of an object and provide a controlled way to inspect or change its state.

Construction and initialization

A Constructor is creation-time logic that establishes an object's initial values. In Python, __init__() is an initializer called automatically after a new instance has been created. In Java, a constructor has the same name as its class and has no return type.

A well-designed initializer establishes a valid starting state. For example, a Student initializer can receive a name and year, then store those values in the new object's attributes.

Validation can occur during initialization. A rectangle initializer might reject nonpositive dimensions before storing width and height. This ensures that every successfully created rectangle begins in a state the class considers valid.

Some languages provide a default or no-argument constructor when none is explicitly declared. The exact rule depends on the language; Java supplies one only when the class declares no constructors.

Takeaway: Initialization is part of object creation and should establish required data and enforce important starting conditions.

Identity, equality, and references

Two objects can contain equal-looking values while still being different objects. Object identity concerns whether two references designate the exact same object, whereas equality concerns whether their values compare as equal according to the type's rules.

For example, two separately created accounts for the same owner and balance have different identities. If third = first, then third is another reference to the object designated by first; it is not a new copy. A change made through either reference affects the same object.

In Python, is and is not test identity, while == tests equality. The id() function returns an integer that is unique and constant for an object during that object's lifetime.

An assignment such as alias = account creates a Reference to the existing object. A genuine copy requires an explicit copying operation, and the result may be shallow or deep depending on the language and the data inside the object.

Takeaway: Equal values do not guarantee equal identity, and assigning a new name usually creates an alias rather than a copy.

Putting the concepts together

A complete object workflow can be understood through a rectangle example:

1. Define a Rectangle class with width and height attributes.

2. Instantiate objects such as a small rectangle with dimensions $3$ and $4$, and a large rectangle with dimensions $10$ and $2$.

3. Let the initializer validate the dimensions and establish the initial state.

4. Use an area() method to calculate the current area. For the small rectangle, $3 \times 4 = 12$.

5. Use a scale() method to change the dimensions. Scaling the small rectangle by $2$ changes its area to $48$.

6. Observe that the large rectangle remains at area $20$, because it is a separate instance with independent instance state.

This sequence connects the main ideas: the class defines the available structure and behavior, instantiation creates objects, initialization sets their starting data, methods inspect or mutate state, and separate instances normally do not affect one another.

Takeaway: Follow the lifecycle from class definition to instantiation, initialization, method use, state change, and independent instances.