Learn from Blogs and Tutorials:

Docy turns out that context is a key part of learning.

Get Started
Updated on January 12, 2026

Java

Estimated reading: 15 minutes 38 views

Java Tutorial from Basics to Advanced

Clear concepts with simple examples. Every topic has a concept and an explanation.

1. What is Java

Concept Java is a compiled and interpreted language. You write once and run on many systems using the Java Virtual Machine.

Why it matters

  • Strong standard library
  • Good performance with automatic memory management
  • Large ecosystem for web, mobile, data, and tools

Hello program

public class Hello {
    public static void main(String[] args) {
        System.out.println("Hello Java");
    }
}

Explanation main is the entry point. System.out.println prints text to the console.

2. Install and Run

Concept You compile source files to bytecode. The JVM runs the bytecode.

Example

javac Hello.java
java Hello

Explanation javac creates Hello.class. The java command runs the class by its name.

3. Program Structure and Packages

Concept Packages group related classes. The file path should match the package.

Example

package app.greet;

public class Greeter {
    public static void say(String name) {
        System.out.println("Hi " + name);
    }
}
package app;

import app.greet.Greeter;

public class Main {
    public static void main(String[] args) {
        Greeter.say("Aarav");
    }
}

Explanation Use package at the top. Import types with import. Keep folders matching the package path.

4. Variables and Types

Concept Java is statically typed. Each variable has a declared type.

Example

public class TypesDemo {
    public static void main(String[] args) {
        byte b = 120;
        int count = 42;
        long big = 9_000_000_000L;
        float r = 2.5f;
        double pi = 3.141592653589793;
        boolean active = true;
        char initial = 'K';
        System.out.println(count + " " + pi + " " + active + " " + initial);
    }
}

Explanation Use suffixes for literals such as L for long and f for float. Use underscore to group digits for readability.

5. var and Constants

Concept var lets the compiler infer local variable types. final marks constants.

Example

public class VarFinalDemo {
    public static void main(String[] args) {
        var message = "ready";
        final double TAX_RATE = 0.18;
        System.out.println(message + " " + TAX_RATE);
    }
}

Explanation var works for local variables only. final prevents reassignment.

6. Operators

Concept Operators perform arithmetic and logic on values. Know precedence and integer division.

Example

public class Ops {
    public static void main(String[] args) {
        int a = 9, b = 4;
        System.out.println(a + b);   // 13
        System.out.println(a / b);   // 2 integer division
        System.out.println(a % b);   // 1 remainder
        double x = 9, y = 4;
        System.out.println(x / y);   // 2.25 double division
        boolean ok = (a > b) && (b > 0);
        System.out.println(ok);
    }
}

Explanation Using int divides and truncates. Use double for real division.

7. Control Flow

Concept Use conditionals and loops to direct execution.

Example

public class Flow {
    public static void main(String[] args) {
        int temp = 33;
        if (temp >= 40) {
            System.out.println("Too hot");
        } else if (temp >= 30) {
            System.out.println("Warm");
        } else {
            System.out.println("Cool");
        }

        for (int i = 0; i < 5; i++) {
            if (i == 2) continue;
            if (i == 4) break;
            System.out.println("i " + i);
        }

        int n = 3;
        while (n > 0) {
            System.out.println(n);
            n--;
        }
    }
}

Explanation break exits a loop. continue skips to the next iteration.

8. switch and switch expressions

Concept Switch handles multiple branches. Newer Java adds switch expressions that return values.

Example

public class SwitchDemo {
    public static void main(String[] args) {
        String grade = "B";
        switch (grade) {
            case "A" -> System.out.println("Excellent");
            case "B" -> System.out.println("Good");
            case "C" -> System.out.println("Average");
            default -> System.out.println("Unknown");
        }

        int day = 6;
        String type = switch (day) {
            case 1, 2, 3, 4, 5 -> "weekday";
            case 6, 7 -> "weekend";
            default -> "invalid";
        };
        System.out.println(type);
    }
}

Explanation Switch expressions use arrow labels and can yield a value.

9. Methods

Concept Methods group logic and can return results. Parameters pass inputs.

Example

public class Methods {
    static int square(int n) {
        return n * n;
    }

    static void printSum(int a, int b) {
        System.out.println("sum " + (a + b));
    }

    public static void main(String[] args) {
        System.out.println(square(7));
        printSum(3, 5);
    }
}

Explanation Mark helper methods static if they do not depend on object state.

10. Arrays

Concept Arrays hold fixed size sequences of the same type.

Example

import java.util.Arrays;

public class ArraysDemo {
    public static void main(String[] args) {
        int[] scores = {82, 91, 76, 88, 95};
        Arrays.sort(scores);
        System.out.println(Arrays.toString(scores));
        int total = 0;
        for (int s : scores) total += s;
        double avg = total / (double) scores.length;
        System.out.println("avg " + avg);
    }
}

Explanation Arrays have a fixed length. Use enhanced for for simple iteration.

11. Strings

Concept Strings are immutable sequences of characters.

Example

public class StringsDemo {
    public static void main(String[] args) {
        String name = "Meera";
        System.out.println(name.toUpperCase());
        System.out.println(name.charAt(0));
        System.out.println(name.substring(1, 4));
        String msg = String.format("Hi %s age %d", "Asha", 23);
        System.out.println(msg);
    }
}

Explanation String methods return new strings. Use String.format for readable formatting.

12. StringBuilder

Concept Use StringBuilder to build text efficiently in loops.

Example

public class SB {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        for (int i = 1; i <= 5; i++) {
            sb.append(i).append(", ");
        }
        String out = sb.toString();
        System.out.println(out);
    }
}

Explanation StringBuilder avoids many temporary strings.

13. Classes and Objects

Concept Classes bundle state and behavior. Objects are instances of classes.

Example

public class BankAccount {
    private String owner;
    private double balance;

    public BankAccount(String owner, double initial) {
        this.owner = owner;
        this.balance = initial;
    }

    public void deposit(double amount) {
        if (amount <= 0) throw new IllegalArgumentException("amount must be positive");
        balance += amount;
    }

    public void withdraw(double amount) {
        if (amount > balance) throw new IllegalStateException("insufficient funds");
        balance -= amount;
    }

    public double getBalance() {
        return balance;
    }

    public static void main(String[] args) {
        BankAccount acct = new BankAccount("Neel", 500);
        acct.deposit(200);
        System.out.println(acct.getBalance());
    }
}

Explanation Use private fields to protect invariants. Expose state through methods.

14. Constructors and Overloading

Concept Constructors set initial state. You can have multiple constructors.

Example

public class Point {
    private final int x;
    private final int y;

    public Point() {
        this(0, 0);
    }
    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
    public String toString() {
        return "(" + x + "," + y + ")";
    }
    public static void main(String[] args) {
        System.out.println(new Point());
        System.out.println(new Point(3, 4));
    }
}

Explanation Use this to call another constructor and to refer to fields.

15. Encapsulation and Access Modifiers

Concept Control visibility with private, default, protected, and public.

Example

package demo;

class Hidden {
    int value = 10; // package private
}

public class Access {
    private int secret = 42;
    protected int token = 7;

    public static void main(String[] args) {
        Access a = new Access();
        System.out.println(a.secret);
    }
}

Explanation Prefer the most restrictive access that still allows needed use.

16. Inheritance and Polymorphism

Concept Inheritance reuses code. Polymorphism lets a base reference call derived behavior.

Example

abstract class Animal {
    abstract String speak();
}

class Dog extends Animal {
    String speak() { return "woof"; }
}

class Cat extends Animal {
    String speak() { return "meow"; }
}

public class Zoo {
    public static void main(String[] args) {
        Animal[] pets = { new Dog(), new Cat() };
        for (Animal a : pets) System.out.println(a.speak());
    }
}

Explanation Method calls go to the actual object type at runtime.

17. Interfaces and Default Methods

Concept Interfaces define contracts. Default methods provide reusable behavior.

Example

interface Shape {
    double area();
    default boolean biggerThan(Shape other) {
        return this.area() > other.area();
    }
}

class Circle implements Shape {
    private final double r;
    Circle(double r) { this.r = r; }
    public double area() { return Math.PI * r * r; }
}

class Square implements Shape {
    private final double s;
    Square(double s) { this.s = s; }
    public double area() { return s * s; }
}

public class Shapes {
    public static void main(String[] args) {
        Shape a = new Circle(2);
        Shape b = new Square(3);
        System.out.println(a.biggerThan(b));
    }
}

Explanation A class can implement many interfaces. Use defaults to share small behaviors.

18. Records Java 16 plus

Concept Records are immutable data carriers with generated methods.

Example

public record Book(String title, String author, int pages) {
    public String shortLabel() { return title + " by " + author; }
    public static void main(String[] args) {
        var b = new Book("Clean Java", "K P Rao", 320);
        System.out.println(b);
        System.out.println(b.shortLabel());
    }
}

Explanation Records generate constructor, accessors, equals, hashCode, and toString.

19. Enums

Concept Enums model a fixed set of constants and can hold fields and methods.

Example

public enum DayType {
    WEEKDAY(1.0), WEEKEND(1.5);

    private final double rate;
    DayType(double rate) { this.rate = rate; }
    public double rate() { return rate; }

    public static void main(String[] args) {
        System.out.println(DayType.WEEKEND.rate());
    }
}

Explanation Enums are classes with named instances.

20. Generics

Concept Generics enable type safe containers and methods.

Example

import java.util.*;

public class Box
<T> {
    private T value;
    public void set(T v) { value = v; }
    public T get() { return value; }

    public static void main(String[] args) {
        Box
<String> b = new Box<>();
        b.set("hello");
        System.out.println(b.get());
        List
<Integer> nums = List.of(1, 2, 3);
        System.out.println(nums.get(0));
    }
}

Explanation Use type parameters to avoid casts and runtime errors.

21. Collections Framework

Concept Use the right collection for your access pattern.

Example

import java.util.*;

public class CollectionsDemo {
    public static void main(String[] args) {
        List
<Integer> a = new ArrayList<>(List.of(3, 1, 4));
        Set
<String> tags = new HashSet<>(Set.of("red", "blue"));
        Map<String, Integer> count = new HashMap<>();
        count.put("cat", 2);
        count.put("dog", 3);

        Collections.sort(a);
        System.out.println(a);
        System.out.println(tags.contains("red"));
        System.out.println(count.getOrDefault("fish", 0));
    }
}

Explanation Lists are ordered. Sets keep unique values. Maps store key to value pairs.

22. Lambdas and Functional Interfaces

Concept Lambdas are inline functions. A functional interface has one abstract method.

Example

import java.util.function.*;
import java.util.*;

public class LambdaDemo {
    public static void main(String[] args) {
        Predicate
<Integer> even = x -> x % 2 == 0;
        Function<String, Integer> len = s -> s.length();
        List
<String> names = List.of("Anu", "Raj", "Leena");
        names.stream().filter(s -> s.startsWith("L")).forEach(System.out::println);
        System.out.println(even.test(6));
        System.out.println(len.apply("hello"));
    }
}

Explanation Use built in functional interfaces for clarity and reuse.

23. Streams

Concept Streams provide a pipeline for processing data with map and filter and reduce.

Example

import java.util.*;
import java.util.stream.*;

public class StreamsDemo {
    public static void main(String[] args) {
        List
<Integer> nums = List.of(9, 2, 7, 4, 5);
        List
<Integer> evenSquares = nums.stream()
                .filter(x -> x % 2 == 0)
                .map(x -> x * x)
                .sorted()
                .collect(Collectors.toList());
        System.out.println(evenSquares);
        int sum = nums.stream().reduce(0, Integer::sum);
        System.out.println(sum);
    }
}

Explanation Operations are lazy until a terminal step like collect or reduce.

24. Optional

Concept Optional wraps a value that may be present or absent.

Example

import java.util.*;

public class OptionalDemo {
    static Optional
<String> findEmail(String name) {
        if ("Meera".equals(name)) return Optional.of("meera@example.com");
        return Optional.empty();
    }

    public static void main(String[] args) {
        String email = findEmail("Meera").orElse("not found");
        System.out.println(email);
        findEmail("Raj").ifPresent(System.out::println);
    }
}

Explanation Use Optional to avoid null checks and to express absence clearly.

25. Exceptions

Concept Use exceptions for unexpected errors. Catch only what you can handle.

Example

public class ExDemo {
    static int parsePort(String s) {
        try {
            int p = Integer.parseInt(s);
            if (p < 1 || p > 65535) throw new IllegalArgumentException("out of range");
            return p;
        } catch (NumberFormatException e) {
            throw new IllegalArgumentException("not a number", e);
        }
    }

    public static void main(String[] args) {
        try {
            System.out.println(parsePort("8080"));
            System.out.println(parsePort("oops"));
        } catch (IllegalArgumentException e) {
            System.out.println("error " + e.getMessage());
        }
    }
}

Explanation Wrap and rethrow with context. Use checked exceptions for recoverable conditions.

26. Files and NIO Path

Concept NIO provides modern file I O with Path and Files.

Example

import java.nio.file.*;
import java.io.IOException;
import java.util.List;

public class FilesDemo {
    public static void main(String[] args) throws IOException {
        Path p = Path.of("notes.txt");
        Files.writeString(p, "learn java daily\n");
        List
<String> lines = Files.readAllLines(p);
        System.out.println(lines);
        System.out.println(Files.size(p));
    }
}

Explanation Use Path for portability. Methods throw IOException on failure.

27. HTTP Client

Concept Java provides an HTTP client for web requests.

Example

import java.net.http.*;
import java.net.URI;

public class HttpDemo {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest req = HttpRequest.newBuilder(URI.create("https://httpbin.org/get")).build();
        HttpResponse
<String> resp = client.send(req, HttpResponse.BodyHandlers.ofString());
        System.out.println(resp.statusCode());
        System.out.println(resp.body().substring(0, 60) + "...");
    }
}

Explanation Build a request, send it, get a response with body handlers.

28. Date and Time

Concept java.time has immutable and thread safe date and time types.

Example

import java.time.*;

public class TimeDemo {
    public static void main(String[] args) {
        LocalDate today = LocalDate.now();
        LocalDate next = today.plusDays(5);
        LocalDateTime meeting = LocalDateTime.of(2026, 2, 1, 14, 30);
        System.out.println(today + " " + next + " " + meeting);
    }
}

Explanation Prefer java.time over old legacy date APIs.

29. Concurrency with Threads

Concept Threads run tasks in parallel. Synchronize access to shared data.

Example

public class ThreadsDemo {
    private static int counter = 0;

    public static void main(String[] args) throws InterruptedException {
        Object lock = new Object();
        Runnable work = () -> {
            for (int i = 0; i < 100_000; i++) {
                synchronized (lock) {
                    counter++;
                }
            }
        };
        Thread t1 = new Thread(work);
        Thread t2 = new Thread(work);
        t1.start(); t2.start();
        t1.join(); t2.join();
        System.out.println(counter);
    }
}

Explanation sychronized guards critical sections to prevent data races.

30. Executors and CompletableFuture

Concept Executors manage thread pools. CompletableFuture supports async tasks and composition.

Example

import java.util.concurrent.*;
import java.util.*;

public class FutureDemo {
    public static void main(String[] args) throws Exception {
        ExecutorService pool = Executors.newFixedThreadPool(4);
        CompletableFuture
<Integer> a = CompletableFuture.supplyAsync(() -> 21, pool);
        CompletableFuture
<Integer> b = CompletableFuture.supplyAsync(() -> 21, pool);
        int result = a.thenCombine(b, Integer::sum).get();
        System.out.println(result);
        pool.shutdown();
    }
}

Explanation Combine futures without blocking until you need the result.

31. Locks and Atomics

Concept Use ReentrantLock for flexible locking. Use atomics for lock free counters.

Example

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.ReentrantLock;

public class LockAtomicDemo {
    public static void main(String[] args) throws InterruptedException {
        AtomicInteger ai = new AtomicInteger(0);
        ReentrantLock lock = new ReentrantLock();

        Runnable r = () -> {
            for (int i = 0; i < 50_000; i++) {
                ai.incrementAndGet();
                lock.lock();
                try {
                    // do protected work
                } finally {
                    lock.unlock();
                }
            }
        };
        Thread t1 = new Thread(r), t2 = new Thread(r);
        t1.start(); t2.start();
        t1.join(); t2.join();
        System.out.println(ai.get());
    }
}

Explanation Use try finally to ensure locks are released.

32. Annotations and Reflection

Concept Annotations add metadata. Reflection reads or uses it at runtime.

Example

import java.lang.annotation.*;
import java.lang.reflect.*;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@interface Task {
    String value();
}

public class AnnDemo {
    @Task("cleanup")
    public void clean() {}

    public static void main(String[] args) throws Exception {
        for (Method m : AnnDemo.class.getDeclaredMethods()) {
            Task t = m.getAnnotation(Task.class);
            if (t != null) System.out.println(m.getName() + " tag " + t.value());
        }
    }
}

Explanation Keep retention as runtime if you need to inspect annotations at runtime.

33. Modules Java 9 plus

Concept Modules define boundaries for large applications.

Example

// module-info.java
module app.core {
    exports app.core;
}
// src/app/core/Calc.java
package app.core;
public class Calc {
    public static int add(int a, int b) { return a + b; }
}

Explanation Modules declare what they export. Use module paths to compile and run.

34. JDBC Basics

Concept JDBC lets you interact with relational databases.

Example

import java.sql.*;

public class JdbcDemo {
    public static void main(String[] args) throws Exception {
        // Requires a JDBC driver and a reachable DB
        try (Connection conn = DriverManager.getConnection("jdbc:h2:mem:test");
             Statement st = conn.createStatement()) {
            st.executeUpdate("create table users(id int primary key, name varchar(50))");
            st.executeUpdate("insert into users values(1, 'Riya')");
            try (ResultSet rs = st.executeQuery("select * from users")) {
                while (rs.next()) {
                    System.out.println(rs.getInt("id") + " " + rs.getString("name"));
                }
            }
        }
    }
}

Explanation Always use try with resources to close connections and statements.

35. Testing with JUnit

Concept Unit tests verify behavior automatically.

Example

// src/test/java/demo/MathsTest.java
import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.Test;

public class MathsTest {
    int add(int a, int b) { return a + b; }

    @Test
    void addWorks() {
        assertEquals(5, add(2, 3));
        assertEquals(0, add(-1, 1));
    }
}

Explanation Use JUnit Jupiter for modern tests. Assertions state the expected result.

36. Build tools Maven and Gradle

Concept Build tools manage dependencies and tasks.

Maven snippet

<project>
<modelVersion>4.0.0</modelVersion>
<groupId>demo</groupId>
<artifactId>app</artifactId>
<version>1.0.0</version>
<dependencies>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter</artifactId>
<version>5.10.0</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>

Gradle snippet

plugins { id 'java' }
repositories { mavenCentral() }
dependencies { testImplementation 'org.junit.jupiter:junit-jupiter:5.10.0' }
test { useJUnitPlatform() }

Explanation Declare dependencies once. The tool fetches them and sets up tasks.

37. Pattern Matching and Sealed Classes Java 17 plus

Concept Pattern matching simplifies type checks. Sealed classes restrict inheritance.

Example

sealed interface Expr permits Num, Add {}
record Num(int value) implements Expr {}
record Add(Expr left, Expr right) implements Expr {}

public class PMDemo {
    static int eval(Expr e) {
        return switch (e) {
            case Num n -> n.value();
            case Add a -> eval(a.left()) + eval(a.right());
        };
    }
    public static void main(String[] args) {
        Expr expr = new Add(new Num(2), new Add(new Num(3), new Num(4)));
        System.out.println(eval(expr));
    }
}

Explanation Sealed types make closed hierarchies. Switch with patterns handles each variant clearly.

38. Memory and Garbage Collection

Concept Java allocates objects on the heap and frees memory automatically. GC pauses can occur.

Example

public class MemoryDemo {
    public static void main(String[] args) {
        String[] arr = new String[1000];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = "x".repeat(i % 10);
        }
        System.out.println("created " + arr.length + " objects");
    }
}

Explanation Avoid holding references longer than needed. Use profiling tools to find leaks and hot spots.

39. Logging

Concept Use logging for diagnostics. Avoid prints in production code.

Example with JUL

import java.util.logging.*;

public class LogDemo {
    private static final Logger log = Logger.getLogger(LogDemo.class.getName());

    public static void main(String[] args) {
        log.info("service started");
        log.warning("low memory");
        log.severe("something went wrong");
    }
}

Explanation Choose a level based on importance. Configure handlers and formats as needed.

40. Performance Tips

Concept Measure first. Optimize only the hot parts.

Guidelines

  • Use the right collection and algorithm
  • Avoid unnecessary object creation in tight loops
  • Use streams when they make code clear and do not hurt performance
  • Prefer immutable data for safe sharing
  • Benchmark with JMH for reliable results

Explanation Data driven tuning gives better results than guessing.

41. Mini Project Putting It All Together

Concept Combine file I O, parsing, collections, and streams.

Task Read a CSV of items with price and quantity. Print total revenue and top N by revenue.

Example

import java.nio.file.*;
import java.io.IOException;
import java.util.*;
import java.util.stream.*;

record Item(String name, double price, int qty) {
    double revenue() { return price * qty; }
}

public class SalesReport {
    static List
<Item> readCsv(Path p) throws IOException {
        List
<String> lines = Files.readAllLines(p);
        return lines.stream()
                .skip(1) // header line
                .map(line -> line.split(","))
                .filter(cols -> cols.length >= 3)
                .map(cols -> new Item(cols[0].trim(),
                        Double.parseDouble(cols[1].trim()),
                        Integer.parseInt(cols[2].trim())))
                .collect(Collectors.toList());
    }

    public static void main(String[] args) throws Exception {
        Path src = Path.of("sales.csv");
        List
<Item> items = readCsv(src);

        double total = items.stream().mapToDouble(Item::revenue).sum();
        System.out.println("total revenue " + total);

        int topN = 3;
        items.stream()
             .sorted(Comparator.comparingDouble(Item::revenue).reversed())
             .limit(topN)
             .forEach(i -> System.out.println(i.name() + " " + i.revenue()));
    }
}

Explanation Reads lines, parses fields, uses a record for items, sorts by computed revenue, prints summary.

Next Steps

Concept Practice daily and grow with projects.

Ideas

  • A command line note app that saves to JSON
  • A small REST client that fetches and filters data
  • A tiny task scheduler using executors and delays
  • A photo renamer using files and regex

Explanation Real projects will make you comfortable with APIs, design, and testing.

If you want, I can turn this into a weekly study plan with exercises and solutions.

Leave a Comment

Share this Doc

Java

Or copy link

CONTENTS

Powered By EazyDocs