Java Programming Notes: Core Concepts, OOP and Collections

1. Introduction to Java

Java was developed at Sun Microsystems and was publicly released in 1995. A Java program is normally compiled into bytecode rather than directly into machine code for one operating system. A compatible Java runtime then loads and executes that bytecode.

This is the basis of Java's “write once, run anywhere” idea. In practice, portability depends on using a compatible runtime and avoiding unnecessary dependence on operating-system-specific APIs or native libraries.

First Java program

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

• public class Main defines a class named Main.
• main is the conventional entry point for a standalone Java application.
• String[] args receives command-line arguments.
• System.out.println() writes a line to standard output.

2. JDK, JRE and JVM

The Java platform has several related terms. They should not be treated as interchangeable.

Some modern Java distributions do not provide a separate downloadable JRE package. The distinction remains useful: the JDK is for development, while a Java runtime is needed to execute an application.

How a Java program runs

1. A programmer writes source code in a .java file.
2. The javac compiler converts source code into bytecode in a .class file.
3. The JVM class loader finds and loads required classes.
4. The JVM verifies, links, and initializes classes as needed.
5. The execution engine interprets bytecode or uses Just-In-Time compilation for frequently executed code.

Memory management

Java uses automatic garbage collection to reclaim heap memory occupied by objects that are no longer reachable. Garbage collection does not replace explicit cleanup of external resources such as files, sockets, or database connections. Those resources should be closed with try-with-resources or an appropriate API.

3. Data Types, Variables, Arrays and Strings

Java is statically typed: every variable has a declared type, and the compiler checks whether values are used in a type-safe way.

Primitive data types

Variables and type conversion

public class Main {
    public static void main(String[] args) {
        int age = 20;
        long population = 1_400_000_000L;
        float percentage = 82.5f;
        double average = 76.25;
        char grade = 'A';
        boolean passed = true;

        double widened = age;       // implicit widening conversion
        int truncated = (int) 9.8;  // explicit narrowing conversion

        System.out.println(widened);
        System.out.println(truncated); // 9
    }
}

Reference types

Classes, interfaces, arrays, enums, records, and strings are reference types. A variable of a reference type holds either a reference to an object or null.

• An array has a fixed length and uses zero-based indexes.
• String is a reference type and is immutable.
• Wrapper classes such as Integer and Double represent primitive values as objects.
• Java always uses pass-by-value, including when an object reference is passed to a method.

public class Main {
    public static void main(String[] args) {
        int[] marks = {72, 86, 91};
        int total = 0;

        for (int mark : marks) {
            total += mark;
        }

        String message = "Java";
        String updatedMessage = message + " Programming";

        System.out.println(total);
        System.out.println(updatedMessage);
    }
}

4. Operators and Control Statements

Common operators

The operators && and || short-circuit: the second condition may not be evaluated. The operators & and | can also work with boolean values, but both operands are evaluated.

Comparing strings correctly

public class Main {
    public static void main(String[] args) {
        String first = new String("Java");
        String second = new String("Java");

        System.out.println(first == second);       // false: different object references
        System.out.println(first.equals(second));  // true: same text content
    }
}

Use == to compare primitive values. For string content, use equals() or equalsIgnoreCase() when that comparison is appropriate.

Decision-making and loops

public class Main {
    public static void main(String[] args) {
        int marks = 85;
        String grade;

        if (marks >= 90) {
            grade = "A";
        } else if (marks >= 75) {
            grade = "B";
        } else {
            grade = "C";
        }

        System.out.println("Grade: " + grade);

        for (int number = 1; number <= 3; number++) {
            System.out.println(number);
        }
    }
}

• if, if-else, and switch select between alternatives.
• for, while, and do-while repeat statements.
• The enhanced for loop is useful for arrays and collections.
• break exits a loop or switch; continue skips to the next loop iteration.

5. Classes, Objects and OOP

Object-oriented programming organizes code around objects that combine state and behavior. A class is a blueprint, while an object is an instance created from that class.

Four central OOP principles

• Encapsulation: protect internal state and expose controlled operations.
• Inheritance: derive a class from another class.
• Polymorphism: use one common type or method call with different behavior.
• Abstraction: show essential behavior while hiding unnecessary implementation details.

Class, constructor and object example

public class Main {
    static class Student {
        private final String name;
        private final int age;

        Student(String name, int age) {
            if (age < 0) {
                throw new IllegalArgumentException("Age cannot be negative.");
            }

            this.name = name;
            this.age = age;
        }

        void printDetails() {
            System.out.println(name + " is " + age + " years old.");
        }
    }

    public static void main(String[] args) {
        Student student = new Student("Asha", 20);
        student.printDetails();
    }
}

• A constructor initializes a newly created object.
• this refers to the current object.
• static members belong to the class rather than an individual object.
• final prevents reassignment of a variable reference and can prevent overriding or inheritance when applied to methods or classes.

6. Inheritance and Polymorphism

Inheritance lets a subclass reuse accessible members of a superclass. Java supports single inheritance for classes: one class cannot directly extend more than one class. A class can, however, implement multiple interfaces.

Common forms of class inheritance

• Single inheritance: one subclass extends one superclass.
• Multilevel inheritance: a subclass is extended by another subclass.
• Hierarchical inheritance: multiple subclasses extend one superclass.

Runtime polymorphism through overriding

public class Main {
    static class Animal {
        void sound() {
            System.out.println("Animal makes a sound");
        }
    }

    static class Dog extends Animal {
        @Override
        void sound() {
            System.out.println("Dog barks");
        }
    }

    public static void main(String[] args) {
        Animal animal = new Dog();
        animal.sound(); // Dog barks
    }
}

Method overloading vs method overriding

7. Abstraction and Interfaces

Abstraction focuses on what an object can do instead of exposing every internal implementation detail. Java supports abstraction through abstract classes and interfaces.

public class Main {
    interface Printable {
        void print();
    }

    static class Report implements Printable {
        @Override
        public void print() {
            System.out.println("Printing report");
        }
    }

    public static void main(String[] args) {
        Printable item = new Report();
        item.print();
    }
}

A non-abstract subclass must implement every inherited abstract method that has not already been implemented by a superclass.

8. Encapsulation and Access Modifiers

Encapsulation protects an object's internal state by keeping fields private when appropriate and exposing validated methods for reading or changing that state.

Outside its package, a subclass cannot use a protected member through an arbitrary superclass object. Protected access is intended for code that is implementing the subclass relationship.

import java.math.BigDecimal;

public class Main {
    static class BankAccount {
        private BigDecimal balance = BigDecimal.ZERO;

        void deposit(BigDecimal amount) {
            if (amount.signum() <= 0) {
                throw new IllegalArgumentException("Deposit must be positive.");
            }

            balance = balance.add(amount);
        }

        BigDecimal getBalance() {
            return balance;
        }
    }

    public static void main(String[] args) {
        BankAccount account = new BankAccount();
        account.deposit(new BigDecimal("250.50"));

        System.out.println(account.getBalance());
    }
}

BigDecimal is preferable to double when a program needs exact decimal monetary calculations.

9. Exception Handling and File Resources

An exception is an event that interrupts the normal flow of a program. Java provides try, catch, finally, throw, and throws to handle or communicate exceptional conditions.

Try-with-resources

Use try-with-resources for objects that must be closed, such as readers, streams, sockets, and database connections. The resource is closed automatically even if an exception occurs.

import java.io.BufferedReader;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;

public class Main {
    public static void main(String[] args) {
        Path file = Path.of("notes.txt");

        try (BufferedReader reader =
                Files.newBufferedReader(file, StandardCharsets.UTF_8)) {

            System.out.println(reader.readLine());

        } catch (IOException exception) {
            System.err.println("Unable to read the file: "
                    + exception.getMessage());
        }
    }
}

10. Multithreading and Concurrency

Multithreading allows a program to perform multiple tasks concurrently. Java provides the low-level Thread class as well as higher-level concurrency utilities in java.util.concurrent.

Extending Thread is valid for learning, but using Runnable, Callable, or an executor is usually more flexible because a class can still extend another class.

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newSingleThreadExecutor();

        try {
            executor.submit(() -> System.out.println("Task is running."));
        } finally {
            executor.shutdown();
        }
    }
}

Concurrent tasks do not have a guaranteed execution order unless a program explicitly coordinates them. Shared mutable data can create race conditions, so use synchronization, locks, immutable objects, or concurrent collections when appropriate.

11. Java Collections Framework

The Java Collections Framework provides interfaces and classes for storing and processing groups of objects. Generics such as List<String> help the compiler detect type errors.

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        List<String> subjects = new ArrayList<>();
        subjects.add("Java");
        subjects.add("Networking");

        Set<String> uniqueSubjects = Set.of("Java", "DBMS");

        Map<Integer, String> students = new HashMap<>();
        students.put(101, "Asha");
        students.put(102, "Ravi");

        System.out.println(subjects.get(0));
        System.out.println(uniqueSubjects);
        System.out.println(students.getOrDefault(103, "Not found"));
    }
}

ArrayList is usually a good default choice for a list. Do not assume that LinkedList is automatically faster for all insertions or deletions; the right choice depends on the program's actual access pattern.

12. Quick Revision and Practice Questions

Practice questions

1. What is the difference between the JDK and JVM?
   Answer: The JDK contains development tools and a runtime; the JVM is the component that executes Java bytecode.
2. Is Java pass-by-reference?
   Answer: No. Java is pass-by-value. When an object is passed, the value copied is the object reference.
3. Can a Java class extend multiple classes?
   Answer: No. Java supports single inheritance for classes, but a class can implement multiple interfaces.
4. What is the difference between == and equals() for strings?
   Answer: == compares references, while equals() compares string content.
5. Why is try-with-resources useful?
   Answer: It automatically closes declared resources even when an exception occurs.

Further Reading

• Java Language Specification
• Oracle guide to try-with-resources
• Java Collections Framework overview
• Java thread state reference