In Object Oriented Programming (OOP), we seek to represent elements of the real world within our programs. To do this, we abstract from the object its characteristics (what they have) and their behaviors (what they do), translating these ideas into classes and objects. In this way, we can encapsulate states and behaviors of a specific type of object, facilitating its maintenance and reuse in the code.

For example, imagine that we want to represent a pen in our program. What would its characteristics be? and what would their behaviors be? Let's then design the pen as follows:

To translate this abstraction into code, we created a class that works as the "mold" or "project" that establishes the characteristics and behaviors of a pen. The class defines what every object of this type will have (such as attributes) and be able to do (such as methods). Thus, the class serves as an abstract representation, while the object is a concrete/real instance of that class.

When we create an object from a class, it becomes a single instance, with specific values ??assigned to its instance variables. Thus, according to Paul Deitel and Harvey Deitel (2017, p.56): “each new class you develop becomes a new type that can be used to declare variables and delineate objects”. In other words, different objects of the same type (created from the same class), as in the case of a “pen”, can be created and may share the same behaviors, but each one will have different values ??for its attributes, making them unique. For example, when creating Pen A:

With these definitions in mind, when designing a class, one must reflect on what the object knows about itself and what it does (BATES, Bert; SIERRA, Kathy, 2005). What it knows about itself we call instance variables (state) and what it does are its methods (behavior). The class summarizes the structure and behavior that the object must have. When creating an object from the class, it will be constructed with the same general characteristics described in the class, representing a concrete instance of the abstract concept. However, each object will have its own values ??for attributes, reflecting its unique characteristics.

Class or object: Who is born first?

By understanding the class as an abstract “template” for the construction of the object, it becomes, in fact, the foundation, while the object is the concretization of this model. In other words, the class is born first and establishes itself as a type of object. It is not possible to create an object without a class existing, as the class provides the necessary structure for its creation. Thus, the class represents the starting point, while the object is the materialization of this project into a real and usable instance within the program.

Now, we can apply the concept of class and object directly to the code, with a practical example of how to model a car in object-oriented programming.

Firstly, we must ask ourselves: what do we know about cars? What does every car have? It has doors, runs on alcohol, gasoline or other fuels, can be automatic or manual, has a model, color and passenger capacity. These characteristics represent the state of the car, that is, the attributes that define it.

And what can he do? It can accelerate, brake, start, stop, honk, open the doors or activate the headlights. These actions represent the behavior of the car, that is, the methods that describe what it is capable of performing.

Below, we have the implementation of a Car as a class (Car), combining its attributes and methods. Following good practices, we put all the code in English:

public class Car {

    private String model;
    private String color;
    private String fuelType;
    private int passengerCapacity;

    public Car(String model, String color, String fuelType, int passengerCapacity) {
        this.model = model;
        this.color = color;
        this.fuelType = fuelType;
        this.passengerCapacity = passengerCapacity;
    }

    public void accelerate() {
        System.out.println("The car is accelerating.");
    }

    public void brake() {
        System.out.println("The car is braking.");
    }

    public void start() {
        System.out.println("The car is started.");
    }

    public void stop() {
        System.out.println("The car is stopped.");
    }

    public void honk() {
        System.out.println("The car is honking.");
    }

    public void displayDetails() {
        System.out.println("Model: " + model);
        System.out.println("Color: " + color);
        System.out.println("Fuel Type: " + fuelType);
        System.out.println("Passenger Capacity: " + passengerCapacity);
    }
}

Now, let's create a Car object from the Car class to use it in our code, and thus demonstrate the function of the class as a model for building the object and the object as the real version created from that model.

public class Main {
    public static void main(String[] args) {

        Car carA = new Car("Fusca", "Blue", "Gasoline", 4);

        carA.displayDetails();

        carA.start();
        carA.accelerate();
        carA.honk();
        carA.brake();
        carA.stop();
    }
}

In this example, we demonstrate that when we design a class, we are, in fact, creating an abstract model that can be implemented in multiple instances, each with its own data. This is the essence of Object Oriented Programming: transforming abstract ideas into concrete representations for application in code.

Now that you know how classes and objects work, what other objects could you represent in code? And for those who already have extensive experience: what was the most creative or challenging class you've ever created in a project?

Sources:

DEITEL, Paul; DEITEL, Harvey. Java: how to program. S?o Paulo: Pearson
Education do Brasil, 2017.

SIERRA, Kathy; BATES, Bert. Use Your Head! Java. 2ndEd. Rio de Janeiro: Editora Alta Books, 2005.

The above is the detailed content of 'I fished, Java!': Class and Object in Focus: From Abstraction to Reality. For more information, please follow other related articles on the PHP Chinese website!