# Java Programming: Comprehensive Technical Notes

## 1. Java Fundamentals

### 1.1 Basic Concepts

- Platform independence (WORA)

- JVM, JRE, and JDK

- Bytecode compilation

- Class structure

- Package organization

### 1.2 Data Types

1. **Primitive Types**

```java

byte // 8-bit signed

short // 16-bit signed

int // 32-bit signed

long // 64-bit signed

float // 32-bit floating point

double // 64-bit floating point

char // 16-bit Unicode

boolean // true/false

```

2. **Reference Types**

- Objects

- Arrays

- Strings

- Classes

- Interfaces
### 1.3 Variables & Constants

- Instance variables

- Class variables (static)

- Local variables

- Final variables

- Variable scope and lifetime

## 2. Object-Oriented Programming

### 2.1 Classes and Objects

1. **Class Components**

```java

class Example {

// Fields

private int field;

// Constructor

public Example() {}

// Methods

public void method() {}

// Nested classes

class Inner {}

```

2. **Access Modifiers**

- public

- private

- protected
 - package-private (default)

### 2.2 Inheritance

1. **Types**

- Single inheritance

- Multiple interface inheritance

- Hierarchical inheritance

2. **Keywords**

- extends

- implements

- super

- this

### 2.3 Polymorphism

1. **Method Overloading**

- Same name, different parameters

- Compile-time polymorphism

2. **Method Overriding**

- Same signature, different implementation

- Runtime polymorphism

### 2.4 Abstraction

1. **Abstract Classes**

```java

abstract class Base {

abstract void method();

void concreteMethod() {}

```
2. **Interfaces**

```java

interface Example {

void method();

default void defaultMethod() {}

static void staticMethod() {}

```

### 2.5 Encapsulation

- Data hiding

- Getter/setter methods

- Access control

- Package organization

## 3. Exception Handling

### 3.1 Exception Types

1. **Hierarchy**

- Throwable

- Error

- Exception

- RuntimeException

- Checked Exception

2. **Custom Exceptions**

```java

class CustomException extends Exception {

public CustomException(String message) {

super(message);
 }

```

### 3.2 Exception Handling Mechanisms

```java

try {

// Code that might throw exception

} catch (Exception e) {

// Exception handling

} finally {

// Always executed

// Try-with-resources

try (Resource res = new Resource()) {

// Resource automatically closed

```

## 4. Collections Framework

### 4.1 Interfaces

- Collection

- List

- Set

- Queue

- Map

### 4.2 Implementations

1. **Lists**
 - ArrayList

- LinkedList

- Vector

- Stack

2. **Sets**

- HashSet

- LinkedHashSet

- TreeSet

3. **Maps**

- HashMap

- LinkedHashMap

- TreeMap

- Hashtable

### 4.3 Algorithms

- Sorting

- Searching

- Shuffling

- Manipulation

## 5. Generics

### 5.1 Generic Classes

```java

public class Container<T> {

private T value;

public void setValue(T value) {

this.value = value;
 }

public T getValue() {

return value;

```

### 5.2 Generic Methods

```java

public <T> void method(T param) {}

public <T extends Number> T method(T param) {}

```

### 5.3 Wildcards

- Upper bounded (`<? extends Type>`)

- Lower bounded (`<? super Type>`)

- Unbounded (`<?>`)

## 6. Multithreading

### 6.1 Thread Creation

1. **Extending Thread**

```java

class MyThread extends Thread {

public void run() {

// Thread code

```
2. **Implementing Runnable**

```java

class MyRunnable implements Runnable {

public void run() {

// Thread code

```

### 6.2 Thread Synchronization

1. **Synchronized Methods**

```java

synchronized void method() {}

```

2. **Synchronized Blocks**

```java

synchronized(object) {

// Synchronized code

```

### 6.3 Thread Communication

- wait()

- notify()

- notifyAll()

- join()

## 7. I/O Operations

### 7.1 Streams

- InputStream

- OutputStream

2. **Character Streams**

- Reader

- Writer

### 7.2 Files and Directories

```java

// File operations

File file = new File("path");

file.createNewFile();

file.delete();

// NIO.2

Path path = Paths.get("path");

Files.createFile(path);

Files.delete(path);

```

## 8. Advanced Features

### 8.1 Lambda Expressions

```java

// Lambda syntax

(parameters) -> expression

(parameters) -> { statements; }

// Example

Consumer<String> consumer = s -> System.out.println(s);

### 8.2 Stream API

```java

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

numbers.stream()

.filter(n -> n % 2 == 0)

.map(n -> n * 2)

.collect(Collectors.toList());

```

### 8.3 Optional Class

```java

Optional<String> optional = Optional.of("value");

optional.ifPresent(System.out::println);

String value = optional.orElse("default");

```

### 8.4 Module System (Java 9+)

```java

module com.example {

requires java.base;

exports com.example.api;

provides com.example.spi.Service with com.example.impl.ServiceImpl;

```

## 9. Java Memory Model

### 9.1 Memory Areas

- Heap
- Stack

- Method Area

- PC Registers

- Native Method Stack

### 9.2 Garbage Collection

1. **Generations**

- Young Generation

- Old Generation

- Metaspace

2. **GC Algorithms**

- Serial GC

- Parallel GC

- CMS

- G1 GC

- ZGC

## 10. Best Practices

### 10.1 Code Organization

- Package naming conventions

- Class design principles

- Method design guidelines

- Variable naming conventions

### 10.2 Performance Optimization

- Memory management

- Threading considerations

- Resource handling

- Caching strategies
### 10.3 Security

- Input validation

- Access control

- Secure communication

- Cryptography usage