Java is a high-level, platform-independent, object-oriented programming language. It follows "write once, run anywhere" (WORA) principle. Compiled to bytecode and executed by JVM (Java Virtual Machine).

JVM is an abstract computing machine that enables a computer to run Java programs and programs written in other languages compiled to Java bytecode. It provides platform independence.

Object-oriented, platform-independent, multi-threaded, secure, robust, simple syntax, automatic memory management (garbage collection), rich API library, supports networking.

JVM executes bytecode. JRE (Java Runtime Environment) includes JVM + libraries. JDK (Java Development Kit) includes JRE + compiler + tools for development.

An object is an instance of a class containing state (attributes/fields) and behavior (methods). Objects are created using the new keyword: MyClass obj = new MyClass();

A class is a blueprint/template for creating objects. Defines attributes and methods. Example: public class Car { int speed; void drive() {} }

Control visibility: public (accessible everywhere), private (only within class), protected (within package and subclasses), default/package (within package only).

Bundling data (attributes) and methods together, hiding internal details. Use private variables with public getter/setter methods. Improves security and maintainability.

Acquiring properties of one class (parent/super) by another (child/sub). Use extends keyword: public class Child extends Parent {}. Promotes code reusability.

One entity taking multiple forms. Method overloading (same name, different parameters) and method overriding (child class redefines parent method).

Multiple methods with same name but different parameters (type, number, order). Resolved at compile time. Example: void add(int a, int b) {} and void add(double a, double b) {}

Child class provides specific implementation of parent's method. Same signature, different body. Resolved at runtime. Use @Override annotation.

Class that cannot be instantiated, contains abstract methods (no implementation). Use abstract keyword. Subclasses must implement abstract methods. Example: abstract class Animal { abstract void eat(); }

Fully abstract class defining contract for subclasses. Contains only abstract methods and constants. Implements using implements keyword. Example: class Dog implements Animal {}

Abstract class can have concrete methods, constructors, and state. Interface (traditionally) only abstract methods and constants. Java 8+ allows default methods in interfaces.

Special method called when object is created. Has same name as class, no return type. Used for initialization. Example: public MyClass() { this.name = "John"; }

Overloading: multiple constructors with different parameters. Chaining: calling one constructor from another using this(). Example: this("default");

References parent class. Used to call parent's methods and constructors. Example: super.methodName(); or super();

References current object. Used to disambiguate when local variable has same name as instance variable. Example: this.name = name;

Primitive: byte, short, int, long, float, double, boolean, char. Reference/Object: String, Array, Classes, Interfaces.

Primitive types store actual values and have fixed size. Reference types store memory address (reference to object). Primitives are faster, references allow flexibility.

Fixed-size collection of elements of same type. Indexed from 0. Example: int[] arr = new int[5]; or int[] arr = {1, 2, 3};

Immutable sequence of characters. String str = "Hello"; String is a class, not primitive. Strings are stored in string pool for efficiency.

length(), charAt(), substring(), indexOf(), equals(), equalsIgnoreCase(), contains(), replace(), split(), trim(), toUpperCase(), toLowerCase().

Dynamic array implementation of List interface. Resizes automatically. Example: ArrayList<String> list = new ArrayList<>(); list.add("item");

Arrays are fixed size, ArrayList is dynamic. Arrays are primitive, ArrayList is generic and type-safe. ArrayList has more built-in methods.

Key-value pair collection (Map interface). HashMap<String, Integer> map = new HashMap<>(); map.put("key", value); map.get("key");

Checked (must be caught): IOException, SQLException. Unchecked (extends RuntimeException): NullPointerException, ArrayIndexOutOfBoundsException.

try block contains risky code. catch block handles exceptions. finally block executes always (cleanup). Example: try { ... } catch (Exception e) { ... } finally { ... }

Declares that method throws checked exception instead of handling it. Example: public void readFile() throws IOException { ... }

Automatic memory management that removes unused objects. JVM identifies and deletes objects with no references. User calls System.gc() but doesn't guarantee immediate execution.

Makes variable/method belong to class, not instance. Static variables are shared across all instances. Static methods don't need object creation. Example: static int count = 0;

Prevents modification. Final variable (constant), final method (cannot override), final class (cannot subclass). Example: final int VAL = 10;

Makes method/block thread-safe. Only one thread can access at a time. Prevents race conditions in multi-threading. Example: synchronized void method() {}

Directory structure for organizing classes. Prevents naming conflicts. Define: package com.example; Import: import com.example.MyClass;

for, while, do-while, enhanced for. Example: for (int i = 0; i < 10; i++) { } or for (String item : list) { }

if-else, switch-case. Example: if (condition) { } else { } or switch(value) { case 1: break; default: }

&& (AND), || (OR), ! (NOT). Example: if (a > 5 && b < 10) { }

== compares references (memory address), equals() compares content. For strings: "a" == "a" may be false if different objects, but "a".equals("a") is always true.

Returns string representation of object. Override to provide meaningful output. Default returns class name + object hash code.

Autoboxing converts primitive to wrapper object: int a = 5; Integer b = a; (automatic). Unboxing: Integer b = 5; int a = b; (reverse).

Object representations of primitive types: Integer (int), Double (double), Boolean (boolean). Allow primitives to be used as objects.

Both used to create mutable strings. StringBuffer is synchronized (thread-safe), StringBuilder is not. StringBuilder is faster, preferred in single-threaded code.

Defines natural ordering of objects. Implement compareTo() method. Used for sorting: Collections.sort(list);

Defines custom ordering of objects. Implement compare() method. Passed to Collections.sort(): Collections.sort(list, new MyComparator());

Checked: compiler checks, must be caught (IOException, SQLException). Unchecked: runtime exceptions, not mandatory to catch (NullPointerException).

Splits string by delimiter: String[] words = sentence.split(" "); Returns array of strings.

Variable that doesn't reference any object. Can be checked: if (obj == null) { }. NullPointerException thrown if null is accessed.

break exits loop/switch. continue skips current iteration and moves to next. Example: for (...) { if (condition) continue; }

Use Scanner: Scanner sc = new Scanner(System.in); String input = sc.nextLine(); Or use BufferedReader for files.

Framework for storing and manipulating groups of objects. Main interfaces: Collection (List, Set, Queue), Map. Implementations: ArrayList, HashMap, HashSet, LinkedList.

List maintains order, allows duplicates (ArrayList, LinkedList). Set doesn't allow duplicates (HashSet, TreeSet). Map stores key-value pairs (HashMap, TreeMap).

Lightweight process within a program. Multiple threads run concurrently. Create by extending Thread or implementing Runnable: new Thread(() -> { ... }).start();

Thread is class, Runnable is interface. Implement Runnable for multiple inheritance. Example: class Worker implements Runnable { public void run() {} }

New, Runnable, Running, Waiting/Blocked, Terminated. Thread moves between states based on operations.

start() creates new thread and calls run(). run() directly executes in current thread. Always call start(), not run().

Anonymous function (Java 8+). Simplified syntax for functional interfaces. Example: (a, b) -> a + b; or (x) -> x * 2;

Interface with single abstract method. Can have default/static methods. Examples: Runnable, Callable, Comparator. Enable lambda expressions.

Functional approach to process collections. Example: list.stream().filter(x -> x > 5).map(x -> x * 2).collect(Collectors.toList());

Provide type safety for collections. Example: List<String> list = new ArrayList<>(); Prevents ClassCastException.

Classes defined within another class. Types: static nested, non-static (inner), local, anonymous. Example: class Outer { class Inner {} }

Metadata providing information about code, not directly affecting execution. Example: @Override, @Deprecated, @FunctionalInterface, @SuppressWarnings.

Ability to inspect and manipulate classes at runtime. Use Class.forName("ClassName"); Get methods, fields, constructors dynamically.

Abstract cannot be instantiated, contains abstract methods. Concrete can be instantiated, implements all methods.

Object that cannot be changed after creation. Example: String is immutable. Create immutable classes: final class, private fields, no setters.

Creates copy of object. Implement Cloneable and override clone(). Shallow copy by default, can implement deep copy.

Converting object to byte stream. Implement Serializable (marker interface). ObjectOutputStream.writeObject(obj);

Reconstructing object from byte stream. ObjectInputStream.readObject();

Ensures visibility of changes across threads. Volatile variable changes are immediately visible to all threads. Prevents thread caching.

Two threads waiting for each other to release resources. Prevent: lock in consistent order, use timeout, use higher-level concurrency utilities.

Auto-close resources (Java 7+). Example: try (FileReader fr = new FileReader("file")) { ... } //auto closes

Container for value that may or may not be present. Example: Optional<String> opt = Optional.ofNullable(value); opt.ifPresent(System.out::println);

Shorthand for lambda. Example: System.out::println instead of x -> System.out.println(x);

Interfaces can have default methods, abstract classes can have state. Prefer interfaces for contracts, abstract classes for shared implementation.

Methods with implementation (Java 8+). Use default keyword. Allow backward compatibility when adding methods to existing interfaces.

Thrown when accessing member of null reference. Check before use: if (obj != null) { obj.method(); } or use Optional.

Thrown when class is not found at runtime. Occurs with Class.forName() with invalid class name.

equals() compares content. hashCode() returns hash for efficient lookup in HashMap/HashSet. Override both or override neither.

? represents unknown type. Example: List<?> can hold any list. Upper bound: List<? extends Number> Lower bound: List<? super Integer>

Concatenation (+=) creates new objects each time (inefficient). StringBuilder reuses buffer (efficient). Use StringBuilder in loops.

HashMap that maintains insertion order. Useful when order matters. Example: LinkedHashMap<String, Integer> map = new LinkedHashMap<>();

Sorted Map implementation. Keys sorted by natural order or custom Comparator. Example: TreeMap<String, Integer> map = new TreeMap<>();

Sorted Set implementation. Maintains ascending order. Example: TreeSet<Integer> set = new TreeSet<>();

Interface for traversing collections. Methods: hasNext(), next(), remove(). Example: while (iterator.hasNext()) { System.out.println(iterator.next()); }

Thread-safe collections: ConcurrentHashMap, CopyOnWriteArrayList. Better performance than synchronized collections.

Fail-fast throws ConcurrentModificationException if collection modified during iteration. Fail-safe works on copy, no exception.

Type for set of constants. Example: enum Color { RED, GREEN, BLUE; } Use: Color.RED

new creates object directly. newInstance() uses reflection: Class.forName("ClassName").newInstance();

Grouping of packages. Define in module-info.java. Improves encapsulation and dependency management for large applications.

Annotation marking interface as functional. Compiler ensures only one abstract method. Example: @FunctionalInterface interface MyInterface { void method(); }

Method calling itself. Must have base case to avoid infinite loop. Example: factorial(n) = n * factorial(n-1) with base case n == 0

LIFO (Last In First Out) collection. Methods: push(), pop(), peek(). Example: Stack<String> stack = new Stack<>();

FIFO (First In First Out) collection. Methods: offer(), poll(), peek(). Implementations: LinkedList, PriorityQueue.

Block executed once when class loads. Use static {} { }. Useful for initializing static variables.

Block executed every time object is created. Use {} { }. Useful for common initialization code.

Class variables (static) are shared across all instances. Instance variables are unique to each object.

Sorts list using natural order or custom Comparator. Example: Collections.sort(list); or Collections.sort(list, comparator);

Searches sorted list using binary search. Returns index if found, negative value if not.

Importing static members directly. Example: import static java.lang.Math.*; Use Math.sqrt() without Math prefix.

Checks if object is instance of class. Example: if (obj instanceof String) { ... }

Reusing objects instead of creating new ones. Improves performance by reducing garbage collection. Example: database connection pooling.

WeakReference allows garbage collection of referenced object if no strong references. Used in caches.

SoftReference cleared only when memory is low. Used for memory-sensitive caches.

PhantomReference notifies when object is about to be garbage collected. Used for cleanup operations.

Popular Java framework for building applications. Provides dependency injection, AOP, transaction management. IoC container manages beans.

Framework injects dependencies instead of object creating them. Improves testability and loose coupling. Example: @Autowired private Service service;

Constructor injection, setter injection, field injection. Constructor is preferred (immutable, testable).

Marks method as bean producer. Returns object managed by Spring container. Example: @Bean public MyService myService() { return new MyService(); }

Separates cross-cutting concerns (logging, security) from business logic. Uses aspects, join points, advice.

Intermediate: filter(), map(), sorted(), distinct(). Terminal: collect(), forEach(), reduce(), count(). Example: list.stream().filter(x > 5).collect(Collectors.toList());

111-150. Advanced Topics (abbreviated)

111-115: Custom annotations, metaprogramming, bytecode manipulation, classloaders, memory leaks. 116-120: Performance tuning, profiling, GC optimization, JVM tuning, multithreading patterns. 121-125: Design patterns (Singleton, Factory, Observer), SOLID principles, unit testing frameworks. 126-130: Reactive programming, functional programming in Java, concurrency utilities, ExecutorService, ForkJoinPool. 131-135: Spring Boot, Spring Data, ORM frameworks (Hibernate), REST APIs, microservices. 136-140: Docker/containerization, cloud deployment, DevOps practices, CI/CD integration, monitoring. 141-145: Security practices, encryption, authentication, authorization, secure coding. 146-150: Performance benchmarking, load testing, scalability, distributed systems, system design.