Java Overview

1. Installation & Configuration:

- JDK (Java Development Kit) includes the tools for writing and compiling Java programs.
JRE (Java Runtime Environment) is needed to run Java applications. JIT (Just-In-Time)
compiler optimizes code execution, and the Garbage Collector automatically manages
memory by clearing unused objects.
- To run a Java program, the main class contains the main method, and the Java compiler
translates the code into bytecode that runs on the Java Virtual Machine (JVM).
2. IDEs Supporting Java:
- Integrated Development Environments (IDEs) like IntelliJ IDEA, Eclipse, and NetBeans help
with writing, debugging, and running Java code.
3. Variable Types & Keywords:
- Java has primitive data types such as int, boolean, char, and float. Reserved keywords like
public, static, and void have predefined meanings in the language.
4. Operators & Exception Handling:
- Java supports arithmetic, logical, and relational operators.
- The try-catch-finally structure is used to handle exceptions, with common ones being
NullPointerException, ArrayIndexOutOfBoundsException, etc.

Programming Paradigms
1. Structured Programming:
- Focuses on dividing a program into small modules using control structures like loops and
conditions.
2. Object-Oriented Programming (OOP):
- Based on creating objects which represent real-world entities. The key principles include
encapsulation, inheritance, polymorphism, and abstraction.
3. Functional Programming:
- Emphasizes immutability and pure functions where outputs depend only on inputs without
changing state.
Object-Oriented Programming (OOP)
1. Overview & UML:
- OOP structures code around objects, with classes defining their structure. UML (Unified
Modeling Language) helps visualize class relationships and interactions.
2. Abstraction:
- Concept: Hides complexity and shows only the essential features of an object.
- Example: Think of a car. You don’t need to understand how the engine works to drive it; you
just need to know that pressing the pedal makes it go, and turning the wheel changes direction.
The complex details are hidden from the user.
• Abstract class Car could have abstract methods like accelerate() and brake(). Specific
types of cars (like ElectricCar or GasCar) would implement these methods with details.
3. Inheritance:
- Concept: A class can inherit properties and methods from another class.
- Example: A Dog class can inherit from a general Animal class. The Animal class may have
methods like eat() and sleep(), and the Dog class can inherit these, while also adding its own
method, like bark().
• Dog "is a type of" Animal, so it inherits common behaviors while also having its own
unique features.
4. Encapsulation:
- Concept: Restricts access to the internal details of an object.
- Example: Imagine a bank account object. The balance is private and can only be accessed
or modified via public methods like deposit() and withdraw(). This ensures that users can’t
directly modify the balance.
• Access to sensitive data is controlled using getters and setters.
5. Polymorphism:
- Concept: Allows one interface to be used for a general class of actions. The exact behavior
is determined by the object that is invoking the method.
- Example: A method makeSound() might be defined in an Animal class, but every subclass
(like Dog or Cat) can implement it differently (e.g., Dog barks, Cat meows). You can call
makeSound() on any animal, and it will behave according to the specific type of animal.
6. OOP Pillars in Action:
- Combining all: Imagine a Vehicle superclass that is inherited by subclasses Car, Bicycle, and
Airplane. These subclasses inherit methods like start() and stop(), but they implement these
methods differently depending on the vehicle. The internal details (engine, pedals, wings) are
encapsulated from the user. An abstract method move() can be defined in Vehicle and each
subclass would provide its specific implementation.

SOLID Principles
1. Single Responsibility Principle (SRP):
- Concept: A class should have only one reason to change, meaning it should only have one
responsibility.
- Example: Think of a book class. If the class is responsible for both storing book information
and printing the book details, it violates SRP. Instead, create a Book class to store book
information and a separate BookPrinter class to handle printing. Each class now has a single
responsibility.
2. Open-Closed Principle (OCP):
- Concept: Software entities (classes, modules, functions) should be open for extension, but
closed for modification.
- Example: Suppose you have a Shape class with methods for drawing different shapes (circle,
square, etc.). Instead of modifying this class every time you add a new shape, you can create
a draw() method in the Shape class and extend it by adding new subclasses for each shape
(e.g., Circle, Square), which overrides draw().
3. Liskov Substitution Principle (LSP):
- Concept: Subtypes should be substitutable for their base types without altering the
correctness of the program.
- Example: If you have a Bird class with a fly() method, you might be tempted to create a
Penguin subclass. However, since penguins can’t fly, substituting a Penguin for a Bird would
break the fly() method. This violates LSP because the Penguin does not fit the expectations set
by the Bird class.
4. Interface Segregation Principle (ISP):
- Concept: Clients should not be forced to implement interfaces they don't use. It’s better to
have many small, specific interfaces rather than one large, general-purpose interface.
- Example: Imagine a Vehicle interface with methods like fly(), drive(), and sail(). A car doesn’t
need fly() or sail(). Instead of having one large interface, break it down into smaller ones like
Drivable, Flyable, and Sailable. The Car class would implement Drivable, the Plane class would
implement Flyable, etc.
5. Dependency Inversion Principle (DIP):
- Concept: High-level modules should not depend on low-level modules. Both should depend
on abstractions.
- Example: Imagine a Notification system where you send notifications via EmailService or
SMSService. Instead of Notification depending directly on EmailService or SMSService, you
create an INotificationService interface that both EmailService and SMSService implement.
Now, Notification depends on the abstraction (INotificationService) rather than the concrete
implementations, making it easier to switch or add new notification services.

Java Data Structures

1. Dynamic Data Structures:
- Examples include ArrayList and LinkedList. Dynamic structures grow and shrink in size as
needed. They are flexible but may have slower performance when resizing or traversing.
2. Static Data Structures:
- Examples include arrays. They have a fixed size and are efficient in terms of memory
allocation, but they lack flexibility in managing variable amounts of data.

OOP with Java

1. Fields & Properties:
- Fields represent the attributes of a class. Java uses constructors to initialize objects, while
properties or fields can store data.
2. Values & Reference Types:
- Java distinguishes between value types (primitive data types) and reference types (objects).
Objects hold references to memory locations, while primitives store actual values.
3. Constructors:
- Constructors initialize new objects. Java supports overloading constructors with different
parameter lists to create objects in multiple ways.
4. Static Variables & Classes:
- Static variables are shared across all instances of a class, while static methods or classes
belong to the class itself, not to any specific instance.
5. Method Overloading & Overriding:
- Overloading refers to having multiple methods with the same name but different parameters.
Overriding allows a subclass to provide a specific implementation for a method inherited from
its superclass.

Debugging in Java
1. Remote Debugging & Logs:
- Remote debugging allows developers to debug a running application on another machine,
while logging provides a way to capture the state of the application as it runs.
2. Console Prints & Breakpoints:
- Console prints (System.out.println) help during debugging by outputting variable states, and
breakpoints stop the program execution at specified points to inspect the code’s behavior.

Component Principles
1. Cohesion vs Coupling:
- Cohesion measures how related and focused the responsibilities of a class are. High
cohesion is preferred.
- Coupling measures how dependent classes are on each other. Loose coupling is ideal to
reduce the ripple effect of changes.

Spring Boot
1. Overview:
- Spring Boot is a framework built on top of Spring that simplifies application setup and
development by providing auto-configuration, starters, and embedded servers.
2. Beans & Configuration:
- Beans in Spring are objects managed by the Spring IoC (Inversion of Control) container. In
Spring Boot, beans are automatically configured using annotations (@Bean, @Component,
@Service, etc.), making it easier to manage dependencies.
- Beans are typically injected via constructor or setter methods, enabling loose coupling.
3. Spring vs Spring Boot:
- Spring requires manual configuration of beans and dependencies, whereas Spring Boot
simplifies this with auto-configuration and pre-configured settings.
- Spring Boot starters are convenient dependencies that provide everything needed for a
particular functionality, like web applications (spring-boot-starter-web) or JPA (spring-boot-
starter-data-jpa).

Software Architecture
1. Common Architectures:
- Monolithic: A single-tiered application where all components are interconnected and
interdependent.
- N-Tier: Separates the application into layers such as presentation, business logic, and data
access.
- Microservices: A collection of small, loosely coupled services, each handling a specific
functionality.
2. Clean Architecture:
- Clean architecture emphasizes separation of concerns and the independence of business
logic from frameworks, databases, and UI. It helps in keeping the system maintainable and
scalable.
3. Component Design Principles:
- Composite: Combines objects into tree structures to represent part-whole hierarchies.
- Decorator: Dynamically adds behavior to an object without modifying its structure.
- Adapter: Converts the interface of a class into another interface the client expects.
- Factory: Creates objects without specifying the exact class to be instantiated.
4. Observer, Facade, Singleton:
- Observer: A design pattern where objects (observers) are notified when another object
(subject) changes its state.
- Facade: Provides a simplified interface to a complex system.
- Singleton: Ensures that a class has only one instance and provides a global point of access
to it.

Clean Code
- Readable and Maintainable Code: Writing code that is easy to understand and maintain is
crucial. This includes clear naming conventions, short and well-focused methods, and reducing
complexity. Following best practices from Robert C. Martin’s Clean Code improves collaboration
and reduces technical debt.
- Error Handling: Always handle errors properly using exceptions and avoid returning error
codes.
- Code Smells: Be vigilant for anti-patterns like long methods, large classes, and duplicated
code, and refactor when necessary.
Design Patterns
1. Creational Patterns:
• Factory: Creates objects without exposing the instantiation logic.
• Singleton: Ensures a class has only one instance and provides global access.
2. Structural Patterns:
• Adapter: Converts one interface into another expected by the client.
• Facade: Simplifies a complex subsystem by providing a unified interface.
3. Behavioral Patterns:
• Observer: Objects subscribe to and receive updates from another object when its state
changes.
• Strategy: Encapsulates algorithms into interchangeable objects.

Clean Architecture
- Separation of Concerns: Clean Architecture ensures business logic is independent of
frameworks, databases, and UI. Each layer of the system (e.g., use cases, entities, controllers)
should only depend on abstractions, making the system more maintainable, testable, and
scalable.
- Core Concepts: Clean Architecture emphasizes the use of interfaces and dependency
inversion to ensure the application remains flexible and easy to extend.

Servlets and JSP (Java Server Pages)

- Servlets: Java Servlets are used to handle client requests and generate dynamic web content
on the server. They are the foundation of Java’s server-side web technologies, providing
methods like doGet() and doPost() to handle HTTP requests.
- JSP: Java Server Pages allow embedding Java code within HTML to generate dynamic web
pages. JSPs are compiled into Servlets under the hood and can be combined with Servlets to
process data and create web applications.
- General Use: While still part of the Java EE stack, modern development often replaces them
with frameworks like Spring MVC for easier development and more features.