String name = "Alice";     // reference to String object
int[] numbers = {1, 2, 3}; // reference to array object
List<String> items = new ArrayList<>(); // reference to ArrayList

// Java 10+
var list = new ArrayList<String>();  // inferred as ArrayList<String>
var count = 0;                       // inferred as int
// Only for local variables — not fields, parameters, or return types

// Arithmetic: +, -, *, /, %
// Comparison: ==, !=, <, >, <=, >=
// Logical: &&, ||, !
// Bitwise: &, |, ^, ~, <<, >>, >>>
// Assignment: =, +=, -=, *=, /=

// == vs .equals()
String a = new String("hello");
String b = new String("hello");
a == b        // false — different objects
a.equals(b)   // true — same content

public class Vehicle {
    // Fields
    private String make;
    private int year;
    private double mileage;
    
    // Constructor
    public Vehicle(String make, int year) {
        this.make = make;
        this.year = year;
        this.mileage = 0.0;
    }
    
    // Methods
    public void drive(double km) {
        if (km < 0) throw new IllegalArgumentException("Distance must be positive");
        this.mileage += km;
    }
    
    // Getter
    public double getMileage() {
        return mileage;
    }
    
    @Override
    public String toString() {
        return String.format("%d %s (%.1f km)", year, make, mileage);
    }
}

public interface Drawable {
    void draw(Canvas canvas);
    
    // Default method (Java 8+)
    default void drawWithBorder(Canvas canvas) {
        drawBorder(canvas);
        draw(canvas);
    }
    
    // Static method
    static Drawable empty() {
        return canvas -> {}; // lambda
    }
}

public abstract class Shape {
    protected String color;
    
    public Shape(String color) {
        this.color = color;
    }
    
    // Concrete method
    public String getColor() { return color; }
    
    // Abstract — subclasses must implement
    public abstract double area();
    public abstract double perimeter();
}

public class Circle extends Shape {
    private double radius;
    
    public Circle(String color, double radius) {
        super(color);
        this.radius = radius;
    }
    
    @Override
    public double area() { return Math.PI * radius * radius; }
    
    @Override
    public double perimeter() { return 2 * Math.PI * radius; }
}

List<Shape> shapes = List.of(
    new Circle("red", 5),
    new Rectangle("blue", 3, 4)
);

for (Shape shape : shapes) {
    // Calls the correct area() based on actual type
    System.out.println(shape.area());
}

// Pre-generics (unsafe)
List list = new ArrayList();
list.add("hello");
String s = (String) list.get(0); // cast required, ClassCastException possible

// With generics (type-safe)
List<String> list = new ArrayList<>();
list.add("hello");
String s = list.get(0); // no cast needed

public class Pair<A, B> {
    private final A first;
    private final B second;
    
    public Pair(A first, B second) {
        this.first = first;
        this.second = second;
    }
    
    public A getFirst() { return first; }
    public B getSecond() { return second; }
}

// Generic method
public static <T extends Comparable<T>> T max(T a, T b) {
    return a.compareTo(b) >= 0 ? a : b;
}

// Upper bound — T must be Number or subclass
public <T extends Number> double sum(List<T> numbers) {
    return numbers.stream().mapToDouble(Number::doubleValue).sum();
}

// Multiple bounds
public <T extends Serializable & Comparable<T>> void process(T item) { ... }

// Upper bounded — read-only (producer)
void printAll(List<? extends Shape> shapes) {
    for (Shape s : shapes) System.out.println(s.area());
}

// Lower bounded — write-only (consumer)
void addCircles(List<? super Circle> list) {
    list.add(new Circle("red", 5));
}

// PECS: Producer Extends, Consumer Super

List<String> names = List.of("Alice", "Bob", "Charlie");
Set<Integer> primes = Set.of(2, 3, 5, 7, 11);
Map<String, Integer> scores = Map.of("Alice", 95, "Bob", 87);
// All throw UnsupportedOperationException on modification

// Automatically closes resources (implements AutoCloseable)
try (var reader = new BufferedReader(new FileReader("data.txt"));
     var writer = new BufferedWriter(new FileWriter("out.txt"))) {
    
    String line;
    while ((line = reader.readLine()) != null) {
        writer.write(line.toUpperCase());
        writer.newLine();
    }
} catch (IOException e) {
    logger.error("File processing failed", e);
}
// reader and writer are closed here, even if exception occurred

// Modern approach: ExecutorService
ExecutorService executor = Executors.newFixedThreadPool(4);

Future<String> future = executor.submit(() -> {
    // runs in thread pool
    return fetchData();
});

String result = future.get(); // blocks until complete
executor.shutdown();

public class Counter {
    private int count = 0;
    
    // synchronized method — only one thread at a time
    public synchronized void increment() {
        count++;
    }
    
    // Or use explicit locks for more control
    private final ReentrantLock lock = new ReentrantLock();
    
    public void incrementWithLock() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }
}

CompletableFuture<String> future = CompletableFuture
    .supplyAsync(() -> fetchUser(userId))          // async
    .thenApply(user -> user.getEmail())            // transform
    .thenCompose(email -> sendEmail(email))        // chain async
    .exceptionally(ex -> {
        logger.error("Failed", ex);
        return "fallback";
    });

// Lightweight threads — millions possible
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    List<Future<String>> futures = urls.stream()
        .map(url -> executor.submit(() -> fetch(url)))
        .toList();
    
    for (var future : futures) {
        System.out.println(future.get());
    }
}

// Before lambdas
Comparator<String> comp = new Comparator<String>() {
    @Override
    public int compare(String a, String b) {
        return a.length() - b.length();
    }
};

// With lambdas
Comparator<String> comp = (a, b) -> a.length() - b.length();

// Method reference
Comparator<String> comp = Comparator.comparingInt(String::length);

List<String> result = employees.stream()
    .filter(e -> e.getSalary() > 50000)       // filter
    .sorted(Comparator.comparing(Employee::getName)) // sort
    .map(Employee::getName)                    // transform
    .distinct()                                // deduplicate
    .limit(10)                                 // take first 10
    .collect(Collectors.toList());             // terminal operation

// Reduction
int totalSalary = employees.stream()
    .mapToInt(Employee::getSalary)
    .sum();

// Grouping
Map<Department, List<Employee>> byDept = employees.stream()
    .collect(Collectors.groupingBy(Employee::getDepartment));

Optional<User> user = findUser(id);

// Safe access
String name = user
    .map(User::getName)
    .orElse("Unknown");

// Throw if absent
User u = user.orElseThrow(() -> new NotFoundException("User " + id));

// Never do: user.get() without checking isPresent()

<!-- pom.xml -->
<project>
    <groupId>com.example</groupId>
    <artifactId>my-app</artifactId>
    <version>1.0.0</version>
    
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>3.2.0</version>
        </dependency>
    </dependencies>
</project>

mvn clean compile    # compile
mvn test             # run tests
mvn package          # build JAR/WAR
mvn install          # install to local repo

// build.gradle
plugins {
    id 'java'
    id 'org.springframework.boot' version '3.2.0'
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
}

./gradlew build      # compile + test + package
./gradlew test       # run tests
./gradlew bootRun    # run Spring Boot app

import org.junit.jupiter.api.*;
import static org.junit.jupiter.api.Assertions.*;

class CalculatorTest {
    
    private Calculator calc;
    
    @BeforeEach
    void setUp() {
        calc = new Calculator();
    }
    
    @Test
    @DisplayName("Addition of two positive numbers")
    void testAdd() {
        assertEquals(5, calc.add(2, 3));
    }
    
    @Test
    void testDivideByZero() {
        assertThrows(ArithmeticException.class, () -> calc.divide(1, 0));
    }
    
    @ParameterizedTest
    @CsvSource({"1,1,2", "0,0,0", "-1,1,0"})
    void testAddParameterized(int a, int b, int expected) {
        assertEquals(expected, calc.add(a, b));
    }
}

@ExtendWith(MockitoExtension.class)
class UserServiceTest {
    
    @Mock
    private UserRepository repository;
    
    @InjectMocks
    private UserService service;
    
    @Test
    void findUser_returnsUser_whenExists() {
        var user = new User(1L, "Alice");
        when(repository.findById(1L)).thenReturn(Optional.of(user));
        
        var result = service.findUser(1L);
        
        assertEquals("Alice", result.getName());
        verify(repository).findById(1L);
    }
}

// Interface
public interface NotificationService {
    void send(String message, String recipient);
}

// Implementation
@Service
public class EmailNotificationService implements NotificationService {
    @Override
    public void send(String message, String recipient) {
        // send email
    }
}

// Consumer — Spring injects the implementation
@RestController
public class OrderController {
    private final NotificationService notifications;
    
    // Constructor injection (preferred)
    public OrderController(NotificationService notifications) {
        this.notifications = notifications;
    }
    
    @PostMapping("/orders")
    public ResponseEntity<Order> createOrder(@RequestBody OrderRequest request) {
        Order order = processOrder(request);
        notifications.send("Order confirmed", order.getEmail());
        return ResponseEntity.ok(order);
    }
}

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

# application.yml
server:
  port: 8080
spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/mydb
    username: ${DB_USER}
    password: ${DB_PASSWORD}