11.3. OOP Terminology and Concepts

A special method that is automatically called when an object is created.

class Person {
    Person() {
        System.out.println("Constructor called");
    }
}

A constructor is a unique type of method in Object-Oriented Programming (OOP) that is invoked automatically when a new instance of a class (an object) is created. It typically initializes the object’s attributes or performs any setup required before the object is ready to use.

In the example provided, the constructor for the Person class prints a message when an object is created. So, if you were to instantiate this class (i.e., create a Person object), the constructor would run, and you would see 'Constructor called' in the output.

Think of a constructor like a welcome speech at a new employee orientation. When a new employee joins the company, they are welcomed (the constructor is called), and the company provides them with all the necessary information to start their job. Similarly, the constructor initializes new objects with the specific settings they need to function correctly.

Refers to the current object instance.

The this keyword is used in OOP to refer to the current instance of the class. It helps distinguish between instance variables (attributes of the class) and parameters or local variables with the same name.

For example, if there's a parameter in a method that has the same name as an attribute of the class, this can clarify which one you're referring to. Using this.makeModel = makeModel; would set the makeModel attribute of the current object to the value of the method parameter makeModel.

Imagine you are in a room filled with multiple employees who share the same name. When you want to speak about yourself, you would say, 'I' or 'me'. In OOP, this acts like your personal identity in a room of similar names—it specifies that you are referring to your own specific instance, eliminating any confusion.

Belongs to the class rather than instance.

The static keyword indicates that a particular member (variable or method) belongs to the class itself rather than any specific instance (object) of that class. When a member is declared as static, it can be accessed without creating an instance of the class, which is useful for methods and data that are shared across all objects of that class.

For example, a static variable can hold a value common to all instances. If class Counter { static int count; } is used, count can be incremented in every instance, but it represents the same variable across all instances.

Consider a school's principal (static member) who sets rules for all students (object instances). Any change made by the principal affects all students at once. Similarly, a static variable or method in OOP is shared by all instances of a class, providing a common resource or behavior.

• final variable → constant • final method → cannot be overridden • final class → cannot be inherited

The final keyword is a modifier that can be applied to variables, methods, and classes in OOP.

1. A final variable becomes a constant, meaning once it is initialized, its value cannot change.
2. A final method cannot be overridden by subclasses, which means no child class can provide its own implementation for that method.
3. A final class cannot be extended, meaning no class can inherit from it. This is useful when you want to prevent subclassing altogether.

In terms of structure, the final keyword is used to maintain the integrity of a class design.

Think of a final variable as a package that is sealed and cannot be opened or changed. Once sealed, the contents cannot be modified. A final method is like a secret recipe that can't be altered by anyone else trying to replicate it, and a final class is akin to a prestigious award that cannot be altered or awarded to anyone else—it stands alone.

--