Classes and Objects

Tags: #◇Computer Science #◇CCPROG3 #◇Classes and Objects #◇Conceptual #◇M2

◇Overview

In the Object-Oriented Programming (OOP) paradigm, modeling real-world entities effectively in software requires a robust foundational structure. This is achieved through the use of Classes and Objects. While procedural programming treats data and procedures as separate entities, OOP encapsulates them. A class acts as a central blueprint or prototype from which individual objects are created. By understanding the distinction between a class (the abstract definition) and an object (the concrete manifestation), developers can design highly modular, reusable, and secure software architectures.

◇Key Definitions

• Class: A blueprint, template, or prototype that defines the variables (state) and the methods (behavior) common to all objects of a certain kind. It is an abstract definition and does not represent a specific instance.
• Object: A concrete instance of a class. It is a specific entity constructed from a class blueprint that possesses its own unique state, predefined behavior, and distinct identity.
• Instantiation: The process of creating a specific object from a class blueprint using the new keyword in Java.

◇Theoretical Framework / Core Concepts

The Anatomy of an Object

Object-Oriented Programming revolves entirely around "objects". Every object constructed in OOP conceptually consists of three core characteristics:

1. State: Represented by attributes, fields, or variables within the class. The state reflects the current data or condition of the object at a given point in time (e.g., a car is "red" and currently going "60 mph").
2. Behavior: Represented by methods or functions. Behavior defines what an object can do or how it can interact with other objects (e.g., a car can "accelerate" or "brake").
3. Identity: A unique property that distinguishes one object from every other object, even if they have the exact same state. In Java, this is typically handled intrinsically by the JVM via memory addresses.

Encapsulation and Data Hiding

Classes provide encapsulation, logically grouping related data and the operations that manipulate that data together into a cohesive unit. A critical sub-principle of this is Data Hiding:

• Access Modifiers: Keywords like private, protected, and public are used to control the visibility and accessibility of a class's internal state.
• By making state private and exposing public methods (like getters and setters), a class strictly controls how its data is modified, protecting it from invalid external manipulation.

◇Worked Examples / Protocol Walkthroughs / Calculations

Consider modeling a vehicle in software.

The Class Blueprint (Car.java)
We define a Car class, specifying the general attributes and methods that any car should have:

public class Car {
    // State (Attributes)
    private String color;
    private String brand;
    private int speed;

    // Constructor
    public Car(String color, String brand) {
        this.color = color;
        this.brand = brand;
        this.speed = 0;
    }

    // Behavior (Methods)
    public void accelerate(int amount) {
        this.speed += amount;
    }

    public void brake() {
        this.speed = 0;
    }
}

Object Instantiation
When the program runs, we can create distinct, concrete objects from this blueprint.

// Instantiating specific objects
Car myCar = new Car("Red", "Toyota");
Car yourCar = new Car("Blue", "Ford");

// Manipulating the state of a specific object
myCar.accelerate(50);

Here, myCar and yourCar possess different identities and states, despite being born from the identical Car class blueprint.

◇Summary & Key Takeaways

• A class is merely an abstract blueprint, while an object is a concrete, living instance of that class in memory.
• Every object inherently possesses State (attributes), Behavior (methods), and a unique Identity.
• Classes facilitate encapsulation, grouping related data and behaviors together.
• Data Hiding through access modifiers is essential for protecting an object's internal state from unintended interference.

◇References & Navigation

• Previous Topic: ◇The Object-Oriented Paradigm and an Overview of Java
• Next Topic: ◇Class Relationships
• Related Notes: ◇Overview of Programming Languages