Java Programming

Layout manager

A layout manager is an object that controls the size and position of components inside a container (Frame, Panel, JFrame). It lets the interface adjust to different screen sizes and platforms. It is set with setLayout(). Common ones are FlowLayout, BorderLayout, GridLayout, CardLayout, BoxLayout and GridBagLayout.

GridBagLayout

GridBagLayout is the most flexible layout manager. It places components in a grid of rows and columns, but a component may span several rows or columns, and rows and columns can have different sizes. Each component is controlled by a GridBagConstraints object with these main fields:

• gridx, gridy: the cell (column, row).
• gridwidth, gridheight: the number of columns or rows spanned.
• weightx, weighty: how extra space is shared.
• fill: how the component grows (NONE, HORIZONTAL, VERTICAL, BOTH).
• anchor: where the component sits inside its cell.
• insets: the external padding.
• ipadx, ipady: the internal padding.

Example

import javax.swing.*;
import java.awt.*;

public class GridBagDemo {
    public static void main(String[] args) {
        JFrame f = new JFrame("GridBagLayout");
        f.setLayout(new GridBagLayout());
        GridBagConstraints c = new GridBagConstraints();
        c.insets = new Insets(5, 5, 5, 5);
        c.fill = GridBagConstraints.HORIZONTAL;

        c.gridx = 0; c.gridy = 0;
        f.add(new JLabel("Name:"), c);

        c.gridx = 1; c.gridy = 0; c.weightx = 1.0;
        f.add(new JTextField(15), c);

        c.gridx = 0; c.gridy = 1; c.gridwidth = 2;   // spans two columns
        f.add(new JButton("Submit"), c);

        f.pack();
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.setVisible(true);
    }
}

The label and text field are in row 0, and the button sits in row 1 across both columns.

Yes. Polymorphism can be achieved in Java generics in these ways.

1. Parametric polymorphism: one generic class or method works for many types, for example Box<T> or <T> void show(T x).
2. Bounded type parameters: <T extends Shape> accepts Shape and its subclasses, and calls overridden methods polymorphically.
3. Wildcards: List<? extends Shape> accepts List<Circle> or List<Square>, and List<? super Circle> accepts lists of Circle and its parents.
4. Subtype objects inside a generic type: List<Shape> can hold Circle and Square objects, and draw() is chosen at run time.

Important limit: generics are invariant. List<Circle> is not a List<Shape>, even though Circle is a Shape. Wildcards are used to overcome this.

static void drawAll(List<? extends Shape> list) {
    for (Shape s : list) s.draw();   // runtime polymorphism
}

FileWriter writes characters to a file and FileReader (wrapped in BufferedReader) reads them back. Both can throw IOException, so they are used with try-with-resources, which closes the files automatically.

import java.io.*;

public class FileDemo {
    public static void main(String[] args) {
        // create sample.txt and write to it
        try (FileWriter fw = new FileWriter("sample.txt")) {
            fw.write("Java Programming is Fun!!");
            System.out.println("Data written to sample.txt");
        } catch (IOException e) {
            System.out.println("Write error: " + e.getMessage());
        }

        // read the content back
        try (BufferedReader br = new BufferedReader(new FileReader("sample.txt"))) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            System.out.println("Read error: " + e.getMessage());
        }
    }
}

Output:

Data written to sample.txt
Java Programming is Fun!!

new FileWriter("sample.txt") creates the file if it does not exist (and overwrites it if it does). readLine() returns null at the end of the file, which ends the loop.

FileWriter writes characters to a file and FileReader reads characters from it. Both throw the checked IOException, so the code is placed in try-catch; try-with-resources closes the streams automatically.

import java.io.*;

public class FileDemo {
    public static void main(String[] args) {
        // Create sample.txt and write "Hello World"
        try (FileWriter fw = new FileWriter("sample.txt")) {
            fw.write("Hello World");
            System.out.println("Data written to sample.txt");
        } catch (IOException e) {
            System.out.println("Write error: " + e.getMessage());
        }

        // Read the content back
        try (FileReader fr = new FileReader("sample.txt")) {
            int ch;
            System.out.print("File content: ");
            while ((ch = fr.read()) != -1) {
                System.out.print((char) ch);
            }
            System.out.println();
        } catch (IOException e) {
            System.out.println("Read error: " + e.getMessage());
        }
    }
}

Explanation.

• new FileWriter("sample.txt") creates the file if it does not exist (and overwrites it if it does).
• write() stores the string; closing the writer flushes the data to disk.
• FileReader.read() returns one character as an int, or -1 at end of file, so the loop prints characters until -1.

Output:

Data written to sample.txt
File content: Hello World

A generic method declares its own type parameter before the return type, so it can work with many data types while the compiler still checks the types.

Importance over non-generic methods

1. One method for all types: a non-generic version needs one overloaded method per type, or an Object parameter.
2. Type safety: with Object, wrong types are found only at run time (ClassCastException). A generic method is checked at compile time.
3. No casting: the result already has the right type.
4. Reusability and maintenance: one method is easier to maintain than many copies.
5. Type inference: the compiler infers T from the arguments, so the call looks simple.

Example

Non-generic code needs separate methods:

static void print(Integer[] a) { for (Integer x : a) System.out.print(x + " "); }
static void print(String[] a)  { for (String x : a)  System.out.print(x + " "); }

Generic version:

public class GenericMethodDemo {
    static <T> void print(T[] arr) {
        for (T x : arr) System.out.print(x + " ");
        System.out.println();
    }

    static <T extends Comparable<T>> T max(T a, T b) {
        return a.compareTo(b) > 0 ? a : b;
    }

    public static void main(String[] args) {
        print(new Integer[]{1, 2, 3});
        print(new String[]{"Ram", "Sita"});
        print(new Double[]{1.5, 2.5});
        System.out.println(max(10, 20));        // 20
        System.out.println(max("apple", "mango")); // mango
    }
}

The single print and max methods work for Integer, String and Double.

Generics in Java

Generics allow classes, interfaces and methods to take types as parameters (<T>). They provide compile-time type checking, remove the need for casting, and make code reusable. Collections such as ArrayList<String> use generics.

Importance of generic methods over non-generic methods

1. One generic method handles all types, while non-generic code needs a separate overloaded method for each type.
2. It is type safe, since mistakes are found at compile time. A non-generic method taking Object can fail at run time with ClassCastException.
3. No casting is needed on the result.
4. It reduces duplicate code and is easier to maintain.
5. Bounds (<T extends Comparable<T>>) allow operations that need certain capabilities.

Example

public class GenericDemo {
    static <T> void display(T[] arr) {
        for (T e : arr) System.out.print(e + " ");
        System.out.println();
    }

    static <T extends Comparable<T>> T largest(T[] arr) {
        T max = arr[0];
        for (T e : arr) if (e.compareTo(max) > 0) max = e;
        return max;
    }

    public static void main(String[] args) {
        Integer[] a = {3, 9, 5};
        String[] s = {"ball", "zebra", "cat"};
        display(a);
        display(s);
        System.out.println(largest(a));   // 9
        System.out.println(largest(s));   // zebra
    }
}

Two methods serve both Integer and String arrays; without generics, four methods would be needed.

Platform independence

Platform independence means a program written once can run unchanged on any operating system and hardware (Windows, Linux, macOS) without recompiling. Java achieves this ("Write Once, Run Anywhere") because the compiler does not produce machine code for a specific CPU. It produces bytecode (a .class file), an intermediate, platform-neutral instruction set. Each platform has its own Java Virtual Machine (JVM) that interprets or JIT-compiles the bytecode into native instructions. Only the JVM is platform dependent; the bytecode is not.

Steps to compile and execute a Java program

Step 1: Write the source code in a text editor or IDE and save it with the .java extension. The file name must match the public class name.

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

Step 2: Compile with the Java compiler: javac Hello.java. The compiler checks syntax and types and generates Hello.class containing bytecode. Errors are reported here and no class file is produced.

Step 3: Load and verify. When you run java Hello, the JVM's class loader loads Hello.class, and the bytecode verifier checks that the code is valid and safe.

Step 4: Execute. The interpreter and JIT compiler convert bytecode into native machine code for the host system and run it. Output: Hello, Nepal!

Diagram

 Hello.java  --javac-->  Hello.class (bytecode)
                              |
        +---------------------+---------------------+
        |                     |                     |
  JVM for Windows       JVM for Linux          JVM for macOS
        |                     |                     |
  Windows machine code  Linux machine code    macOS machine code

The same .class file runs on every JVM, which is what makes Java platform independent.

An array is a fixed-size collection of elements of the same data type stored in contiguous memory and accessed by an index starting at 0.

One-dimensional (1D) array

A 1D array is a single row of elements.

Declaration and creation: int[] marks = new int[5]; or with initial values int[] marks = {70, 85, 60, 90, 75};

Accessing: marks[0] is 70 and marks[4] is 75. The length is marks.length.

public class OneD {
    public static void main(String[] args) {
        int[] marks = {70, 85, 60, 90, 75};
        marks[2] = 65;                      // modify an element
        for (int i = 0; i < marks.length; i++) {
            System.out.println("marks[" + i + "] = " + marks[i]);
        }
        for (int m : marks) {               // enhanced for loop
            System.out.print(m + " ");
        }
    }
}

Two-dimensional (2D) array

A 2D array is an array of arrays, organised as rows and columns (a matrix). An element is accessed with two indices: a[row][col].

Declaration: int[][] a = new int[2][3]; or int[][] a = {{1, 2, 3}, {4, 5, 6}};

public class TwoD {
    public static void main(String[] args) {
        int[][] a = {{1, 2, 3}, {4, 5, 6}};
        System.out.println("a[1][2] = " + a[1][2]);   // 6
        for (int i = 0; i < a.length; i++) {          // rows
            for (int j = 0; j < a[i].length; j++) {   // columns
                System.out.print(a[i][j] + " ");
            }
            System.out.println();
        }
    }
}

Output:

a[1][2] = 6
1 2 3 
4 5 6 

Accessing and displaying a 1D array needs one loop, while a 2D array needs nested loops (outer for rows, inner for columns). Accessing an index outside the range throws ArrayIndexOutOfBoundsException.

Method overriding

Method overriding is defining a method in a subclass that has the same name, parameter list and compatible return type as a method in its superclass, so the subclass supplies its own implementation. It achieves runtime polymorphism: the method called is decided by the actual object type at run time. The overriding method cannot have weaker access, and static, final and private methods cannot be overridden. @Override is used to make the compiler check it.

class Animal { void sound() { System.out.println("Animal sound"); } }
class Dog extends Animal {
    @Override
    void sound() { System.out.println("Dog barks"); }
}
// Animal a = new Dog(); a.sound();  // prints "Dog barks"

Types of methods in a Java class

(a) Predefined (built-in) methods are already written in Java class libraries and are used directly by importing the class. Examples: Math.sqrt(16), String.length(), System.out.println().

double r = Math.sqrt(25);        // 5.0
int n = "Pokhara".length();      // 7

(b) User-defined methods are written by the programmer to perform a specific task. They have a return type, name, parameters and body, and can be called many times (code reuse).

class Calc {
    int add(int a, int b) { return a + b; }
}
// new Calc().add(3, 4) returns 7

(c) Static methods belong to the class rather than to any object. They are declared with static and called using the class name, with no object needed. They can access only static members directly. main is a static method.

class Util {
    static int square(int x) { return x * x; }
}
// Util.square(5) returns 25

Java String

String is a class representing a sequence of characters. Strings are immutable: once created, the content cannot be changed; every modification creates a new object. String literals are kept in the String constant pool.

String s1 = "Hello";              // literal, in pool
String s2 = new String("Hello");  // new object in heap
String s3 = s1.concat(" World");  // new String; s1 unchanged
System.out.println(s3.length());          // 11
System.out.println(s3.toUpperCase());     // HELLO WORLD
System.out.println(s3.substring(0, 5));   // Hello
System.out.println(s1.equals(s2));        // true (same content)
System.out.println(s1 == s2);             // false (different objects)

Common methods: length(), charAt(), substring(), indexOf(), equals(), compareTo(), replace(), trim().

StringBuffer

StringBuffer is a mutable sequence of characters. Its content can be modified in place without creating new objects. It is thread-safe because its methods are synchronized.

StringBuffer sb = new StringBuffer("Hello");
sb.append(" World");        // Hello World
sb.insert(5, ",");          // Hello, World
sb.replace(0, 5, "Hi");     // Hi, World
sb.reverse();               // dlroW ,iH
sb.delete(0, 2);            // oW ,iH
System.out.println(sb);

Other methods: capacity(), length(), deleteCharAt(), setCharAt(). The default capacity is 16 and it grows automatically.

Difference between String and StringBuffer

A class is a blueprint or template that defines the data (instance variables) and behaviour (methods) common to a group of objects. An object is an instance of a class.

public class Employee {
    String name;
    String designation;
    double salary;

    // default constructor
    Employee() {
        name = "Unknown";
        designation = "Not Assigned";
        salary = 0.0;
    }

    // parameterized constructor
    Employee(String name, String designation, double salary) {
        this.name = name;
        this.designation = designation;
        this.salary = salary;
    }

    void displayInfo() {
        System.out.println("Name: " + name);
        System.out.println("Designation: " + designation);
        System.out.println("Salary: Rs " + salary);
    }

    public static void main(String[] args) {
        Employee e1 = new Employee();                                  // default
        Employee e2 = new Employee("Ram Sharma", "Manager", 55000.0);  // parameterized
        e1.displayInfo();
        System.out.println();
        e2.displayInfo();
    }
}

Output:

Name: Unknown
Designation: Not Assigned
Salary: Rs 0.0

Name: Ram Sharma
Designation: Manager
Salary: Rs 55000.0

new Employee() calls the default constructor and new Employee("Ram Sharma", ...) calls the parameterized one, chosen by matching the arguments (constructor overloading).

An interface declares methods that implementing classes must define. Here Shape declares calculateArea(), and Circle and Rectangle implement it.

interface Shape {
    double calculateArea();
}

class Circle implements Shape {
    double radius;
    Circle(double radius) { this.radius = radius; }
    public double calculateArea() {
        return Math.PI * radius * radius;
    }
}

class Rectangle implements Shape {
    double length, width;
    Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }
    public double calculateArea() {
        return length * width;
    }
}

public class ShapeDemo {
    public static void main(String[] args) {
        Shape c = new Circle(7);
        Shape r = new Rectangle(5, 4);
        System.out.println("Area of Circle = " + c.calculateArea());
        System.out.println("Area of Rectangle = " + r.calculateArea());
    }
}

Output:

Area of Circle = 153.93804002589985
Area of Rectangle = 20.0

Check: circle area $\pi r^2 = 3.14159 \times 49 \approx 153.94$; rectangle area $5 \times 4 = 20$. Interface methods are implicitly public, so the implementations must be declared public. Using the Shape reference to call each object's method is an example of polymorphism.

An abstract class cannot be instantiated and may contain abstract methods (no body) that subclasses must implement.

abstract class Motor {
    abstract void start_engine();
    abstract void stop_engine();
    abstract void display_engine();
}

class Car extends Motor {
    void start_engine()   { System.out.println("Car engine started."); }
    void stop_engine()    { System.out.println("Car engine stopped."); }
    void display_engine() { System.out.println("Car has a 1500 cc petrol engine."); }
}

class Bus extends Motor {
    void start_engine()   { System.out.println("Bus engine started."); }
    void stop_engine()    { System.out.println("Bus engine stopped."); }
    void display_engine() { System.out.println("Bus has a 6000 cc diesel engine."); }
}

public class MotorDemo {
    public static void main(String[] args) {
        Motor m1 = new Car();
        Motor m2 = new Bus();
        m1.start_engine();
        m1.display_engine();
        m1.stop_engine();
        m2.start_engine();
        m2.display_engine();
        m2.stop_engine();
    }
}

Output:

Car engine started.
Car has a 1500 cc petrol engine.
Car engine stopped.
Bus engine started.
Bus has a 6000 cc diesel engine.
Bus engine stopped.

Car and Bus inherit Motor using extends and give their own implementation of all three abstract methods. Writing new Motor() would be a compile-time error.

Inheritance

Inheritance is the OOP mechanism by which a class (subclass or child) acquires the fields and methods of another class (superclass or parent), using the extends keyword. It promotes code reuse, method overriding and an "is-a" relationship.

class Person { String name = "Sita"; void eat() { System.out.println("eating"); } }
class Student extends Person { void study() { System.out.println("studying"); } }

Does Java support multiple inheritance?

Java does not support multiple inheritance through classes: a class can extend only one class. This avoids the diamond problem, where two parents have the same method and the compiler cannot decide which to inherit. However, Java does support multiple inheritance of type through interfaces: a class can implement any number of interfaces, and an interface can extend several interfaces. So the answer is yes, via interfaces.

Code example

interface Printable {
    void print();
}

interface Showable {
    void show();
}

class Document implements Printable, Showable {   // multiple inheritance
    public void print() { System.out.println("Printing document"); }
    public void show()  { System.out.println("Showing document"); }
}

public class MultipleDemo {
    public static void main(String[] args) {
        Document d = new Document();
        d.print();
        d.show();
    }
}

Output:

Printing document
Showing document

Document inherits the abstract methods of both Printable and Showable. If two interfaces declare the same method, the class provides one implementation, so there is no ambiguity. With default methods of the same name, the class must override and may call Printable.super.method() to choose one.

Need for multithreading

A thread is a lightweight unit of execution within a process. Multithreading runs several threads concurrently in one program. It is needed because it:

• makes better use of the CPU, since one thread can run while another waits for I/O, so idle time is reduced;
• keeps applications responsive (the GUI stays active while a download or calculation runs in the background);
• allows tasks to run in parallel on multi-core processors, improving performance;
• shares memory within a process, so threads are cheaper to create and switch than processes;
• suits servers that handle many clients simultaneously.

Thread by extending the Thread class

Extend Thread, override run(), create the object and call start().

class MyThread extends Thread {
    public void run() {
        for (int i = 1; i <= 3; i++) {
            System.out.println("MyThread: " + i);
            try { Thread.sleep(200); } catch (InterruptedException e) { }
        }
    }
}

Thread by implementing Runnable

Implement Runnable, define run(), pass the object to a Thread constructor and call start(). This is preferred because the class can still extend another class.

class MyTask implements Runnable {
    public void run() {
        for (int i = 1; i <= 3; i++) {
            System.out.println("MyTask: " + i);
            try { Thread.sleep(200); } catch (InterruptedException e) { }
        }
    }
}

public class ThreadDemo {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        Thread t2 = new Thread(new MyTask());
        t1.start();
        t2.start();
    }
}

Both threads run concurrently, so the output lines interleave (for example MyThread: 1, MyTask: 1, MyThread: 2, MyTask: 2, ...); the exact order may vary. Calling run() directly instead of start() would not create a new thread.

Exception

An exception is an abnormal event or runtime error that disrupts the normal flow of a program's instructions, such as dividing by zero, accessing an invalid array index or opening a missing file. Java handles exceptions with try, catch, finally, throw and throws. All exceptions are subclasses of Throwable; checked exceptions derive from Exception and unchecked ones from RuntimeException.

Creating your own exception (user-defined exception)

When the built-in exceptions do not describe an application-specific error, we create our own class by extending Exception (checked) or RuntimeException (unchecked). Steps:

1. Create a class that extends Exception.
2. Provide a constructor that passes a message to super(message).
3. Use throw new MyException("...") where the error condition occurs.
4. Declare it with throws in the method signature if it is checked, and handle it with try-catch.

class InvalidAgeException extends Exception {
    InvalidAgeException(String message) {
        super(message);
    }
}

public class VoteDemo {
    static void checkAge(int age) throws InvalidAgeException {
        if (age < 18) {
            throw new InvalidAgeException("Age " + age + " is not eligible to vote");
        }
        System.out.println("Eligible to vote");
    }

    public static void main(String[] args) {
        try {
            checkAge(20);
            checkAge(15);
        } catch (InvalidAgeException e) {
            System.out.println("Caught: " + e.getMessage());
        } finally {
            System.out.println("Finished");
        }
    }
}

Output:

Eligible to vote
Caught: Age 15 is not eligible to vote
Finished

The finally block always executes, whether or not an exception occurs.

Wrapper classes

Wrapper classes are classes in java.lang that wrap a primitive value in an object. Every primitive type has one:

They are needed because collections such as ArrayList store only objects, and they provide useful methods like Integer.parseInt("25"), Integer.MAX_VALUE and Double.valueOf().

Autoboxing and unboxing

Autoboxing is the automatic conversion of a primitive into its wrapper object by the compiler. Unboxing is the automatic conversion of a wrapper object back into its primitive. Both were introduced in Java 5.

import java.util.ArrayList;

public class BoxDemo {
    public static void main(String[] args) {
        int a = 10;
        Integer obj = a;          // autoboxing: int -> Integer
        int b = obj;              // unboxing: Integer -> int
        System.out.println(obj + " " + b);

        ArrayList<Integer> list = new ArrayList<>();
        list.add(5);              // autoboxing 5 to Integer
        int x = list.get(0);      // unboxing to int
        System.out.println(x + obj);   // 15
    }
}

Output:

10 10
15

Before Java 5 this had to be done manually: Integer obj = Integer.valueOf(a); and int b = obj.intValue();. Unboxing a null wrapper throws NullPointerException.

JDBC driver

JDBC (Java Database Connectivity) is a Java API (java.sql package) for connecting to relational databases and executing SQL. A JDBC driver is the software component that implements the JDBC interfaces for a specific database and translates Java calls into the database's own protocol. There are four types: Type 1 (JDBC-ODBC bridge), Type 2 (native API), Type 3 (network protocol) and Type 4 (thin, pure Java driver, the most widely used, e.g. MySQL Connector/J).

Steps to connect to a database

1. Import the packages: import java.sql.*;
2. Load and register the driver: Class.forName("com.mysql.cj.jdbc.Driver"); (optional in JDBC 4 and later, because the driver on the classpath registers itself).
3. Establish the connection using DriverManager.getConnection(url, user, password).
4. Create a Statement (Statement or PreparedStatement) from the connection.
5. Execute the SQL query: executeQuery() for SELECT or executeUpdate() for INSERT, UPDATE, DELETE.
6. Process the ResultSet by looping with rs.next().
7. Close the connection (and statement and result set) to release resources.

import java.sql.*;

public class JdbcDemo {
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/college";
        try {
            Class.forName("com.mysql.cj.jdbc.Driver");                      // step 2
            Connection con = DriverManager.getConnection(url, "root", "pass"); // step 3
            Statement st = con.createStatement();                           // step 4
            ResultSet rs = st.executeQuery("SELECT id, name FROM student"); // step 5
            while (rs.next()) {                                             // step 6
                System.out.println(rs.getInt("id") + " " + rs.getString("name"));
            }
            con.close();                                                    // step 7
        } catch (Exception e) {
            System.out.println(e);
        }
    }
}

The MySQL connector JAR must be on the classpath, and the database college with table student must exist.

Use of JavaFX

JavaFX is a Java library for building rich desktop and cross-platform graphical user interface (GUI) applications. It replaces Swing/AWT and is used for:

• creating windows, forms, buttons, tables, charts and menus;
• styling with CSS and designing layouts with FXML;
• 2D/3D graphics, animation, audio and video;
• event-driven applications that run on Windows, Linux and macOS.

Architecture

+--------------------------------------------------+
|              JavaFX Public APIs / Scene Graph     |
|   (Application, Stage, Scene, Nodes, Layouts)     |
+--------------------------------------------------+
|  Glass Windowing Toolkit | Quantum Toolkit        |
|  Prism (rendering)       | Media | Web engines    |
+--------------------------------------------------+
|        Java Virtual Machine (JVM)                 |
+--------------------------------------------------+
|     Operating System / Graphics hardware          |
+--------------------------------------------------+

• Scene graph: a tree of nodes (controls, shapes, layouts) displayed in a scene.
• Stage: the top-level window; Scene: the container of the scene graph content.
• Prism: graphics rendering engine (hardware or software accelerated).
• Glass Windowing Toolkit: connects JavaFX to the native OS for windows and events.
• Quantum Toolkit: ties Prism and Glass together.
• Media and WebView engines: audio/video playback and embedded web content.

First JavaFX application: greeting message

import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.Label;
import javafx.scene.layout.StackPane;
import javafx.stage.Stage;

public class GreetingApp extends Application {
    @Override
    public void start(Stage stage) {
        Label greeting = new Label("Hello! Welcome to JavaFX.");
        StackPane root = new StackPane(greeting);
        Scene scene = new Scene(root, 350, 150);
        stage.setTitle("My First JavaFX App");
        stage.setScene(scene);
        stage.show();
    }

    public static void main(String[] args) {
        launch(args);
    }
}

launch() starts the JavaFX runtime, which calls start(Stage). The label is placed in a layout pane, the pane in a scene, and the scene on the stage window.

Abstraction is the OOP concept of hiding implementation details and showing only the essential features to the user. In Java it is achieved with abstract classes and interfaces. For example, a driver uses the brake pedal without knowing the braking mechanism.

abstract class Vehicle { abstract void run(); }
class Bike extends Vehicle { void run() { System.out.println("Bike runs"); } }

It reduces complexity, increases security and lets implementation change without affecting users.

Polymorphism means "many forms": one name or interface behaving differently in different situations. Java has two kinds:

• Compile-time (static) polymorphism through method overloading: same method name, different parameters, resolved by the compiler. For example add(int, int) and add(double, double).
• Runtime (dynamic) polymorphism through method overriding: a superclass reference calls the subclass's version, resolved at run time.

class Shape { void draw() { System.out.println("Shape"); } }
class Circle extends Shape { void draw() { System.out.println("Circle"); } }
// Shape s = new Circle(); s.draw();   // prints Circle

A real-world example is a person who is a teacher at college, a customer in a shop and a son at home: one person, different behaviour in each role.

A package is a namespace that groups related classes, interfaces and sub-packages together, like a folder in a file system. It is declared at the top of a source file with the package keyword.

package mycollege.util;

public class Helper {
    public static void greet() { System.out.println("Hello from package"); }
}

It is used from another file with import mycollege.util.Helper; (or mycollege.util.*).

Types:

• Built-in packages: java.lang (imported automatically), java.util, java.io, java.sql, java.awt.
• User-defined packages: created by the programmer.

Advantages:

• avoids name conflicts, since classes in different packages can share a name;
• organises large programs and makes classes easy to find;
• provides access protection (package-private members);
• promotes reusability.

Compile with javac -d . Helper.java, which creates the matching directory structure mycollege/util/Helper.class.

The Java Collections Framework (in java.util) is a unified architecture of interfaces, implementation classes and algorithms for storing and manipulating groups of objects. It replaces fixed-size arrays with dynamically growing data structures.

Core interfaces:

• Collection is the root interface. Its main sub-interfaces are List, Set and Queue.
• Map stores key-value pairs and is separate from Collection.

Main implementations:

import java.util.*;

public class CollDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("Ram"); list.add("Sita"); list.add("Ram");
        Set<String> set = new HashSet<>(list);        // duplicates removed
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "Hari");
        System.out.println(list + " " + set.size() + " " + map);
    }
}

The Collections utility class provides algorithms such as sort(), reverse() and max(). Advantages are reduced programming effort, reusable tested code, dynamic size and better performance.

Structure of a Java program

A Java program is organised in these sections, in order:

1. Documentation section: optional comments (//, /* */, /** */).
2. Package statement: optional, package mypack;
3. Import statements: bring in other classes, e.g. import java.util.Scanner;
4. Class definition: one or more classes, with variables and methods.
5. Main method: public static void main(String[] args), the entry point.

// Documentation: simple greeting program
package demo;                       // package statement
import java.util.Scanner;           // import statement

public class Greeting {             // class definition
    String msg = "Hello, ";         // variable
    void show(String name) {        // method
        System.out.println(msg + name);
    }
    public static void main(String[] args) {   // main method
        Scanner sc = new Scanner(System.in);
        String n = sc.nextLine();
        new Greeting().show(n);
    }
}

Concepts of OOP with real-world examples

Class and object: a class is a blueprint and an object is an instance. Car is a class; my red Toyota is an object.

Encapsulation: wrapping data and methods in one unit and hiding data with private plus getters/setters. A bank account hides its balance and lets you change it only via deposit and withdraw.

Inheritance: a class acquires properties of another. Dog and Cat inherit from Animal, as a child inherits traits from parents.

Polymorphism: one interface, many forms. The same "play" button plays music, video or a game depending on the app.

Abstraction: showing essential features and hiding details. An ATM lets you withdraw cash without showing the internal banking process.

Together these make programs modular, reusable, secure and easy to maintain.

Array

An array is a fixed-size, ordered collection of elements of the same data type, stored in contiguous memory locations and accessed using a zero-based index, e.g. int[] age = new int[10];.

Program

import java.util.Scanner;

class SortAge {
    void ascending(int[] arr) {
        int[] a = arr.clone();
        for (int i = 0; i < a.length - 1; i++) {
            for (int j = 0; j < a.length - 1 - i; j++) {
                if (a[j] > a[j + 1]) {
                    int t = a[j]; a[j] = a[j + 1]; a[j + 1] = t;
                }
            }
        }
        System.out.print("Ascending : ");
        for (int x : a) System.out.print(x + " ");
        System.out.println();
    }

    void descending(int[] arr) {
        int[] a = arr.clone();
        for (int i = 0; i < a.length - 1; i++) {
            for (int j = 0; j < a.length - 1 - i; j++) {
                if (a[j] < a[j + 1]) {
                    int t = a[j]; a[j] = a[j + 1]; a[j + 1] = t;
                }
            }
        }
        System.out.print("Descending: ");
        for (int x : a) System.out.print(x + " ");
        System.out.println();
    }
}

public class AgeInput {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int[] ages = new int[10];
        for (int i = 0; i < 10; i++) {
            System.out.print("Enter age of person " + (i + 1) + ": ");
            ages[i] = sc.nextInt();
        }
        SortAge s = new SortAge();
        s.ascending(ages);
        s.descending(ages);
    }
}

For the input 25 18 40 33 21 60 12 45 30 28 the output is:

Ascending : 12 18 21 25 28 30 33 40 45 60 
Descending: 60 45 40 33 30 28 25 21 18 12 

Both methods use bubble sort on a copy, so the original array is not disturbed.

A method is a named block of code that performs a task and can be reused. Syntax: returnType name(parameters) { body }. Methods in Java are classified as follows.

(a) Predefined (library) methods are supplied by the Java API and called directly.

double r = Math.pow(2, 3);       // 8.0
String s = "java".toUpperCase(); // JAVA

(b) User-defined methods are written by the programmer. They may or may not take parameters and may or may not return a value, giving four forms:

class Demo {
    void hello() { System.out.println("Hello"); }          // no param, no return
    void greet(String n) { System.out.println("Hi " + n); } // param, no return
    int five() { return 5; }                                // no param, returns
    int add(int a, int b) { return a + b; }                 // param, returns
}

(c) Static methods belong to the class and are called as ClassName.method() without creating an object.

class MathUtil { static int square(int x) { return x * x; } }
// MathUtil.square(4) returns 16

(d) Instance methods are non-static and need an object: new Demo().add(2, 3) returns 5.

(e) Abstract methods have no body and are declared with abstract in an abstract class or interface; subclasses must implement them.

abstract class Shape { abstract double area(); }

(f) Final methods cannot be overridden by subclasses: final void show() { }.

(g) Overloaded and overridden methods: overloaded methods share a name but differ in parameters (same class); overridden methods redefine a superclass method in a subclass.

(h) Constructors are special methods with the class name and no return type, used to initialise objects.

Constructor

A constructor is a special member method that has the same name as its class and no return type. It is invoked automatically when an object is created with new, and is used to initialise the object's instance variables. If none is written, the compiler supplies a default no-argument constructor. Types: default (no-argument), parameterized, and copy constructor. Constructors can be overloaded.

Program: area of a circle using a constructor

Area of a circle is $A = \pi r^2$.

public class Circle {
    double radius;
    double area;

    Circle(double r) {            // parameterized constructor
        radius = r;
        area = Math.PI * radius * radius;
    }

    void display() {
        System.out.println("Radius = " + radius);
        System.out.println("Area = " + area);
    }

    public static void main(String[] args) {
        Circle c = new Circle(5);
        c.display();
    }
}

Output (for $r = 5$, $A = 3.14159 \times 25 \approx 78.54$):

Radius = 5.0
Area = 78.53981633974483

The constructor receives the radius when new Circle(5) executes, and computes the area at the time of object creation.

Visibility modes (access modifiers) control which classes can access a class, method or variable. Java has four levels.

private: accessible only inside the declaring class. Used to hide data (encapsulation).

default (package-private): used when no modifier is written; accessible within the same package only.

protected: accessible within the package and in subclasses even if they are in different packages.

public: accessible from anywhere.

package pack1;
public class A {
    private int a = 1;
    int b = 2;               // default
    protected int c = 3;
    public int d = 4;
    public int getA() { return a; }   // access private via a public method
}

package pack2;
import pack1.A;
public class B extends A {
    void test() {
        // System.out.println(a);  // error: private
        // System.out.println(b);  // error: default, different package
        System.out.println(c);     // OK: protected via inheritance
        System.out.println(d);     // OK: public
    }
}

Top-level classes can be only public or default; private and protected apply to members (and nested classes).

Inheritance

Inheritance is the mechanism by which a subclass acquires the fields and methods of a superclass using extends. It provides code reuse and supports overriding and polymorphism.

Types of inheritance

1. Single: one subclass extends one superclass. B extends A.
2. Multilevel: a chain of inheritance. C extends B, B extends A.
3. Hierarchical: several subclasses extend one superclass. B extends A, C extends A.
4. Multiple: a class inherits from more than one parent. Not supported with classes in Java; achieved through interfaces.
5. Hybrid: a combination of the above; in Java possible only using interfaces.

 Single: A -> B          Multilevel: A -> B -> C
 Hierarchical: A -> B, A -> C
 Multiple: A, B -> C  (via interfaces)

Multiple inheritance in Java

Java does not allow a class to extend two classes, to avoid the diamond problem (ambiguity when both parents define the same method). We create it using interfaces: a class implements multiple interfaces, using implements.

interface Father {
    void skills();
}

interface Mother {
    void talents();
}

class Child implements Father, Mother {
    public void skills()  { System.out.println("Child has father's skills"); }
    public void talents() { System.out.println("Child has mother's talents"); }
}

public class Main {
    public static void main(String[] args) {
        Child c = new Child();
        c.skills();
        c.talents();
    }
}

Output:

Child has father's skills
Child has mother's talents

Child inherits from both Father and Mother, which is multiple inheritance of type, and since interface methods have no implementation there is no ambiguity.

Example program

class Calculator {
    int add(int a, int b)       { return a + b; }
    double add(double a, double b) { return a + b; }       // overloading
    int add(int a, int b, int c) { return a + b + c; }     // overloading
}

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

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

public class Demo {
    public static void main(String[] args) {
        Calculator c = new Calculator();
        System.out.println(c.add(2, 3));          // 5
        System.out.println(c.add(2.5, 3.5));      // 6.0
        System.out.println(c.add(1, 2, 3));       // 6

        Animal a = new Dog();
        a.sound();                                // Dog barks
    }
}

Output:

5
6.0
6
Dog barks

The three add calls are resolved at compile time from their arguments (overloading), whereas a.sound() is resolved at run time from the actual object Dog (overriding).

Uses of a package

• Groups related classes and interfaces, so large projects are well organised.
• Avoids naming conflicts, because the same class name can exist in different packages.
• Gives access control through package-private and protected members.
• Makes code reusable and easy to locate and maintain.

Uses of an interface

• Defines a contract of methods that implementing classes must provide, giving 100% abstraction.
• Enables multiple inheritance in Java, since a class can implement many interfaces.
• Achieves loose coupling and runtime polymorphism (code depends on the interface, not the implementation).
• Gives a common type to unrelated classes, e.g. Comparable, Runnable.

Steps to create a package

1. Choose a package name (lowercase, e.g. college.math).
2. Declare it as the first statement of every source file: package college.math;
3. Write the public classes inside that file.
4. Compile with -d so the directory structure is created: javac -d . Calculator.java produces college/math/Calculator.class.
5. Import and use the package in another program, then compile and run it.

// File: Calculator.java
package college.math;

public class Calculator {
    public int add(int a, int b) { return a + b; }
    public int multiply(int a, int b) { return a * b; }
}

// File: Main.java
import college.math.Calculator;

public class Main {
    public static void main(String[] args) {
        Calculator c = new Calculator();
        System.out.println("Sum = " + c.add(4, 6));
        System.out.println("Product = " + c.multiply(4, 6));
    }
}

Compile and run: javac -d . Calculator.java, then javac Main.java, then java Main.

Output:

Sum = 10
Product = 24

Classes and methods used from another package must be public; the package folder must be on the classpath.

The Collections Framework is a unified architecture in the java.util package for storing, retrieving and manipulating groups of objects. It provides:

• Interfaces: Collection, List, Set, Queue, Deque and Map (Map is part of the framework but does not extend Collection).
• Implementations: ArrayList, LinkedList, Vector, HashSet, LinkedHashSet, TreeSet, PriorityQueue, HashMap, TreeMap, etc.
• Algorithms: static methods in Collections such as sort(), reverse(), shuffle(), binarySearch(), max().

Its advantages are reduced programming effort, reusable ready-made data structures, good performance, and a common API so that implementations can be swapped easily.

Dynamic list. ArrayList is a resizable array. It grows automatically when elements are added, keeps insertion order and allows duplicates.

Unique list. HashSet (or LinkedHashSet to keep insertion order, TreeSet for sorted order) stores only distinct elements; adding a duplicate is ignored.

import java.util.*;

public class CollectionDemo {
    public static void main(String[] args) {
        // Dynamic list: size grows as needed, duplicates allowed
        List<String> list = new ArrayList<>();
        list.add("Ram");
        list.add("Sita");
        list.add("Ram");          // duplicate is kept
        list.remove("Sita");
        System.out.println("List: " + list);        // [Ram, Ram]
        System.out.println("Size: " + list.size()); // 2

        // Unique list: duplicates are rejected
        Set<String> set = new LinkedHashSet<>();
        set.add("Ram");
        set.add("Sita");
        boolean added = set.add("Ram");             // false, already present
        System.out.println("Set: " + set);          // [Ram, Sita]
        System.out.println("Duplicate added? " + added);
    }
}

Output:

List: [Ram, Ram]
Size: 2
Set: [Ram, Sita]
Duplicate added? false

In Java a thread can be created by extending Thread or by implementing Runnable. When start() is called on two thread objects, the JVM schedules both, so their run() methods execute concurrently and their output is interleaved.

class FirstThread extends Thread {
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println("First thread: " + i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                System.out.println(e);
            }
        }
    }
}

class SecondThread implements Runnable {
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println("Second thread: " + i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                System.out.println(e);
            }
        }
    }
}

public class TwoThreads {
    public static void main(String[] args) {
        Thread t1 = new FirstThread();
        Thread t2 = new Thread(new SecondThread());
        t1.start();     // both threads now run simultaneously
        t2.start();
    }
}

Explanation. start() (not run()) creates a new call stack for each thread. Thread.sleep(500) pauses the current thread for 500 ms, giving the other thread the CPU, so the output alternates, for example:

First thread: 1
Second thread: 1
Second thread: 2
First thread: 2
...

The exact order may differ between runs because thread scheduling is controlled by the operating system and the JVM.

A user-defined (custom) exception is created by extending Exception (checked) or RuntimeException (unchecked). It is raised with throw and handled with try-catch.

import java.util.Scanner;

class NegativeValueException extends Exception {
    NegativeValueException(String message) {
        super(message);
    }
}

public class NegativeTest {
    static void check(int value) throws NegativeValueException {
        if (value < 0) {
            throw new NegativeValueException("Negative value entered: " + value);
        }
        System.out.println("You entered a valid value: " + value);
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter a number: ");
        int n = sc.nextInt();
        try {
            check(n);
        } catch (NegativeValueException e) {
            System.out.println("Exception caught: " + e.getMessage());
        } finally {
            sc.close();
        }
    }
}

Working.

• NegativeValueException extends Exception and passes its message to the superclass constructor.
• check() declares throws NegativeValueException and uses throw new ... when the value is below zero.
• main catches the exception and prints the message.

Sample runs:

Enter a number: 25
You entered a valid value: 25

Enter a number: -7
Exception caught: Negative value entered: -7

An exception is an abnormal event or runtime problem that disrupts the normal flow of a program's instructions (for example dividing by zero or opening a missing file). In Java an exception is an object of a class derived from java.lang.Throwable; when it occurs, the JVM creates the object and throws it. If it is not handled, the program terminates. Java handles exceptions with try, catch, finally, throw and throws.

Hierarchy. Object -> Throwable -> (Error, Exception); Exception -> (RuntimeException and other checked exceptions).

Types of exceptions

(a) Checked exceptions. Checked by the compiler at compile time. The programmer must either handle them with try-catch or declare them with throws; otherwise the code does not compile. They are subclasses of Exception other than RuntimeException. Examples: IOException, FileNotFoundException, SQLException, ClassNotFoundException, InterruptedException.

(b) Unchecked exceptions. Subclasses of RuntimeException. They occur at run time and the compiler does not force handling. They normally indicate programming mistakes. Examples: ArithmeticException, NullPointerException, ArrayIndexOutOfBoundsException, NumberFormatException, ClassCastException.

(c) Errors. Subclasses of Error; they represent serious problems of the JVM or environment that an application should not try to catch, such as OutOfMemoryError, StackOverflowError, VirtualMachineError.

Built-in vs user-defined. Exceptions supplied by Java are built-in; programmers may also write their own by extending Exception or RuntimeException.

public class ExceptionTypes {
    public static void main(String[] args) {
        try {
            int a = 10 / 0;                       // unchecked
        } catch (ArithmeticException e) {
            System.out.println("Caught: " + e.getMessage());
        }
        try {
            new java.io.FileReader("missing.txt"); // checked
        } catch (java.io.FileNotFoundException e) {
            System.out.println("Caught: " + e.getMessage());
        }
    }
}

JDBC (Java Database Connectivity) is a Java API in the packages java.sql and javax.sql that lets Java programs connect to relational databases, send SQL statements and process the results. It gives one common interface; a vendor-specific driver (for example MySQL Connector/J, Oracle's ojdbc, PostgreSQL driver) translates calls into the database's own protocol. Thus the same code works with different databases by changing only the driver and URL.

Steps to connect a Java application to a database

1. Import packages: java.sql.*.
2. Load/register the driver: Class.forName("com.mysql.cj.jdbc.Driver"); (optional in JDBC 4+ if the driver jar is on the classpath, but it must be added to the classpath).
3. Establish the connection: DriverManager.getConnection(url, user, password) where the URL has the form jdbc:<subprotocol>://host:port/database.
4. Create a statement: Statement, PreparedStatement or CallableStatement.
5. Execute the query: executeQuery() for SELECT (returns ResultSet), executeUpdate() for INSERT/UPDATE/DELETE.
6. Process the result: loop over ResultSet with next() and getXxx().
7. Close the resources: ResultSet, Statement, Connection.

import java.sql.*;

public class JdbcDemo {
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/college";
        String user = "root";
        String pass = "secret";
        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            try (Connection con = DriverManager.getConnection(url, user, pass);
                 Statement st = con.createStatement();
                 ResultSet rs = st.executeQuery("SELECT id, name FROM student")) {
                while (rs.next()) {
                    System.out.println(rs.getInt("id") + " " + rs.getString("name"));
                }
            }
        } catch (ClassNotFoundException | SQLException e) {
            e.printStackTrace();
        }
    }
}

To connect to another database, only the driver class, driver jar and URL change, for example jdbc:oracle:thin:@localhost:1521:xe for Oracle or jdbc:postgresql://localhost:5432/college for PostgreSQL.

JavaFX is the Java framework for building rich desktop and media-rich client applications. Its architecture is layered:

• Scene graph: the application UI is a tree of nodes (controls, layouts, shapes, images, media). Each node has a parent except the root; this is the public API through which the developer works.
• Stage and Scene: Stage is the top-level window (the primary stage is passed to start()); a Scene holds the scene graph and is set on a stage. Application is the base class; its lifecycle methods are init(), start(Stage) and stop().
• Java public APIs: javafx.scene, javafx.stage, javafx.scene.control, javafx.scene.layout, animation, CSS styling, FXML, properties and bindings, and event handling.
• Quantum Toolkit: connects Prism and Glass Windowing Toolkit and manages rendering threads.
• Prism: the graphics rendering engine, using hardware acceleration (Direct3D, OpenGL) with software fallback.
• Glass Windowing Toolkit: platform-dependent layer that provides windows, timers and event queue by talking to the operating system.
• Media Engine (audio and video) and Web Engine (embedded HTML through WebView, based on WebKit).
• JVM at the bottom, on which everything runs. UI changes occur on the JavaFX Application Thread.

public class Hello extends javafx.application.Application {
    public void start(javafx.stage.Stage stage) {
        stage.setScene(new javafx.scene.Scene(new javafx.scene.control.Label("Hello"), 200, 100));
        stage.show();
    }
    public static void main(String[] a) { launch(a); }
}

Thread priority is an integer from 1 to 10 that tells the thread scheduler how important a thread is. A higher-priority thread is given preference for CPU time, but this is only a hint: actual scheduling depends on the operating system and JVM, so priority never guarantees execution order.

The Thread class defines three constants:

A new thread inherits the priority of the thread that creates it. Methods: setPriority(int) (throws IllegalArgumentException outside 1 to 10) and getPriority().

class P extends Thread {
    public void run() {
        System.out.println(getName() + " priority = " + getPriority());
    }
    public static void main(String[] args) {
        P t1 = new P();
        P t2 = new P();
        t1.setPriority(Thread.MIN_PRIORITY);
        t2.setPriority(Thread.MAX_PRIORITY);
        t1.start();
        t2.start();
    }
}

Here t1 runs with priority 1 and t2 with priority 10, so t2 is likely, but not certain, to get CPU time first.

finalize() is a method of the Object class, declared as protected void finalize() throws Throwable. The garbage collector calls it on an object just before reclaiming its memory, so it can be overridden to release resources (open files, network or database connections) or to do clean-up.

class Demo {
    protected void finalize() {
        System.out.println("Object is being garbage collected");
    }

    public static void main(String[] args) {
        Demo d = new Demo();
        d = null;           // object becomes unreachable
        System.gc();        // requests garbage collection
    }
}

Points to note

• It is called at most once per object, by the garbage collector, not by the programmer.
• There is no guarantee of when (or whether) it will run, and System.gc() is only a request.
• Exceptions thrown inside it are ignored.
• It is not like a C++ destructor. Since Java 9 it is deprecated (and deprecated for removal in later versions); preferred alternatives are try-with-resources with AutoCloseable, or java.lang.ref.Cleaner.
• It is different from final (a modifier) and finally (a block that always runs after try-catch).

Inheritance is the mechanism by which a class (subclass/child) acquires the fields and methods of another class (superclass/parent) using the extends keyword. It supports code reuse and run-time polymorphism and models an "is-a" relationship.

Interface is a reference type that contains abstract method declarations (plus constants, default, static and private methods since Java 8/9). It defines a contract that a class fulfils with implements. A class may implement any number of interfaces, and an interface may extend several interfaces.

Multiple inheritance. Java does not allow a class to extend more than one class (to avoid ambiguity such as the diamond problem), but multiple inheritance of type is achieved through interfaces.

interface Printable {
    void print();
}

interface Showable {
    void show();
}

class Document implements Printable, Showable {   // multiple inheritance
    public void print() {
        System.out.println("Printing the document");
    }
    public void show() {
        System.out.println("Showing the document");
    }
}

// An interface can also extend several interfaces
interface Both extends Printable, Showable { }

public class MultipleInheritance {
    public static void main(String[] args) {
        Document d = new Document();
        d.print();
        d.show();
        Printable p = d;      // polymorphic reference
        p.print();
    }
}

Output:

Printing the document
Showing the document
Printing the document

If two interfaces declare the same method, the class provides a single implementation, so no ambiguity arises. If they have the same default method, the class must override it.

Difference between error and exception

Handling exceptions in Java. Java uses five keywords:

• try: block containing code that may throw an exception.
• catch: block that handles a particular exception type; several catch blocks (or multi-catch A | B) may follow a try.
• finally: block that always runs (for clean-up), whether or not an exception occurs.
• throw: explicitly throws an exception object.
• throws: declares in a method signature the checked exceptions it may pass to its caller.

public class HandleDemo {
    static int divide(int a, int b) throws ArithmeticException {
        if (b == 0) throw new ArithmeticException("Divisor is zero");
        return a / b;
    }

    public static void main(String[] args) {
        try {
            int[] arr = new int[3];
            System.out.println(divide(10, 2));   // 5
            System.out.println(divide(10, 0));   // throws
            arr[5] = 1;                          // never reached
        } catch (ArithmeticException e) {
            System.out.println("Arithmetic problem: " + e.getMessage());
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Bad index: " + e.getMessage());
        } finally {
            System.out.println("finally block executed");
        }
    }
}

Output:

5
Arithmetic problem: Divisor is zero
finally block executed

When the exception occurs, control leaves the try block at once, the matching catch block runs, then finally runs and execution continues normally.

Differences between Java applet and Java application

(Applets are deprecated since Java 9 and removed in later versions, but remain in the syllabus.)

Steps to execute an applet

1. Write the source code, e.g. HelloApplet.java:

import java.applet.Applet;
import java.awt.Graphics;

public class HelloApplet extends Applet {
    public void paint(Graphics g) {
        g.drawString("Hello Applet", 50, 50);
    }
}

2. Compile it: javac HelloApplet.java, which produces HelloApplet.class.
3. Create an HTML file hello.html that refers to the class:

<html>
  <body>
    <applet code="HelloApplet.class" width="300" height="200"></applet>
  </body>
</html>

4. Run it with the applet viewer: appletviewer hello.html (or open the page in an applet-enabled browser).

Alternatively, put the <applet> tag in a comment at the top of the Java file, /* <applet code="HelloApplet" width=300 height=200></applet> */, and run appletviewer HelloApplet.java.

Importance of multithreading

• Several tasks run concurrently within one program, so the application stays responsive (for example a GUI keeps responding while a file downloads).
• It uses the CPU better: while one thread waits for I/O, others run, and multi-core processors are exploited.
• Threads share the same memory, so they are lightweight and cheaper to create and switch than processes.
• It simplifies modelling of independent activities such as servers handling many clients, animation and background jobs.

Program

class EvenThread extends Thread {
    public void run() {
        for (int i = 1; i <= 10; i++) {
            System.out.println("Even: " + (2 * i));
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                System.out.println(e);
            }
        }
    }
}

class OddRunnable implements Runnable {
    public void run() {
        for (int i = 1; i <= 20; i++) {
            System.out.println("Odd: " + (2 * i - 1));
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                System.out.println(e);
            }
        }
    }
}

public class EvenOddMain {
    public static void main(String[] args) {
        Thread even = new EvenThread();
        Thread odd = new Thread(new OddRunnable());
        even.start();
        odd.start();
    }
}

Explanation. EvenThread extends Thread and prints the first 10 even numbers (2 to 20). OddRunnable implements Runnable and prints the first 20 odd numbers (1 to 39). Each sleeps 100 ms after every number. Since both threads run together, their lines are interleaved, for example:

Even: 2
Odd: 1
Odd: 3
Even: 4
...

After 10 numbers the even thread finishes and the odd thread continues until 39.

A stream is a sequence of data flowing between a program and a source or destination (file, keyboard, network).

Byte streams handle data as 8-bit bytes. Their base classes are InputStream and OutputStream, with subclasses such as FileInputStream, FileOutputStream, BufferedInputStream and DataInputStream. They are suitable for binary data such as images, audio and executables.

Character streams handle 16-bit Unicode characters. Their base classes are Reader and Writer, with subclasses FileReader, FileWriter, BufferedReader, BufferedWriter and InputStreamReader. They are suitable for text and perform character-encoding conversion automatically.

Program: write and read Pokhara.txt

import java.io.*;

public class PokharaFile {
    public static void main(String[] args) {
        // Write
        try (FileWriter fw = new FileWriter("Pokhara.txt")) {
            fw.write("I study BCA");
        } catch (IOException e) {
            System.out.println("Write error: " + e.getMessage());
        }

        // Read
        try (BufferedReader br = new BufferedReader(new FileReader("Pokhara.txt"))) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            System.out.println("Read error: " + e.getMessage());
        }
    }
}

Output:

I study BCA

The same task with byte streams would use FileOutputStream.write("I study BCA".getBytes()) and FileInputStream.read() to obtain each byte.

Difference between AWT and Swing

Event Delegation Model. Events are handled by delegating the processing from the source of the event to separate listener objects. It has three parts:

1. Event source: the component that generates the event (button, text field, window).
2. Event object: an object of a class derived from java.util.EventObject, such as ActionEvent, MouseEvent, KeyEvent, carrying information about the event.
3. Event listener: an object implementing a listener interface (ActionListener, MouseListener, KeyListener) that contains the handler method.

The listener must be registered with the source, e.g. button.addActionListener(this). When the user acts, the source creates an event object and passes it to the registered listener's method (actionPerformed(ActionEvent e)). Only registered listeners are notified, so unrelated events cost nothing, and the GUI code is separated from the event-handling logic.

button.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
        System.out.println("Button clicked");
    }
});

The form uses JTextField for name, address, phone and email, JRadioButton (grouped in a ButtonGroup) for gender, and a JList (list box) for city.

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

public class StudentRegistration extends JFrame implements ActionListener {
    JTextField txtName = new JTextField(20);
    JTextField txtAddress = new JTextField(20);
    JTextField txtPhone = new JTextField(20);
    JTextField txtEmail = new JTextField(20);
    JRadioButton rbMale = new JRadioButton("Male", true);
    JRadioButton rbFemale = new JRadioButton("Female");
    JList<String> lstCity = new JList<>(new String[]{"Kathmandu", "Pokhara", "Lalitpur", "Butwal"});
    JButton btnSubmit = new JButton("Register");

    StudentRegistration() {
        super("Student Registration");
        setLayout(new GridLayout(7, 2, 5, 5));

        ButtonGroup bg = new ButtonGroup();
        bg.add(rbMale);
        bg.add(rbFemale);
        JPanel genderPanel = new JPanel();
        genderPanel.add(rbMale);
        genderPanel.add(rbFemale);

        lstCity.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
        lstCity.setSelectedIndex(0);

        add(new JLabel("Name:"));    add(txtName);
        add(new JLabel("Address:")); add(txtAddress);
        add(new JLabel("Gender:"));  add(genderPanel);
        add(new JLabel("City:"));    add(new JScrollPane(lstCity));
        add(new JLabel("Phone:"));   add(txtPhone);
        add(new JLabel("Email:"));   add(txtEmail);
        add(new JLabel(""));         add(btnSubmit);

        btnSubmit.addActionListener(this);
        setSize(400, 350);
        setDefaultCloseOperation(EXIT_ON_CLOSE);
        setVisible(true);
    }

    public void actionPerformed(ActionEvent e) {
        String gender = rbMale.isSelected() ? "Male" : "Female";
        String msg = "Name: " + txtName.getText()
                + "\nAddress: " + txtAddress.getText()
                + "\nGender: " + gender
                + "\nCity: " + lstCity.getSelectedValue()
                + "\nPhone: " + txtPhone.getText()
                + "\nEmail: " + txtEmail.getText();
        JOptionPane.showMessageDialog(this, msg, "Registered", JOptionPane.INFORMATION_MESSAGE);
    }

    public static void main(String[] args) {
        SwingUtilities.invokeLater(StudentRegistration::new);
    }
}

Explanation. A GridLayout of 7 rows by 2 columns places each label beside its field. The ButtonGroup ensures only one gender can be selected. The JList in single-selection mode acts as the city list box. On clicking Register, actionPerformed collects the values and displays them in a dialog.

A layout manager decides the size and position of components in a container. Main layouts in Java:

• FlowLayout: places components left to right, wrapping to the next row; default for JPanel.
• BorderLayout: five regions (North, South, East, West, Center); default for JFrame.
• GridLayout: equal-sized cells in rows and columns.
• CardLayout: stacks components like cards, showing one at a time.
• BoxLayout: arranges components in a single row or column.
• GridBagLayout: flexible grid whose rows and columns may have different sizes and components may span several cells.
• GroupLayout / SpringLayout: used mostly by GUI builders.

GridBagLayout. Components are placed in a grid of cells, but unlike GridLayout a component may span multiple rows or columns and the rows and columns need not be the same size. Each component is controlled by a GridBagConstraints object with fields:

• gridx, gridy: cell position.
• gridwidth, gridheight: number of cells spanned.
• weightx, weighty: how extra space is distributed.
• fill: how the component fills its cell (NONE, HORIZONTAL, VERTICAL, BOTH).
• anchor: where it sits in the cell; insets: external padding; ipadx, ipady: internal padding.

import javax.swing.*;
import java.awt.*;

public class GridBagDemo {
    public static void main(String[] args) {
        JFrame f = new JFrame("GridBagLayout");
        f.setLayout(new GridBagLayout());
        GridBagConstraints c = new GridBagConstraints();
        c.insets = new Insets(5, 5, 5, 5);
        c.fill = GridBagConstraints.HORIZONTAL;

        c.gridx = 0; c.gridy = 0;
        f.add(new JLabel("Name:"), c);

        c.gridx = 1; c.gridy = 0; c.weightx = 1.0;
        f.add(new JTextField(15), c);

        c.gridx = 0; c.gridy = 1; c.gridwidth = 2;   // spans two columns
        f.add(new JButton("Submit"), c);

        f.pack();
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.setVisible(true);
    }
}

The label and text field share the first row; the button sits on the second row and spans both columns.

A proxy server is an intermediary server that sits between clients and other servers. A client sends its request to the proxy, which forwards it to the destination server and returns the response. Uses:

• Caching: stores frequently requested pages to save bandwidth and speed up access.
• Filtering and access control: blocks unwanted sites and enforces policies.
• Anonymity and security: hides the client's IP address and can inspect traffic.
• Load balancing (reverse proxy) and logging of traffic.

Socket program. The server uses ServerSocket to wait on a port; the client uses Socket to connect. Streams over the socket carry the data.

Server.java

import java.io.*;
import java.net.*;

public class Server {
    public static void main(String[] args) throws IOException {
        try (ServerSocket ss = new ServerSocket(5000)) {
            System.out.println("Server waiting for client...");
            try (Socket s = ss.accept();
                 BufferedReader in = new BufferedReader(new InputStreamReader(s.getInputStream()))) {
                String text = in.readLine();
                System.out.println("Received from client: " + text);
            }
        }
    }
}

Client.java

import java.io.*;
import java.net.*;

public class Client {
    public static void main(String[] args) throws IOException {
        try (Socket s = new Socket("localhost", 5000);
             PrintWriter out = new PrintWriter(s.getOutputStream(), true)) {
            out.println("Hello Server, I study BCA");
        }
    }
}

Run. Start Server first, then Client. The server prints:

Server waiting for client...
Received from client: Hello Server, I study BCA

accept() blocks until a client connects; readLine() reads the text sent by println().

Steps to connect to a database (JDBC)

1. Import java.sql.*.
2. Load the driver, e.g. Class.forName("com.mysql.cj.jdbc.Driver"), with the driver jar on the classpath.
3. Create the connection with DriverManager.getConnection(url, user, password).
4. Create a Statement or PreparedStatement.
5. Execute the SQL (executeQuery / executeUpdate).
6. Process the ResultSet.
7. Close the ResultSet, statement and connection.

Method to authenticate a user. The server is 192.168.10.121, user pouexam, password P0kHarA. A table users(username, password) in a database (here called exam) is assumed. A PreparedStatement is used so that the supplied values cannot cause SQL injection.

import java.sql.*;

public class Auth {
    public static boolean authenticate(String username, String password) {
        String url = "jdbc:mysql://192.168.10.121:3306/exam";
        String dbUser = "pouexam";
        String dbPass = "P0kHarA";
        String sql = "SELECT 1 FROM users WHERE username = ? AND password = ?";

        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            try (Connection con = DriverManager.getConnection(url, dbUser, dbPass);
                 PreparedStatement ps = con.prepareStatement(sql)) {
                ps.setString(1, username);
                ps.setString(2, password);
                try (ResultSet rs = ps.executeQuery()) {
                    return rs.next();     // true if a matching row exists
                }
            }
        } catch (ClassNotFoundException | SQLException e) {
            System.out.println("Database error: " + e.getMessage());
            return false;
        }
    }

    public static void main(String[] args) {
        System.out.println(authenticate("ram", "ram123") ? "Login success" : "Login failed");
    }
}

The method signature is public static boolean authenticate(String username, String password). It returns true when the query finds a row with the given username and password, otherwise false. (In real systems passwords should be stored hashed and compared as hashes.)

The java.net.URL class represents a Uniform Resource Locator, the address of a resource on the Internet. A URL has the form

protocol://host:port/path/filename?query#ref

for example https://www.example.com:8080/docs/index.html. The class lets a program parse a URL and read the resource (openStream(), openConnection()). Constructor: URL(String spec), which throws MalformedURLException for an invalid URL. Important methods:

• getProtocol(): scheme such as http or https.
• getHost(): host name.
• getPort(): port number, or -1 if none is given in the URL.
• getDefaultPort(): default port of the protocol (80 for http, 443 for https).
• getFile() / getPath(): file part (with / without query).
• getQuery(), getRef(), openStream().

import java.net.*;

public class URLDemo {
    public static void main(String[] args) {
        try {
            URL url = new URL("http://www.example.com:8080/docs/index.html?id=5");
            System.out.println("Protocol : " + url.getProtocol());
            System.out.println("Host     : " + url.getHost());
            System.out.println("Port     : " + url.getPort());
            System.out.println("Filename : " + url.getFile());
        } catch (MalformedURLException e) {
            System.out.println("Invalid URL: " + e.getMessage());
        }
    }
}

Output:

Protocol : http
Host     : www.example.com
Port     : 8080
Filename : /docs/index.html?id=5

getPath() would return only /docs/index.html.

Generics let classes, interfaces and methods operate on types specified as parameters (e.g. List<String>), giving compile-time type safety.

Advantages of generics over non-generics

1. Type safety: errors are detected at compile time instead of causing ClassCastException at run time. A raw ArrayList accepts any object, so a wrong type is found only when it is used.
2. No explicit casting: elements are retrieved with their correct type.
3. Code reuse: one class or method works for many types (Box<Integer>, Box<String>).
4. Generic algorithms: sorting, searching and similar logic can be written once for all types.
5. Cleaner, self-documenting code.

// Non-generic
List raw = new ArrayList();
raw.add("Ram");
raw.add(10);
String s = (String) raw.get(1);   // compiles, fails at run time: ClassCastException

// Generic
List<String> names = new ArrayList<>();
names.add("Ram");
// names.add(10);                 // compile-time error
String n = names.get(0);          // no cast needed

Polymorphism in generics. It is achieved in three ways:

• Parametric polymorphism: one generic class or method works with many types.
• Bounded type parameters (<T extends Number>) restrict the type and allow calling methods of the bound.
• Wildcards (? extends, ? super) allow methods to accept related generic types, because List<Integer> is not a subtype of List<Number>.

import java.util.*;

class Pair<T extends Comparable<T>> {
    private T a, b;
    Pair(T a, T b) { this.a = a; this.b = b; }
    T max() { return a.compareTo(b) >= 0 ? a : b; }
}

public class GenericPoly {
    // Generic method
    static <E> void show(E[] arr) {
        for (E e : arr) System.out.print(e + " ");
        System.out.println();
    }

    // Wildcard: accepts List of Integer, Double, etc.
    static double sum(List<? extends Number> list) {
        double total = 0;
        for (Number n : list) total += n.doubleValue();
        return total;
    }

    public static void main(String[] args) {
        System.out.println(new Pair<>(3, 8).max());          // 8
        System.out.println(new Pair<>("apple", "bat").max()); // bat
        show(new Integer[]{1, 2, 3});
        show(new String[]{"A", "B"});
        System.out.println(sum(Arrays.asList(1, 2, 3)));     // 6.0
        System.out.println(sum(Arrays.asList(1.5, 2.5)));    // 4.0
    }
}

The same Pair, show and sum code works for different types, demonstrating polymorphism through generics.

A thread passes through several states between creation and termination, described by Thread.State.

1. New: the thread object has been created (new Thread(...)) but start() has not been called.
2. Runnable: after start(), the thread is ready and waiting for the CPU, or running. (Ready and running are both reported as RUNNABLE.)
3. Running: the scheduler has given it the CPU and run() executes.
4. Blocked: waiting to acquire a monitor lock held by another thread (for example entering a synchronized block).
5. Waiting: waiting indefinitely for another thread, after wait(), join() or park(); resumes on notify()/notifyAll() or when the joined thread ends.
6. Timed waiting: waiting for a specified time, after sleep(ms), wait(ms) or join(ms).
7. Terminated (Dead): run() has completed normally or ended due to an uncaught exception. A dead thread cannot be restarted.

New --start()--> Runnable <--> Running --run() ends--> Terminated
                    ^             |
                    |     sleep / wait / join / lock
                    +-- Blocked / Waiting / Timed waiting

getState() returns the current state, and isAlive() is true between start and termination.

A generic class is declared with one or more type parameters in angle brackets after the class name. The parameters act as placeholders replaced by actual types when an object is created. Conventional names: T (type), E (element), K (key), V (value), N (number).

class Pair<K, V> {
    private K key;
    private V value;

    Pair(K key, V value) {
        this.key = key;
        this.value = value;
    }
    K getKey()   { return key; }
    V getValue() { return value; }
}

public class Test {
    public static void main(String[] args) {
        Pair<String, Integer> p = new Pair<>("Roll", 25);
        String k = p.getKey();      // no cast needed
        int v = p.getValue();
        System.out.println(k + " = " + v);   // Roll = 25
    }
}

Key points

• Several parameters can be used (Pair<K, V>).
• Type arguments must be reference types: Pair<String, Integer>, not int; primitives are autoboxed.
• A parameter can be bounded: class Box<T extends Number>.
• The diamond <> lets the compiler infer the type arguments.
• Type information is erased at run time (type erasure), and new T() is not allowed.
• Benefits: type safety, no casts, reusable code.

A JDBC driver is a software component that lets a Java application communicate with a particular database. It implements the JDBC interfaces and translates JDBC calls into the database's protocol. There are four types:

Type 1: JDBC-ODBC bridge driver. Converts JDBC calls into ODBC calls, which the ODBC driver passes to the database. Needs the ODBC driver installed on the client. Slow and platform-dependent; removed in Java 8.

Type 2: Native-API driver (partly Java). Converts JDBC calls into the database vendor's native client library calls (e.g. Oracle OCI). Faster than Type 1, but needs native libraries on each client and is not fully portable.

Type 3: Network protocol driver (middleware). Sends JDBC calls over the network to a middleware server in a database-independent protocol; the server converts them for the database. Pure Java client, no client-side installation, suits the internet, but needs a middleware server.

Type 4: Thin driver (pure Java). Converts JDBC calls directly into the database's own network protocol. Platform-independent, fastest and most widely used; examples are MySQL Connector/J, the Oracle thin driver and the PostgreSQL driver.

Type 4 is generally preferred, with Type 3 where one driver must serve many databases.

Platform independence. A language or program is platform independent if it can run on any operating system and hardware without modification. Java achieves this with "Write Once, Run Anywhere": the Java compiler (javac) converts source code into bytecode (.class), not into machine code. Bytecode is executed by the Java Virtual Machine (JVM), which exists for each platform (Windows, Linux, macOS) and converts bytecode to native instructions. Hence the same .class file runs on any system that has a JVM. Further reasons: fixed sizes of primitive types (an int is always 32 bits), and a standard library behaving the same everywhere.

Source (.java) --javac--> Bytecode (.class) --JVM(Windows/Linux/Mac)--> Machine code

Multiple inheritance in Java. Java does not allow a class to extend more than one class because it creates ambiguity (the diamond problem: if two parents define the same method, which one does the child inherit?). Java supports multiple inheritance through interfaces: a class can implement any number of interfaces, because interfaces carry no state and the class supplies a single implementation.

Real-world example. A smartphone is both a camera and a phone (and a music player). Camera and Phone are separate capabilities, and a smartphone class inherits from both.

interface Camera {
    void takePhoto();
}

interface Phone {
    void call(String number);
}

class SmartPhone implements Camera, Phone {
    public void takePhoto() {
        System.out.println("Photo taken");
    }
    public void call(String number) {
        System.out.println("Calling " + number);
    }
}

public class Demo {
    public static void main(String[] args) {
        SmartPhone s = new SmartPhone();
        s.takePhoto();
        s.call("9800000000");
        Camera c = s;       // can be used as either type
        Phone p = s;
    }
}

Output:

Photo taken
Calling 9800000000

Thus the smartphone gets the behaviour of both parents without ambiguity. If two interfaces have the same default method, the class must override it, resolving any conflict explicitly.

When to use exception handling

Exception handling is used when a program may meet abnormal run-time conditions that it can report or recover from, so it does not crash. Examples are invalid input, division by zero, a missing file, a network failure, or a business-rule violation (such as insufficient balance). It separates error-handling code from normal logic, lets errors propagate to a suitable handler, and allows resources to be released in finally.

Program: user-defined exception for recharge balance below Rs 10

A call needs at least Rs 10 balance. If the balance is less, an InsufficientFundException is thrown, and the user must recharge.

class InsufficientFundException extends Exception {
    InsufficientFundException(String msg) { super(msg); }
}

class Mobile {
    private double balance;
    Mobile(double balance) { this.balance = balance; }

    void call(String number) throws InsufficientFundException {
        if (balance < 10)
            throw new InsufficientFundException(
                "Insufficient fund: balance Rs " + balance + " is less than Rs 10. Please recharge.");
        System.out.println("Calling " + number + " ...");
    }

    void recharge(double amount) {
        balance += amount;
        System.out.println("Recharged Rs " + amount + ", balance = Rs " + balance);
    }
}

public class RechargeTest {
    public static void main(String[] args) {
        Mobile m = new Mobile(5);
        try {
            m.call("9841000000");
        } catch (InsufficientFundException e) {
            System.out.println(e.getMessage());
            m.recharge(50);
        }
    }
}

Output:

Insufficient fund: balance Rs 5.0 is less than Rs 10. Please recharge.
Recharged Rs 50.0, balance = Rs 55.0

Applet

An applet is a small Java program that is embedded in a web page and runs inside a browser or the appletviewer, using the JVM. It extends java.applet.Applet (or javax.swing.JApplet) and has no main() method. (Applets are deprecated in recent Java versions, but they are still part of the syllabus.)

Life cycle of an applet

The browser calls these methods automatically:

1. init(): called once when the applet is first loaded. It initialises variables, loads images and builds the interface.
2. start(): called after init() and every time the page is revisited. It starts the applet's work (for example, threads or animation).
3. paint(Graphics g): called whenever the output must be drawn or redrawn.
4. stop(): called when the user leaves the page or the applet is minimised. It suspends activity.
5. destroy(): called once when the applet is removed from memory. It releases resources.

Order: init() -> start() -> paint() -> stop() -> (start() again if revisited) -> destroy().

Example

import java.applet.Applet;
import java.awt.Graphics;

public class LifeApplet extends Applet {
    String msg = "";
    public void init()    { msg += " init"; }
    public void start()   { msg += " start"; }
    public void paint(Graphics g) { g.drawString(msg, 20, 30); }
    public void stop()    { System.out.println("stop"); }
    public void destroy() { System.out.println("destroy"); }
}

HTML to run it:

<applet code="LifeApplet.class" width="300" height="100"></applet>

Thread

A thread is a lightweight unit of execution inside a process. All threads of a process share its memory, but each has its own stack and program counter. Multithreading lets a program do several tasks at once.

Importance

• Better CPU utilisation, because one thread runs while another waits for I/O.
• Responsive applications (the GUI stays active while a background task runs).
• Cheaper than processes, since creating and switching threads costs less and they share data easily.
• Suits server programs that handle many clients at once, and parallel computation.

Runnable interface

java.lang.Runnable has one method, void run(). A class implements Runnable and puts the task in run(). A Thread object is then created with the Runnable and started with start(). This is preferred over extending Thread because the class can still extend another class.

class Task implements Runnable {
    private String name;
    Task(String name) { this.name = name; }

    public void run() {
        for (int i = 1; i <= 3; i++) {
            System.out.println(name + " : " + i);
            try { Thread.sleep(500); } catch (InterruptedException e) { }
        }
    }
}

public class RunnableDemo {
    public static void main(String[] args) {
        Thread t1 = new Thread(new Task("Thread-A"));
        Thread t2 = new Thread(new Task("Thread-B"));
        t1.start();
        t2.start();
    }
}

Both threads run concurrently, so their outputs interleave. Calling run() directly would not create a new thread, so start() must be used.

PrintWriter

java.io.PrintWriter is a character-output class that prints formatted text to a stream or file. It has the methods print(), println() and printf(), can wrap a File, FileWriter or OutputStream, and does not throw IOException from its print methods (use checkError()). It is often wrapped over BufferedWriter for efficiency.

Sequential file program

In a sequential file, data is written and read in order from the start. The program below writes records and then reads them back sequentially.

import java.io.*;
import java.util.Scanner;

public class SequentialFile {
    public static void main(String[] args) throws IOException {
        // write sequentially
        try (PrintWriter pw = new PrintWriter(new FileWriter("data.txt"))) {
            pw.println("1 Ram 80");
            pw.println("2 Sita 90");
            pw.printf("%d %s %d%n", 3, "Hari", 75);
        }

        // read sequentially
        try (Scanner sc = new Scanner(new File("data.txt"))) {
            while (sc.hasNextLine()) {
                System.out.println(sc.nextLine());
            }
        }
    }
}

Output:

1 Ram 80
2 Sita 90
3 Hari 75

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

public class RegistrationScreen extends JFrame implements ActionListener {
    JTextField txtName, txtUser;
    JPasswordField txtPass;
    JButton btnRegister;

    public RegistrationScreen() {
        setTitle("Registration");
        setLayout(new GridLayout(4, 2, 5, 5));

        add(new JLabel("Full Name:"));
        txtName = new JTextField();
        add(txtName);

        add(new JLabel("Username:"));
        txtUser = new JTextField();
        add(txtUser);

        add(new JLabel("Password:"));
        txtPass = new JPasswordField();
        add(txtPass);

        btnRegister = new JButton("Register");
        btnRegister.addActionListener(this);
        add(new JLabel());          // empty cell
        add(btnRegister);

        setSize(350, 180);
        setDefaultCloseOperation(EXIT_ON_CLOSE);
        setLocationRelativeTo(null);
        setVisible(true);
    }

    public void actionPerformed(ActionEvent e) {
        String name = txtName.getText();
        String user = txtUser.getText();
        String pass = new String(txtPass.getPassword());
        if (name.isEmpty() || user.isEmpty() || pass.isEmpty()) {
            JOptionPane.showMessageDialog(this, "Please fill all fields");
        } else {
            JOptionPane.showMessageDialog(this, "Registered: " + name + " (" + user + ")");
        }
    }

    public static void main(String[] args) {
        SwingUtilities.invokeLater(RegistrationScreen::new);
    }
}

The program uses JLabel, JTextField, JPasswordField and JButton in a 4x2 GridLayout. The button's ActionListener reads the fields and shows a confirmation message.

Socket

A socket is one endpoint of a two-way communication link between two programs on a network. It is identified by an IP address and a port number. Java provides java.net.Socket for the client and java.net.ServerSocket for the server, and TCP sockets give reliable, connection-oriented communication.

Server (receives text)

import java.io.*;
import java.net.*;

public class Server {
    public static void main(String[] args) throws IOException {
        ServerSocket ss = new ServerSocket(5000);
        System.out.println("Waiting for client...");
        Socket s = ss.accept();
        BufferedReader in = new BufferedReader(new InputStreamReader(s.getInputStream()));
        String text = in.readLine();
        System.out.println("Received: " + text);
        in.close(); s.close(); ss.close();
    }
}

Client (sends text)

import java.io.*;
import java.net.*;

public class Client {
    public static void main(String[] args) throws IOException {
        Socket s = new Socket("localhost", 5000);
        PrintWriter out = new PrintWriter(s.getOutputStream(), true);
        out.println("Hello Server");
        out.close(); s.close();
    }
}

Run the server first, then the client. The server prints Received: Hello Server.

Proxy server

A proxy server is an intermediate server between clients and other servers (usually the Internet). The client sends its request to the proxy, which forwards it to the destination, receives the reply and returns it to the client. Uses include caching (faster repeat access), filtering or blocking sites, hiding the client's IP address (anonymity), logging, and security control.

Steps to implement a TCP/IP client/server application

Server side

1. Create a ServerSocket on a port: ServerSocket ss = new ServerSocket(port);
2. Wait for a client: Socket s = ss.accept(); (this blocks until a client connects).
3. Get the input and output streams: s.getInputStream() and s.getOutputStream(), and wrap them in readers and writers.
4. Read the request and send the response.
5. Close the streams and sockets.

Client side

1. Create a Socket with the server's host and port: Socket s = new Socket(host, port);
2. Get the input and output streams of the socket.
3. Send the request and read the response.
4. Close the streams and the socket.

For many clients, the server runs a loop that calls accept() and gives each connection to a new thread.

import java.sql.*;

public class StudentJDBC {
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/college";
        String user = "root", pass = "password";

        try (Connection con = DriverManager.getConnection(url, user, pass)) {
            Class.forName("com.mysql.cj.jdbc.Driver");

            Statement st = con.createStatement();
            st.executeUpdate("CREATE TABLE IF NOT EXISTS tbl_students ("
                + "sid INT PRIMARY KEY, name VARCHAR(50), "
                + "semester INT, program VARCHAR(30))");

            // save
            String sql = "INSERT INTO tbl_students VALUES (?, ?, ?, ?)";
            PreparedStatement ps = con.prepareStatement(sql);
            ps.setInt(1, 101);
            ps.setString(2, "Ram Sharma");
            ps.setInt(3, 3);
            ps.setString(4, "BCA");
            ps.executeUpdate();

            // read back
            ResultSet rs = st.executeQuery("SELECT * FROM tbl_students");
            System.out.println("SID\tName\tSemester\tProgram");
            while (rs.next()) {
                System.out.println(rs.getInt("sid") + "\t" + rs.getString("name")
                    + "\t" + rs.getInt("semester") + "\t" + rs.getString("program"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Steps: load the driver, open a Connection, create the table, insert the student with a PreparedStatement, run SELECT to get a ResultSet, and loop with rs.next() to print rows. Running the insert twice with the same sid would violate the primary key.

JDBC driver

A JDBC driver is a set of classes that implements the JDBC interfaces (Driver, Connection, Statement, ResultSet) for a specific database. It translates Java JDBC calls into the protocol that the database understands, and DriverManager uses it to create connections.

Types of JDBC drivers

Type 4 is most widely used today (for example com.mysql.cj.jdbc.Driver, oracle.jdbc.OracleDriver).

Class.forName("com.mysql.cj.jdbc.Driver");
Connection con = DriverManager.getConnection("jdbc:mysql://localhost/db", "user", "pw");

In the event delegation model, the handling of an event is delegated to a separate listener object. It has three parts.

1. Event source: the component that generates the event (button, text field, window).
2. Event object: describes the event (ActionEvent, MouseEvent, KeyEvent).
3. Event listener: an object that implements a listener interface (ActionListener, MouseListener) and is registered with the source using addXxxListener().

Steps: create the component, implement the listener interface, register the listener with the source, and write the code in the handler method. Only registered listeners are notified, so this is more efficient than the old model, where every event was passed through the component hierarchy. It also separates the interface logic from the application logic.

import java.awt.*;
import java.awt.event.*;

public class DelegationDemo extends Frame implements ActionListener {
    Button b = new Button("Click");
    Label l = new Label("Not clicked   ");

    DelegationDemo() {
        setLayout(new FlowLayout());
        add(b); add(l);
        b.addActionListener(this);          // register listener with source
        setSize(250, 100); setVisible(true);
    }

    public void actionPerformed(ActionEvent e) {   // event handler
        l.setText("Button clicked");
    }

    public static void main(String[] a) { new DelegationDemo(); }
}

Here the button is the source, ActionEvent is the event, and the frame is the listener.

Example of random access:

RandomAccessFile raf = new RandomAccessFile("data.dat", "rw");
raf.writeInt(10);
raf.writeInt(20);
raf.writeInt(30);
raf.seek(4);                       // skip first int (4 bytes)
System.out.println(raf.readInt()); // 20
raf.close();

Other useful methods are getFilePointer() and length().

Write Once, Run Anywhere (WORA)

A Java program is written and compiled once. The compiler (javac) converts the source file into platform-neutral bytecode (.class), and this bytecode can run unchanged on any machine that has a JVM, whether Windows, Linux or macOS. The JVM turns the bytecode into the machine instructions of its own platform. So the program does not need to be rewritten or recompiled for each platform.

Source (.java) --javac--> Bytecode (.class) --> JVM on Windows / Linux / macOS

JVM architecture

1. Class Loader subsystem: loads, links and initialises classes (Bootstrap, Extension/Platform and Application class loaders). Linking has verification, preparation and resolution.
2. Runtime data areas (memory)
   • Method area: class metadata, static variables, constant pool, method code.
   • Heap: all objects and arrays, shared by all threads and managed by the garbage collector.
   • Stack: one per thread, holding frames with local variables and partial results of method calls.
   • PC register: one per thread, holding the address of the current instruction.
   • Native method stack: for native (non-Java) methods.
3. Execution engine
   • Interpreter: executes bytecode line by line.
   • JIT compiler: compiles frequently used bytecode to native code for speed.
   • Garbage collector: frees objects that are no longer used.
4. Native method interface (JNI) and native libraries: connect the JVM to code written in C/C++.

Because each platform has its own JVM that follows the same specification, the same bytecode behaves the same everywhere, and this gives WORA.

Importance of exception handling

• It prevents abnormal termination, because errors are caught and the program continues or ends cleanly.
• It separates normal logic from error-handling code (try/catch), so the code is cleaner.
• Errors can be passed up the call stack to a method that knows how to handle them (throws).
• It gives meaningful messages to users and supports resource clean-up with finally.
• Business rules can be enforced with user-defined exceptions.

Program

class InsufficientFundException extends Exception {
    InsufficientFundException(String message) { super(message); }
}

class Account {
    private double balance;
    Account(double balance) { this.balance = balance; }

    void withdraw(double amount) throws InsufficientFundException {
        if (balance < 100)
            throw new InsufficientFundException(
                "Insufficient fund: balance Rs " + balance + " is less than Rs 100");
        if (amount > balance)
            throw new InsufficientFundException("Withdrawal exceeds balance");
        balance -= amount;
        System.out.println("Withdrawn Rs " + amount + ", balance Rs " + balance);
    }
}

public class BankTest {
    public static void main(String[] args) {
        Account acc = new Account(80);
        try {
            acc.withdraw(20);
        } catch (InsufficientFundException e) {
            System.out.println("Error: " + e.getMessage());
        } finally {
            System.out.println("Transaction finished");
        }
    }
}

Output:

Error: Insufficient fund: balance Rs 80.0 is less than Rs 100
Transaction finished

Applet

An applet is a small Java program that is embedded in an HTML page and runs inside a browser or appletviewer. It extends java.applet.Applet, has no main() method, and its life cycle methods (init, start, paint, stop, destroy) are called by the browser.

Applet code (HelloPU.java)

import java.applet.Applet;
import java.awt.Graphics;

public class HelloPU extends Applet {
    public void paint(Graphics g) {
        g.drawString("Hello Pokhara University", 50, 50);
    }
}

Compile it with javac HelloPU.java.

HTML code (index.html)

<html>
<head><title>Hello Applet</title></head>
<body>
    <applet code="HelloPU.class" width="300" height="150">
    </applet>
</body>
</html>

Open the page in an applet-enabled environment, or run appletviewer index.html. The window displays "Hello Pokhara University". The .class file must be in the same folder as the HTML file, unless codebase is given.

Why synchronization is required

When several threads use the same shared resource (a variable, a file, an account) at the same time, their operations can interleave and produce wrong or inconsistent results. This is called a race condition. For example, two threads doing count++ can both read the same old value and each write back the same new value, so one update is lost. Synchronization allows only one thread at a time into the critical section, using the object's monitor lock. It ensures data consistency and thread safety.

Ways to do it: a synchronized method, a synchronized block, or Lock objects.

Example

class Counter {
    private int count = 0;
    synchronized void increment() { count++; }   // only one thread at a time
    int get() { return count; }
}

class Worker extends Thread {
    Counter c;
    Worker(Counter c) { this.c = c; }
    public void run() {
        for (int i = 0; i < 1000; i++) c.increment();
    }
}

public class SyncDemo {
    public static void main(String[] args) throws InterruptedException {
        Counter c = new Counter();
        Worker t1 = new Worker(c), t2 = new Worker(c);
        t1.start(); t2.start();
        t1.join();  t2.join();
        System.out.println("Count = " + c.get());   // always 2000
    }
}

Without synchronized, the result may be less than 2000. With it, the result is always 2000.

Java Stream

A stream is a sequence of data flowing from a source to a destination. Java I/O uses streams in the package java.io.

• Input stream: reads data into a program (InputStream, Reader).
• Output stream: writes data from a program (OutputStream, Writer).
• Byte streams (FileInputStream, FileOutputStream) handle binary data in 8-bit bytes.
• Character streams (FileReader, FileWriter) handle text in 16-bit Unicode.

Program to write student info into Student.txt

import java.io.*;
import java.util.Scanner;

public class WriteStudent {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter name: ");
        String stdName = sc.nextLine();
        System.out.print("Enter age: ");
        int stdAge = sc.nextInt();
        System.out.print("Enter id: ");
        int stdId = sc.nextInt();

        try (FileWriter fw = new FileWriter("Student.txt");
             BufferedWriter bw = new BufferedWriter(fw)) {
            bw.write("Name: " + stdName);
            bw.newLine();
            bw.write("Age: " + stdAge);
            bw.newLine();
            bw.write("Id: " + stdId);
            bw.newLine();
            System.out.println("Data written to Student.txt");
        } catch (IOException e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

The try-with-resources statement closes the file automatically.

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

public class LoginForm extends JFrame implements ActionListener {
    JTextField txtUser = new JTextField(15);
    JPasswordField txtPass = new JPasswordField(15);
    JButton btnLogin = new JButton("Login");
    JLabel lblMsg = new JLabel(" ");

    public LoginForm() {
        setTitle("Login");
        setLayout(new FlowLayout());
        add(new JLabel("Username:"));
        add(txtUser);
        add(new JLabel("Password:"));
        add(txtPass);
        add(btnLogin);
        add(lblMsg);

        btnLogin.addActionListener(this);

        setSize(260, 190);
        setDefaultCloseOperation(EXIT_ON_CLOSE);
        setVisible(true);
    }

    public void actionPerformed(ActionEvent e) {
        String user = txtUser.getText();
        String pass = new String(txtPass.getPassword());
        if (user.equals("Ram") && pass.equals("IIIIIII"))
            lblMsg.setText("welcome");
        else
            lblMsg.setText("invalid login");
    }

    public static void main(String[] args) {
        new LoginForm();
    }
}

The equals() method compares the strings exactly. When the button is clicked, the program shows "welcome" for username Ram with password IIIIIII, and "invalid login" otherwise.

Listener

A listener is an object that waits for and handles events from a GUI component. It is an instance of a class that implements a listener interface from java.awt.event (for example ActionListener, MouseListener, KeyListener). It is registered with a component using addXxxListener(), and when the event occurs, the matching method is called automatically.

MouseListener methods (event type MouseEvent)

KeyListener methods (event type KeyEvent)

Useful KeyEvent methods are getKeyChar() and getKeyCode(), and for the mouse getX(), getY() and getClickCount().

import java.awt.*;
import java.awt.event.*;

public class ListenerDemo extends Frame implements MouseListener, KeyListener {
    Label l = new Label("Interact with me");

    ListenerDemo() {
        add(l);
        addMouseListener(this);
        addKeyListener(this);
        setSize(300, 150); setVisible(true);
    }
    public void mouseClicked(MouseEvent e)  { l.setText("Clicked at " + e.getX() + "," + e.getY()); }
    public void mousePressed(MouseEvent e)  { }
    public void mouseReleased(MouseEvent e) { }
    public void mouseEntered(MouseEvent e)  { l.setText("Mouse entered"); }
    public void mouseExited(MouseEvent e)   { l.setText("Mouse exited"); }
    public void keyPressed(KeyEvent e)      { l.setText("Key pressed: " + e.getKeyChar()); }
    public void keyReleased(KeyEvent e)     { }
    public void keyTyped(KeyEvent e)        { }

    public static void main(String[] a) { new ListenerDemo(); }
}

All methods of the interface must be implemented, or an adapter class (MouseAdapter, KeyAdapter) can be used.

java.net

java.net is the Java package for network programming. It contains classes for TCP sockets (Socket, ServerSocket), UDP communication (DatagramSocket, DatagramPacket), addresses (InetAddress) and web resources (URL, URLConnection, HttpURLConnection).

Datagram communication uses UDP, which is connectionless and fast but gives no guarantee of delivery or order. DatagramPacket holds the data, length, address and port, and DatagramSocket sends and receives the packets.

Receiver (run first)

import java.net.*;

public class UDPReceiver {
    public static void main(String[] args) throws Exception {
        DatagramSocket ds = new DatagramSocket(9876);
        byte[] buf = new byte[1024];
        DatagramPacket dp = new DatagramPacket(buf, buf.length);
        ds.receive(dp);                       // blocks until a packet arrives
        String msg = new String(dp.getData(), 0, dp.getLength());
        System.out.println("Received: " + msg);
        ds.close();
    }
}

Sender

import java.net.*;

public class UDPSender {
    public static void main(String[] args) throws Exception {
        DatagramSocket ds = new DatagramSocket();
        byte[] data = "Hello UDP".getBytes();
        InetAddress ip = InetAddress.getByName("localhost");
        DatagramPacket dp = new DatagramPacket(data, data.length, ip, 9876);
        ds.send(dp);
        ds.close();
    }
}

The receiver prints Received: Hello UDP.

Proxy server

A proxy server is an intermediary between a client and the Internet. The client sends requests to the proxy, which forwards them to the target server and returns the reply. It provides caching, content filtering, access control, logging and hides the client's IP address.

Program to read the content of http://www.pu.edu.np

import java.io.*;
import java.net.*;

public class ReadURL {
    public static void main(String[] args) {
        try {
            URL url = new URL("http://www.pu.edu.np");
            URLConnection conn = url.openConnection();
            conn.setConnectTimeout(5000);

            BufferedReader br = new BufferedReader(
                    new InputStreamReader(conn.getInputStream()));
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
            br.close();
        } catch (MalformedURLException e) {
            System.out.println("Bad URL: " + e.getMessage());
        } catch (IOException e) {
            System.out.println("I/O error: " + e.getMessage());
        }
    }
}

URL represents the address, openConnection() returns a URLConnection, and getInputStream() gives the stream used to read the HTML text line by line.

import java.sql.*;

public class ReadUsers {
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/college";
        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            Connection con = DriverManager.getConnection(url, "root", "password");

            Statement st = con.createStatement();
            ResultSet rs = st.executeQuery("SELECT roll, name, address FROM users");

            System.out.println("Roll\tName\tAddress");
            while (rs.next()) {
                int roll = rs.getInt("roll");
                String name = rs.getString("name");
                String address = rs.getString("address");
                System.out.println(roll + "\t" + name + "\t" + address);
            }

            rs.close();
            st.close();
            con.close();
        } catch (ClassNotFoundException | SQLException e) {
            e.printStackTrace();
        }
    }
}

Steps: load the driver, connect with DriverManager, create a Statement, run the SELECT query to get a ResultSet, loop over rows with rs.next(), read columns with getXxx(), and close the resources. The table users(roll INT, name VARCHAR, address VARCHAR) is assumed.

Swing vs AWT

AWT (Abstract Window Toolkit, java.awt) is Java's original GUI toolkit. Its components (Button, TextField, Label) are heavyweight: each one is backed by a native peer from the operating system, so the look changes from platform to platform. Swing (javax.swing) is built on top of AWT. Most of its components (JButton, JTextField, JLabel) are lightweight: they are drawn by Java itself, not by the OS.

Both use the same event-handling model (listeners such as ActionListener). Swing is preferred today because it is more flexible and portable.

JVM Architecture

The Java Virtual Machine (JVM) is the abstract machine that loads and executes Java bytecode (.class files). It makes Java platform independent: the compiler produces bytecode once, and each platform's JVM runs it.

Main components:

1. Class loader subsystem: loads, links and initialises classes.
   • Loading: Bootstrap, Extension (Platform) and Application class loaders read the .class file.
   • Linking: verification (bytecode is checked for safety), preparation (static variables get default values) and resolution (symbolic references become direct references).
   • Initialisation: static variables get their assigned values and static blocks run.
2. Runtime data areas (memory):
   • Method area: class structures, method code, constant pool and static data (shared by all threads).
   • Heap: all objects and arrays are created here; it is shared and managed by the garbage collector.
   • Stack area: each thread has its own stack of frames; a frame holds local variables, the operand stack and a reference to the constant pool.
   • PC register: each thread has one, holding the address of the instruction being executed.
   • Native method stack: used for native (non-Java) methods.
3. Execution engine: executes the bytecode.
   • Interpreter: reads and executes bytecode instruction by instruction.
   • JIT compiler: compiles frequently used code ("hot spots") to native machine code to improve speed.
   • Garbage collector: frees memory of objects that are no longer referenced.
4. Native method interface (JNI) and native libraries: allow Java code to call C/C++ libraries.

Flow: .java -> compiler (javac) -> .class bytecode -> class loader -> runtime data areas -> execution engine -> machine.