Java + Spring Boot Complete Guide
📘 Complete Java + Spring Boot Master Document
---
## SECTION 1: Core Java Concepts
### 1. OOPS in Java (Encapsulation, Inheritance, Polymorphism, Abstraction)
#### 1.1 Encapsulation
Encapsulation is the technique of wrapping data and code acting on the data together as a
single unit. It restricts direct access to some components and can prevent the accidental
modification of data.
```java
public class Student {
private String name;
public String getName() { return name; }
public void setName(String name) { this.name = name; }
}
```
#### 1.2 Inheritance
Inheritance enables new classes to receive or inherit the properties and methods of existing
classes. It promotes code reusability.
```java
class Animal {
void eat() { System.out.println("Eats food"); }
}
class Dog extends Animal {
void bark() { System.out.println("Barks"); }
}
```
#### 1.3 Polymorphism
Allows objects to take multiple forms. Method Overloading and Method Overriding:
```java
class Calculator {
int add(int a, int b) { return a + b; }
int add(int a, int b, int c) { return a + b + c; }
}
class Animal {
void sound() { System.out.println("Animal sound"); }
}
class Cat extends Animal {
@Override void sound() { System.out.println("Meow"); }
}
```
#### 1.4 Abstraction
Hiding implementation:
```java
abstract class Vehicle {
abstract void start();
}
class Car extends Vehicle {
void start() { System.out.println("Starts with key"); }
}
```
### 2. Access Modifiers
| Modifier | Class | Package | Subclass | World |
|-------------|-------|---------|----------|--------|
| `private` | ✅ | ❌ | ❌ |❌ |
| default | ✅ | ✅ | ❌ |❌ |
| `protected` | ✅ | ✅ | ✅ |❌ |
| `public` | ✅ | ✅ | ✅ |✅ |
### 3. Static Code in Java
```java
class Counter {
static int count = 0;
Counter() { count++; }
public static void main(String[] args) {
new Counter(); new Counter();
System.out.println("Count: " + Counter.count);
}
}
```
### 4. Functional Interface & Lambda Expression
```java
@FunctionalInterface
interface Greeting {
void sayHello();
}
public class Main {
public static void main(String[] args) {
Greeting g = () -> System.out.println("Hello!");
g.sayHello();
}
}
```
### 5. Interface vs Abstract Class
| Feature | Abstract Class | Interface |
|-----------------|-----------------------------|----------------------------|
| Methods | Abstract + Concrete | Abstract, default, static |
| Variables | Any | Only public static final |
| Inheritance | Single | Multiple |
### 6. Exception Handling
```java
try {
int a = 5 / 0;
} catch (ArithmeticException e) {
System.out.println("Error: " + e.getMessage());
}
```
### 7. Wrapper Classes
```java
int a = 5;
Integer obj = a;
```
### 8. final, this, super
```java
final int x = 10;
class Demo {
int a;
Demo(int a) { this.a = a; }
}
class Child extends Parent {
void display() {
super.display();
}
}
```
---
## SECTION 2: Spring Framework (Traditional)
Spring MVC Flow:
Client → DispatcherServlet → HandlerMapping → Controller → Service → DAO →
ViewResolver → JSP/HTML
#### web.xml
```xml
<web-app>
<servlet>
<servlet-name>dispatcher</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>dispatcher</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>
```
#### Controller
```java
@Controller
public class HelloController {
@GetMapping("/hello")
public String hello(Model model) {
model.addAttribute("msg", "Hello Spring");
return "hello";
}
}
```
---
## SECTION 3: Spring Boot
```java
@SpringBootApplication
public class MyApp {
public static void main(String[] args) {
SpringApplication.run(MyApp.class, args);
}
}
```
@RestController Example:
```java
@RestController
public class HelloController {
@GetMapping("/hello")
public String sayHello() {
return "Hello, Spring Boot!";
}
}
```
---
## SECTION 4–8: (Security, JWT, SHA, JPA, SQL, Cloud, Microservices)
[Included in previous update]
---
## SECTION 9: Testing and Deployment
### JUnit + Mockito, GitHub Actions CI/CD, Docker, Kubernetes
[Full code included in previous section]
