Java Object-Oriented Programming: From Zero to

Advanced
Table of Contents
1. Introduction to Object-Oriented Programming
2. Basic OOP Concepts in Java
3. Classes and Objects
4. The Four Pillars of OOP
5. Advanced OOP Concepts
6. Exception Handling
7. Generics and Collections
8. Design Patterns
9. SOLID Principles
10. Best Practices and Interview Preparation

1. Introduction to Object-Oriented Programming

Object-Oriented Programming (OOP) is a programming paradigm that uses objects to design applications and
computer programs. It utilizes several key concepts including encapsulation, inheritance, polymorphism, and
abstraction [1] [2] .

What is OOP?
OOP is a programming methodology that organizes software design around data, or objects, rather than functions
and logic. An object can be defined as a data field that has unique attributes and behavior [2] .

Why OOP?
Modularity: Code is structured in logical units
Reusability: Write once, use many times
Maintainability: Easy to update and modify
Scalability: Easy to extend functionality
Security: Data hiding prevents unauthorized access [3]
Key Benefits of OOP in Java
Structures code into logical units (classes and objects)
Keeps related data and methods together (encapsulation)
Makes code modular, reusable and scalable
Prevents unauthorized access to data
Follows the DRY (Don't Repeat Yourself) principle [3]

2. Basic OOP Concepts in Java

2.1 What is Java?

Java is a class-based, object-oriented programming language designed for platform independence through the
"write once, run anywhere" principle [2] .

2.2 Java Virtual Machine (JVM)

The JVM is a runtime environment that executes Java bytecode, providing platform independence and memory
management [2] .

3. Classes and Objects

3.1 Classes
A class is a user-defined blueprint or prototype from which objects are created. It represents the set of properties
or methods that are common to all objects of one type [3] .

Class Declaration Components:

Modifiers: Access level (public, private, etc.)
Class name: Should begin with capital letter
Superclass: If extending another class (using extends)
Interfaces: If implementing interfaces (using implements)
Body: Surrounded by braces { } [3]

Example:

public class Employee {

// Instance variables
private String name;
private float salary;

// Constructor
public Employee(String name, float salary) {
this.name = name;
 this.salary = salary;
}

// Getter methods
public String getName() { return name; }
public float getSalary() { return salary; }

// Setter methods
public void setName(String name) { this.name = name; }
public void setSalary(float salary) { this.salary = salary; }

// Instance method
public void displayDetails() {
System.out.println("Employee: " + name);
System.out.println("Salary: " + salary);
}
}

3.2 Objects
An object is a basic unit of OOP that represents real-life entities. Objects consist of:

State: Represented by attributes/fields

Behavior: Represented by methods
Identity: Unique name that distinguishes it from other objects [3]

Creating Objects:

Employee emp = new Employee("John", 50000.0f);

emp.displayDetails();

3.3 Constructors
Constructors are special methods used to initialize objects. They have the same name as the class and no return
type [2] .

Types of Constructors:
1. Default Constructor: No parameters
2. Parameterized Constructor: Takes parameters
3. Copy Constructor: Creates object from another object

public class Car {

private String model;

// Default constructor
public Car() {
this.model = "Unknown";
}
 // Parameterized constructor
public Car(String model) {
this.model = model;
}
}

3.4 Access Modifiers

Access modifiers control the accessibility of classes, variables, methods, and constructors [4] [5] .

Modifier Description Accessible From

public No restrictions Anywhere

private Same class only Same class

protected Same package + subclasses Package + inheritance

default Same package only Same package

Example:

public class AccessExample {

public String publicVar = "Accessible everywhere";
private String privateVar = "Only within this class";
protected String protectedVar = "Package and subclasses";
String defaultVar = "Same package only";
}

4. The Four Pillars of OOP

4.1 Encapsulation
Encapsulation is the binding of data and methods together in a class while restricting direct access using access
modifiers [1] [6] .

Key Benefits:
Data Hiding: Internal details are hidden
Controlled Access: Access through getter/setter methods
Validation: Input validation in setter methods
Modularity: Changes don't affect other parts [7]
Example:

public class BankAccount {

private double balance; // Private variable

public void setBalance(double balance) {

if (balance > 0) {
this.balance = balance;
} else {
System.out.println("Invalid balance amount");
}
}

public double getBalance() {

return balance;
}
}

4.2 Inheritance
Inheritance is a mechanism where one class acquires properties and behaviors of another class. It establishes an
IS-A relationship [8] [9] .

Types of Inheritance in Java:

1. Single Inheritance: One class extends another
2. Multilevel Inheritance: Chain of inheritance
3. Hierarchical Inheritance: Multiple classes extend one parent
4. Multiple Inheritance: Through interfaces only [10] [11]

Example:

// Parent class
class Animal {
protected String name;

public void eat() {

System.out.println(name + " is eating");
}
}

// Child class
class Dog extends Animal {
public Dog(String name) {
this.name = name;
}

public void bark() {

System.out.println(name + " is barking");
}
 @Override
public void eat() {
System.out.println(name + " is eating dog food");
}
}

Multiple Inheritance via Interfaces:

interface Walkable {
void walk();
}

interface Swimmable {
void swim();
}

class Duck implements Walkable, Swimmable {

public void walk() {
System.out.println("Duck is walking");
}

public void swim() {

System.out.println("Duck is swimming");
}
}

4.3 Polymorphism
Polymorphism means "many forms" - the ability of objects to take multiple forms [12] [13] [14] .

Types of Polymorphism:

1. Compile-time Polymorphism (Static Binding)

Method Overloading: Same method name, different parameters

class Calculator {
public int add(int a, int b) {
return a + b;
}

public double add(double a, double b) {

return a + b;
}

public int add(int a, int b, int c) {

return a + b + c;
}
}
2. Runtime Polymorphism (Dynamic Binding)
Method Overriding: Child class redefines parent method

class Vehicle {
public void start() {
System.out.println("Vehicle starting");
}
}

class Car extends Vehicle {

@Override
public void start() {
System.out.println("Car engine starting");
}
}

public class Test {

public static void main(String[] args) {
Vehicle vehicle = new Car(); // Upcasting
vehicle.start(); // Calls Car's start method
}
}

4.4 Abstraction
Abstraction hides implementation details while showing essential features. It focuses on WHAT an object does
rather than HOW it does it [8] [15] .

Ways to Achieve Abstraction:

1. Abstract Classes:

abstract class Shape {

protected String color;

// Abstract method
public abstract double calculateArea();

// Concrete method
public void setColor(String color) {
this.color = color;
}
}

class Circle extends Shape {

private double radius;

public Circle(double radius) {

this.radius = radius;
}

@Override
 public double calculateArea() {
return Math.PI * radius * radius;
}
}

2. Interfaces:

interface Drawable {
void draw(); // Implicitly public and abstract

// Default method (Java 8+)

default void display() {
System.out.println("Displaying shape");
}

// Static method (Java 8+)

static void info() {
System.out.println("Shape information");
}
}

5. Advanced OOP Concepts

5.1 Interfaces vs Abstract Classes

Feature Interface Abstract Class

Multiple inheritance Yes No

Constructor No Yes

Instance variables Only constants Yes

Access modifiers Public by default All types

When to use Contract definition Partial implementation

5.2 Java 8+ Interface Features

Default Methods:

interface Vehicle {
void start();

default void honk() {

System.out.println("Honking...");
}
}
Static Methods:

interface MathUtils {
static int add(int a, int b) {
return a + b;
}
}

// Usage: MathUtils.add(5, 3);

5.3 Method Overriding Rules

1. Method signature must be identical
2. Return type must be same or covariant
3. Access modifier cannot be more restrictive
4. Cannot override static, final, or private methods
5. Exceptions: Can throw same, subclass, or no exception [16]

6. Exception Handling
Exception handling provides a mechanism to handle runtime errors gracefully, ensuring program continues
execution [17] [18] .

6.1 Exception Hierarchy

Throwable
├── Error (System-level issues)
└── Exception
├── RuntimeException (Unchecked)
└── Other Exceptions (Checked)

6.2 Exception Handling Keywords

Keyword Purpose

try Contains code that might throw exception

catch Handles specific exceptions

finally Executes regardless of exception

throw Manually throws exception

throws Declares exceptions method might throw

6.3 Try-Catch-Finally Example

public class ExceptionExample {

public void processData() {
try {
int result = 10 / 0; // May throw exception
System.out.println("Result: " + result);
} catch (ArithmeticException e) {
System.out.println("Cannot divide by zero: " + e.getMessage());
} catch (Exception e) {
System.out.println("General exception: " + e.getMessage());
} finally {
System.out.println("Cleanup code executes always");
}
}
}

6.4 Custom Exceptions

class InsufficientFundsException extends Exception {

public InsufficientFundsException(String message) {
super(message);
}
}

class BankAccount {
private double balance;

public void withdraw(double amount) throws InsufficientFundsException {

if (amount > balance) {
throw new InsufficientFundsException("Insufficient funds");
}
balance -= amount;
}
}

7. Generics and Collections

7.1 Generics
Generics provide type safety and eliminate the need for casting [19] [20] .

Generic Classes:

public class Box<T> {

private T content;

public void set(T content) {

this.content = content;
}
 public T get() {
return content;
}
}

// Usage
Box<String> stringBox = new Box<>();
stringBox.set("Hello");
String value = stringBox.get(); // No casting needed

Generic Methods:

public static <T> void swap(T[] array, int i, int j) {

T temp = array[i];
array[i] = array[j];
array[j] = temp;
}

7.2 Wildcards

Upper Bounded Wildcards:

// Accepts List of Number or its subtypes

public void processNumbers(List numbers) {
for (Number num : numbers) {
System.out.println(num.doubleValue());
}
}

Lower Bounded Wildcards:

// Accepts List of Integer or its supertypes

public void addIntegers(List list) {
list.add(42);
}

7.3 Collections Framework

List Interface:

List<String> arrayList = new ArrayList<>(); // Dynamic array

List<String> linkedList = new LinkedList<>(); // Doubly-linked list
List<String> vector = new Vector<>(); // Thread-safe
Set Interface:

Set<String> hashSet = new HashSet<>(); // No duplicates, no order

Set<String> treeSet = new TreeSet<>(); // Sorted set
Set<String> linkedHashSet = new LinkedHashSet<>(); // Maintains insertion orde

Map Interface:

Map<String, Integer> hashMap = new HashMap<>();

Map<String, Integer> treeMap = new TreeMap<>(); // Sorted keys
Map<String, Integer> linkedHashMap = new LinkedHashMap<>(); // Insertion order

7.4 Stream API (Java 8+)

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

// Filter even numbers, square them, and collect

List<Integer> result = numbers.stream()
.filter(n -> n % 2 == 0)
.map(n -> n * n)
.collect(Collectors.toList());

// Find sum of all elements

int sum = numbers.stream()
.reduce(0, Integer::sum);

8. Design Patterns
Design patterns are reusable solutions to commonly occurring problems in software design [21] [22] .

8.1 Singleton Pattern

Ensures only one instance of a class exists [22] [23] .

Thread-Safe Implementation:

public class Singleton {

private static volatile Singleton instance;

private Singleton() {}

public static Singleton getInstance() {

if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
 return instance;
}
}

8.2 Factory Pattern

Creates objects without exposing creation logic [21] [24] .

interface Animal {
void makeSound();
}

class Dog implements Animal {

public void makeSound() { System.out.println("Woof!"); }
}

class Cat implements Animal {

public void makeSound() { System.out.println("Meow!"); }
}

class AnimalFactory {
public static Animal createAnimal(String type) {
switch (type.toLowerCase()) {
case "dog": return new Dog();
case "cat": return new Cat();
default: throw new IllegalArgumentException("Unknown animal type");
}
}
}

8.3 Observer Pattern

Defines one-to-many dependency between objects [23] .

interface Observer {
void update(String message);
}

class Subject {
private List<Observer> observers = new ArrayList<>();

public void addObserver(Observer observer) {

observers.add(observer);
}

public void notifyObservers(String message) {

observers.forEach(observer -> observer.update(message));
}
}
9. SOLID Principles
SOLID is an acronym for five design principles that make software designs more understandable, flexible, and
maintainable [25] [26] [27] .

9.1 Single Responsibility Principle (SRP)

A class should have only one reason to change [27] .

// Bad - Multiple responsibilities

class User {
public void saveToDatabase() { /* ... */ }
public void sendEmail() { /* ... */ }
public void generateReport() { /* ... */ }
}

// Good - Single responsibility

class User {
private String name;
// ... user properties and methods
}

class UserRepository {
public void save(User user) { /* ... */ }
}

class EmailService {
public void sendEmail(User user) { /* ... */ }
}

9.2 Open/Closed Principle (OCP)

Software entities should be open for extension but closed for modification [27] .

interface Shape {
double calculateArea();
}

class Rectangle implements Shape {

private double width, height;

public double calculateArea() {

return width * height;
}
}

class Circle implements Shape {

private double radius;

public double calculateArea() {

return Math.PI * radius * radius;
}
}
 class AreaCalculator {
public double calculateTotalArea(List<Shape> shapes) {
return shapes.stream()
.mapToDouble(Shape::calculateArea)
.sum();
}
}

9.3 Liskov Substitution Principle (LSP)

Objects of a superclass should be replaceable with objects of a subclass [27] .

9.4 Interface Segregation Principle (ISP)

Clients should not be forced to depend on interfaces they don't use [27] .

// Bad - Fat interface

interface Worker {
void work();
void eat();
void sleep();
}

// Good - Segregated interfaces

interface Workable {
void work();
}

interface Eatable {
void eat();
}

interface Sleepable {
void sleep();
}

class Human implements Workable, Eatable, Sleepable {

public void work() { /* ... */ }
public void eat() { /* ... */ }
public void sleep() { /* ... */ }
}

class Robot implements Workable {

public void work() { /* ... */ }
}

9.5 Dependency Inversion Principle (DIP)

High-level modules should not depend on low-level modules. Both should depend on abstractions [25] [26] [27] .

// Bad - Direct dependency

class EmailService {
public void sendEmail(String message) { /* ... */ }
 }

class NotificationManager {
private EmailService emailService = new EmailService();

public void sendNotification(String message) {

emailService.sendEmail(message);
}
}

// Good - Dependency inversion

interface NotificationService {
void send(String message);
}

class EmailService implements NotificationService {

public void send(String message) { /* send email */ }
}

class SMSService implements NotificationService {

public void send(String message) { /* send SMS */ }
}

class NotificationManager {
private NotificationService notificationService;

public NotificationManager(NotificationService service) {

this.notificationService = service;
}

public void sendNotification(String message) {

notificationService.send(message);
}
}

10. Best Practices and Interview Preparation

10.1 OOP Best Practices

1. Follow Naming Conventions:
Classes: PascalCase (e.g., StudentManager)
Methods/Variables: camelCase (e.g., calculateTotal)
Constants: UPPER_CASE (e.g., MAX_SIZE)
2. Use Composition over Inheritance when possible
3. Favor Immutable Objects for thread safety
4. Keep Classes Small and Focused
5. Use Interface for Contracts
6. Handle Exceptions Properly
 7. Write Unit Tests

10.2 Common Interview Questions

Basic Level:
1. What are the four pillars of OOP?
Encapsulation, Inheritance, Polymorphism, Abstraction [1] [28]
2. What is the difference between overloading and overriding?
Overloading: Same method name, different parameters (compile-time)
Overriding: Child class redefines parent method (runtime) [12] [16]

3. What is encapsulation?
Binding data and methods together while restricting access [1] [7]

Intermediate Level:
4. Explain polymorphism with examples
Ability to take multiple forms through method overloading/overriding [13] [14]

5. What is abstraction and how is it achieved in Java?

Hiding implementation details, achieved via abstract classes and interfaces [8] [15]
6. Difference between abstract class and interface
Abstract class: Partial implementation, single inheritance
Interface: Contract definition, multiple inheritance [15] [29]

Advanced Level:
7. Explain SOLID principles
Five design principles for better software design [25] [26] [27]
8. What are design patterns? Explain Singleton and Factory
Reusable solutions to common problems [21] [22] [23]
9. How does exception handling work in Java?
Try-catch-finally mechanism for error handling [17] [18]

10. What are generics and their benefits?

Type safety and code reusability [19] [20]
10.3 Coding Best Practices for Interviews
1. Always validate input parameters
2. Handle edge cases
3. Use meaningful variable names
4. Add comments for complex logic
5. Consider time and space complexity
6. Write clean, readable code

10.4 Common Mistakes to Avoid

1. Exposing internal state without proper validation
2. Not overriding equals() and hashCode() together
3. Using inheritance for code reuse instead of composition
4. Ignoring exception handling
5. Not following naming conventions
6. Creating god classes with too many responsibilities

10.5 Advanced Topics to Master

1. Lambda Expressions and Functional Programming
2. Stream API and Parallel Processing
3. Concurrent Programming
4. Design Patterns (Gang of Four)
5. Microservices and Clean Architecture
6. Testing Strategies (Unit, Integration, Mocking)

Conclusion
This comprehensive guide covers Java OOP from fundamental concepts to advanced design principles. Master
these concepts through practice, code reviews, and real-world applications. Remember that OOP is not just about
syntax—it's about designing maintainable, scalable, and robust software systems.

Key Takeaways:
1. Understand the fundamentals: Classes, objects, and the four pillars
2. Practice inheritance and polymorphism with real examples
3. Master exception handling for robust applications
4. Learn generics and collections for type-safe code
5. Apply design patterns for reusable solutions
6. Follow SOLID principles for better design
 7. Practice coding problems regularly
8. Stay updated with Java language features
Continue practicing with hands-on projects and challenges to reinforce these concepts. Good luck with your
interviews and Java development journey!

References
[1] AlmaBetter - Java OOPs Interview Questions and Answers 2025
[2] FreeCodeCamp - Object-Oriented Programming in Java – A Beginner's Guide
[8] GeeksforGeeks - Understanding Encapsulation, Inheritance, Polymorphism, Abstraction in OOPs
[28] GeeksforGeeks - 30 OOPs Interview Questions and Answers [2025 Updated]
[3] GeeksforGeeks - Java OOP(Object Oriented Programming) Concepts
[30] Nerd Vision - Polymorphism, Encapsulation, Data Abstraction and Inheritance
[9] Codefinity - The 80 Top Java Interview Questions and Answers
[31] W3Schools - Java OOP (Object-Oriented Programming)
[6] ScholarHat - OOPs Concepts in Java
[32] PrepInsta - Top 50+ OOPS Interview Questions and Answers(2025)
[33] [34] [35] [36] [37] [38] [39] [40] [41] [42] [43] [44] [45] [46] [47] [48] [49] [50] [51] [52] [53] [54] [55] [56] [57] [58] [59] [60] [61] [62] [63]
[64] [65] [66] [67] [68] [69] [70] [71] [72] [73] [74] [75] [76] [77] [78] [79]

1. https://www.almabetter.com/bytes/articles/java-oops-interview-questions
2. https://www.freecodecamp.org/news/object-oriented-programming-concepts-java/
3. https://www.geeksforgeeks.org/java/object-oriented-programming-oops-concept-in-java/
4. https://codefinity.com/courses/v2/0bfa1111-8677-478f-bcd3-315dff1d7d40/b1441a35-60ec-4466-8425-
835111d22ecf/1766e3ca-62c3-4d39-a7cf-3c355af5357f
5. https://www.geeksforgeeks.org/java/access-modifiers-java/
6. https://www.scholarhat.com/tutorial/java/java-oops-concept-encapsulation-abstraction-inheritence-poly
morphism
7. https://techaffinity.com/blog/oops-concepts-in-java/
8. https://www.geeksforgeeks.org/java/understanding-encapsulation-inheritance-polymorphism-abstractio
n-in-oops/
9. https://codefinity.com/blog/The-80-Top-Java-Interview-Questions-and-Answers
10. https://www.geeksforgeeks.org/java/how-to-implement-multiple-inheritance-by-using-interfaces-in-jav
a/
11. https://www.scaler.com/topics/multiple-inheritance-in-java-using-interface/
12. https://stackoverflow.com/questions/20783266/what-is-the-difference-between-dynamic-and-static-pol
ymorphism-in-java
13. https://www.geekster.in/articles/polymorphism-in-java/
14. https://www.geeksforgeeks.org/java/polymorphism-in-java/
15. https://www.geeksforgeeks.org/are-all-methods-in-a-java-interface-are-abstract/
16. https://www.geeksforgeeks.org/java/difference-between-method-overloading-and-method-overriding-i
n-java/
17. https://www.scholarhat.com/tutorial/java/exception-handling-in-java
18. https://www.geeksforgeeks.org/java/exceptions-in-java/
19. https://stackoverflow.com/questions/3486689/java-bounded-wildcards-or-bounded-type-parameter
20. https://www.codejava.net/collections-tutorials
21. https://www.geeksforgeeks.org/java/difference-between-singleton-and-factory-design-pattern-in-java/
22. https://www.geeksforgeeks.org/system-design/singleton-design-pattern/
23. https://www.maasmind.com/blog/java-design-patterns-singleton-factory-and-observer/
24. https://javatechonline.com/creational-design-patterns-in-java/
25. https://www.digitalocean.com/community/conceptual-articles/s-o-l-i-d-the-first-five-principles-of-object
-oriented-design
26. https://stackify.com/dependency-inversion-principle/
27. https://dev.to/chhavirana/understanding-solid-principles-in-java-with-real-life-examples-1ked
28. https://www.geeksforgeeks.org/interview-prep/oops-interview-questions/
29. https://docs.oracle.com/javase/tutorial/java/IandI/abstract.html
30. https://www.nerd.vision/post/polymorphism-encapsulation-data-abstraction-and-inheritance-in-object-o
riented-programming
31. https://www.w3schools.com/java/java_oop.asp
32. https://prepinsta.com/interview-preparation/technical-interview-questions/oops/
33. https://www.youtube.com/watch?v=Af3s3KsxStY
34. https://www.interviewbit.com/oops-interview-questions/
35. https://docs.oracle.com/javase/tutorial/java/concepts/index.html
36. https://beginnersbook.com/2013/03/oops-in-java-encapsulation-inheritance-polymorphism-abstraction/
37. https://www.edureka.co/blog/interview-questions/oops-interview-questions/
38. https://www.baeldung.com/java-oop
39. https://www.youtube.com/watch?v=46T2wD3IuhM
40. https://www.lambdatest.com/learning-hub/oops-interview-questions
41. https://www.codecademy.com/learn/learn-java
42. https://www.w3schools.com/java/java_modifiers.asp
43. https://stackoverflow.com/questions/74812454/is-method-overloading-and-method-overriding-both-dyn
amic-polymorphism
44. https://www.geeksforgeeks.org/java/interfaces-and-inheritance-in-java/
45. https://www.programiz.com/java-programming/access-modifiers
46. https://www.baeldung.com/java-inheritance
47. https://www.geeksforgeeks.org/java/classes-objects-java/
48. https://stackoverflow.com/questions/13389384/multiple-inheritance-on-java-interfaces
49. https://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html
50. https://docs.oracle.com/javase/tutorial/java/IandI/multipleinheritance.html
51. https://takeuforward.org/java/java-polymorphism/
52. https://www.baeldung.com/java-classes-objects
53. https://www.w3schools.com/java/java_interface.asp
54. https://www.digitalocean.com/community/tutorials/java-8-interface-changes-static-method-default-meth
od
55. https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/statements/exception-handling-stat
ements
56. https://www.geeksforgeeks.org/java/wildcards-in-java/
57. https://stackoverflow.com/questions/19998454/when-to-use-java-8-interface-default-method-vs-abstra
ct-method
58. https://docs.oracle.com/javase/tutorial/java/generics/upperBounded.html
59. https://www.geeksforgeeks.org/java/static-method-in-interface-in-java/
60. https://stackoverflow.com/questions/3779285/exception-thrown-in-catch-and-finally-clause
61. https://www.baeldung.com/java-generics-type-parameter-vs-wildcard
62. https://www.softwaretestinghelp.com/try-catch-finally-and-throw-in-java/
63. https://docs.oracle.com/javase/tutorial/java/generics/lowerBounded.html
64. https://www.baeldung.com/java-interface-default-method-vs-abstract-class
65. https://www.w3schools.com/java/java_try_catch.asp
66. https://stackoverflow.com/questions/22860582/java-generics-wildcard-vs-type-parametere
67. https://www.geeksforgeeks.org/java/java-try-catch-block/
68. https://www.slideshare.net/slideshow/lambdas-collections-framework-stream-api/252441747
69. https://www.youtube.com/watch?v=9oHY5TllWaU
70. https://www.pluralsight.com/courses/java-8-lambda-expressions-collections-streams
71. https://www.digitalocean.com/community/tutorials/java-singleton-design-pattern-best-practices-exampl
es
72. https://www.linkedin.com/advice/0/how-does-dependency-injection-relate-solid-zwobe
73. https://market.tutorialspoint.com/course/java-generics-collections-framework-and-streams-api/index.as
p
74. https://refactoring.guru/design-patterns/java
75. https://www.youtube.com/watch?v=92k5uokmW9o
76. https://www.baeldung.com/creational-design-patterns
77. https://www.baeldung.com/java-dependency-inversion-principle
78. https://www.geeksforgeeks.org/java/java-collections-interview-questions/
79. https://javatechonline.com/solid-principles-the-dependency-inversion-principle/