Core & Advanced Java

What is Java?

Java is a strongly typed, object-oriented language. Java source code is compiled to bytecode, which runs on a Java Virtual Machine (JVM) available for many operating systems.

• JDK: Tools used to develop and compile Java programs.
• JVM: Executes Java bytecode.
• OOP: Structures software around classes and objects.
• Use cases: Backend systems, enterprise applications, services and tools.

Basic workflow

Write source code → compile with javac → run bytecode on the JVM → test and refine.

Java fundamentals

A Java program commonly starts from a class with a main method. Java statements end with semicolons and blocks use braces.

public class Main {
    public static void main(String[] args) {
        String name = "Ravi";
        int age = 21;
        if (age >= 18) {
            System.out.println(name + " is an adult.");
        }
    }
}

Practise primitive types, variables, operators, conditions, loops, arrays and strings. Pay attention to types and the difference between == and .equals() when comparing objects.

Object-oriented programming

Classes define state and behaviour; objects are instances of classes. Core OOP concepts help structure reusable code.

class Course {
    private final String name;

    Course(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

Course course = new Course("Core & Advanced Java");
System.out.println(course.getName());

• Encapsulation: Keep internal state controlled behind methods.
• Inheritance: Derive a class from another when the relationship makes sense.
• Polymorphism: Use a common interface with different implementations.
• Abstraction: Expose essential behaviour and hide implementation details.

Exception handling

Exceptions represent conditions that interrupt normal program flow. Handle expected errors and avoid silently ignoring failures.

try {
    int value = Integer.parseInt("123");
    System.out.println(value);
} catch (NumberFormatException ex) {
    System.out.println("Please enter a valid number.");
}

Learn checked and unchecked exceptions, custom exception classes, try-with-resources and when to propagate an exception to the caller.

Collections and generics

The Collections Framework provides reusable data structures. Choose one based on the operations your program needs.

import java.util.ArrayList;
import java.util.List;

List<String> topics = new ArrayList<>();
topics.add("OOP");
topics.add("Collections");
for (String topic : topics) {
    System.out.println(topic);
}

Explore List, Set, Queue and Map; compare ArrayList and LinkedList; practise HashMap lookups, sorting, iterators and generic types.

Multithreading and modern Java

Threads enable concurrent execution, but shared mutable state must be handled carefully. Learn Runnable, executors, synchronization and thread-safety basics.

• Use executor services for managed task execution.
• Understand race conditions and safe access to shared data.
• Use lambdas and functional interfaces to express behaviour.
• Practise Stream API operations such as filter, map and collect.

File handling and I/O

Java offers APIs for working with text and binary files. Prefer try-with-resources for closeable resources.

import java.nio.file.Files;
import java.nio.file.Path;
import java.io.IOException;

Path path = Path.of("notes.txt");
try {
    Files.writeString(path, "Practise Java every day.");
    String content = Files.readString(path);
    System.out.println(content);
} catch (IOException ex) {
    System.out.println("File operation failed.");
}

Practise file paths, character encoding, buffered I/O, validation and safe handling of missing or inaccessible files.

JDBC and SQL

JDBC lets Java applications connect to relational databases. Use parameterised statements to reduce SQL injection risk.

String sql = "SELECT name FROM students WHERE id = ?";
try (var connection = dataSource.getConnection();
     var statement = connection.prepareStatement(sql)) {
    statement.setInt(1, studentId);
    try (var results = statement.executeQuery()) {
        while (results.next()) {
            System.out.println(results.getString("name"));
        }
    }
}

This example assumes a configured DataSource and a valid studentId. Practise CRUD, transactions, prepared statements and resource cleanup with your course database.

Testing and project workflow

1. Write clear requirements and small methods.
2. Test normal cases, boundary values and invalid inputs.
3. Use Git to track changes and collaborate safely.
4. Use Maven or Gradle to manage dependencies and builds.
5. Document how to configure, run and test the project.

Keep credentials out of source control, validate external input, and avoid logging sensitive information.

Core & Advanced Java glossary