Understand Object-Oriented Programming and Singleton Design Pattern

Main Ideas

1. Classes and Objects

A class is a set of rules or a definition, while an object is a real instance that follows those rules.

A car provides a useful analogy: different cars are objects, while the shared idea of what counts as a car is the class. In Java, a class groups variables (data) and methods (behavior).

For example, a Person class might have fields for a person’s name, age, gender, contact number, and address. Separate objects—such as Raj and Riya—can hold different values for those fields.

2. Creating and Using Objects in Java

A class is declared with the class keyword and a name, with its contents placed between curly braces. The demonstration creates a Java project and package in Eclipse, then adds a Person class and a runner class containing main.

An object is created with the new keyword. A variable such as p1 that refers to an object is called a reference variable.

The Person fields are made private. The presenter uses encapsulation—keeping data and related methods together—and generates public getters and setters so another class can read and update the fields. Each Person object has its own data, so changing one object’s fields does not change another’s.

3. Java Memory and Execution

The presenter gives a simplified explanation of Java memory and execution:

• Stack: Manages method execution and local variables. It follows LIFO (“last in, first out”): the most recently called method finishes first.
• Heap: Stores objects and their instance fields. Each object has its own instance fields.
• Static or class-level storage: Static fields and methods are associated with the class rather than an individual object. Static members can be accessed through the class name without creating an object.

When execution starts, Java looks for main. A method call adds that method’s execution to the stack; when it finishes, execution returns to the calling method. When an object is created, the class is loaded as needed, its instance fields receive default values, and a constructor is called. Reference variables point to objects, and printing a reference may show an identifier-like value.

The presenter explains this as a way to distinguish an instance field from a parameter with the same name—for example, this.name = name. A parameterized constructor can initialize fields during object creation, avoiding separate setter calls.

The discussion of Java memory areas is simplified. In particular, the exact treatment of static data is JVM-dependent. A char field’s actual Java default is the null character ('\u0000'), not an ordinary space.

4. Static Variables and Methods

A static variable belongs to the class rather than to each object. The presenter uses a planet value shared by all people as an example: storing the same value separately in every person object would be redundant.

Static fields and methods can be accessed using the class name, subject to their access modifiers. The presenter describes static access as a “global access point”; this is an informal explanation, not a claim that every static member is accessible from everywhere.

5. Design Patterns

A design pattern is a reusable approach to structuring classes and objects to solve a recurring problem. The presenter emphasizes that a design pattern is not itself a framework or library, although frameworks and libraries may use design patterns.

6. Singleton Design Pattern

A Singleton is intended to ensure that a class has one shared instance, rather than allowing callers to create multiple instances.

The presenter derives the pattern from three main elements:

1. A private constructor, which prevents other classes from calling new on the class.
2. A private static reference field of the same class type, initially null.
3. A public static access method that creates the object the first time it is requested and returns the stored reference thereafter.

The demonstrated method checks whether the reference is null. If it is, the method creates the object; otherwise, it returns the existing one. The example requests the instance twice and shows both references pointing to the same object.

The presenter distinguishes creating an object with new from requesting the Singleton instance through its access method.

7. Suggested Uses and Benefits

The presenter identifies two benefits of the Singleton pattern:

• Limiting object creation to one shared instance.
• Providing a common access point to that instance.

Suggested uses in automation frameworks include:

• Logging: Multiple tests can write to one shared logger and log file.
• Database access: Tests can share a database connection rather than each creating a separate connection.

The video does not discuss thread-safety concerns or alternative Singleton implementations.

Speakers and Sources Featured

• Jatin Sharma — presenter and instructor.
• No other speakers or external sources are featured in the subtitles.