Java Fundamentals: Constructors, Packages, GUI, and Exceptions

Posted on Sep 5, 2025 in Electronic Engineering

Java Constructors: Default and Parameterized

Constructors are special methods used to initialize objects. Java supports different types of constructors to suit various initialization needs.

Default Constructor

A default constructor is a constructor with no parameters. If you don’t define any constructor in your class, Java provides one by default.

Example: Default Constructor in Action

public class Student {
    String name;
    int age;

    // Default constructor
    Student() {
        name = "Unknown";
        age = 0;
    }

    public void display() {
        System.out.println("Name: " + name + ", Age: " + age);
    }

    public static void main(String[] args) {
        Student s1 = new Student(); // Calls the default constructor
        s1.display(); // Output: Name: Unknown, Age: 0
    }
}

Parameterized Constructor

A parameterized constructor is a constructor that accepts arguments. It is used to initialize objects with specific values provided at the time of object creation.

Example: Parameterized Constructor Usage

public class Student {
    String name;
    int age;

    // Parameterized constructor
    Student(String n, int a) {
        name = n;
        age = a;
    }

    public void display() {
        System.out.println("Name: " + name + ", Age: " + age);
    }

    public static void main(String[] args) {
        Student s2 = new Student("Alice", 20); // Calls the parameterized constructor
        s2.display(); // Output: Name: Alice, Age: 20
    }
}

Understanding Java Packages

Java packages are a mechanism to organize classes and interfaces into logical groups. They help in preventing naming conflicts and making code more modular and reusable.

Built-in Java Packages

Java provides numerous built-in packages that offer a wide range of functionalities:

java.lang

Contains fundamental classes essential to the Java programming language (e.g., String, Math, System).

java.util

Provides utility classes and interfaces for data structures, date/time, and more (e.g., ArrayList, HashMap, Date).

java.io

Supports input and output operations (e.g., File, BufferedReader).

java.net

Offers classes for network operations (e.g., Socket, URL).

java.sql

Provides classes for database access using JDBC (e.g., Connection, ResultSet).

javax.swing

Contains classes for creating graphical user interfaces (e.g., JFrame, JButton).

Example: Using a Built-in Package (java.util.Scanner)

import java.util.Scanner; // Import the Scanner class from java.util package

public class BuiltInExample {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter your name: ");
        String name = sc.nextLine();
        System.out.println("Hello, " + name);
        sc.close(); // It's good practice to close the scanner
    }
}

User-Defined Packages

Developers create user-defined packages to structure their own code, making it more organized, maintainable, and reusable across different projects.

Step 1: Create a Package

To create a package, declare the package name at the top of your Java source file. For example, if your package is named mypackage:

// File: mypackage/MyClass.java
package mypackage; // Declares this class belongs to 'mypackage'

public class MyClass {
    public void showMessage() {
        System.out.println("Hello from MyPackage!");
    }
}

Step 2: Use the Package in Another Class

To use classes from a user-defined package, you need to import them into your new class:

// File: TestPackage.java
import mypackage.MyClass; // Import the MyClass from 'mypackage'

public class TestPackage {
    public static void main(String[] args) {
        MyClass obj = new MyClass(); // Create an object of MyClass
        obj.showMessage(); // Call its method
    }
}

Java GUI Components: AWT, Swing, and JavaFX

Java offers several toolkits for building graphical user interfaces (GUIs). The most prominent ones are AWT, Swing, and JavaFX.

AWT/Swing Components

The Abstract Window Toolkit (AWT) was Java’s original GUI toolkit. Swing, built on top of AWT, provides a richer set of components and a more flexible architecture.

Example: Simple Swing GUI Application

import javax.swing.*;

public class SimpleGUI {
    public static void main(String[] args) {
        // Create the main window (JFrame)
        JFrame frame = new JFrame("Simple GUI");
        frame.setSize(300, 200); // Set window size
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // Close operation

        // Create a panel to hold components
        JPanel panel = new JPanel();

        // Create components
        JLabel label = new JLabel("Enter name:");
        JTextField textField = new JTextField(10);
        JButton button = new JButton("Submit");

        // Add components to the panel
        panel.add(label);
        panel.add(textField);
        panel.add(button);

        // Add the panel to the frame
        frame.add(panel);
        frame.setVisible(true); // Make the frame visible
    }
}

JavaFX Components (Briefly)

JavaFX is a modern, powerful toolkit for building rich client applications with a focus on graphics and media. Here are some of its core components:

Java Exception Handling Fundamentals

An exception is an event that occurs during the execution of a program and disrupts its normal flow. Java’s robust exception handling mechanism allows you to manage these events gracefully, preventing program crashes.

Benefits of Exception Handling

• Maintains Program Flow: Prevents abrupt termination of the program.
• Separates Error-Handling Code: Keeps error-handling logic distinct from regular program code, improving readability and maintainability.
• Enhances Reliability: Makes programs more robust and resilient to unexpected issues.
• Simplifies Debugging: Provides clear information about errors, aiding in faster debugging.

Types of Exceptions

Exceptions in Java are broadly categorized into three types:

• Checked Exceptions: These are known to the compiler and must be either handled using a try-catch block or declared using the throws keyword in the method signature (e.g., IOException, SQLException).
• Unchecked Exceptions: Also known as runtime exceptions, these are not checked at compile time. They typically indicate programming errors and do not need to be explicitly handled or declared (e.g., ArithmeticException, NullPointerException, ArrayIndexOutOfBoundsException).
• Errors: These represent serious problems that are generally not intended to be caught by applications. They usually indicate unrecoverable conditions (e.g., OutOfMemoryError, StackOverflowError).

Keywords Used in Exception Handling

• try: Encloses the code segment that might throw an exception.
• catch: Follows a try block and handles a specific type of exception if it occurs.
• finally: A block of code that always executes, regardless of whether an exception occurred or was caught. It’s often used for cleanup operations.
• throw: Used to explicitly throw an exception manually from within a method.
• throws: Used in a method signature to declare the types of checked exceptions that a method might throw.

Example: Exception Handling with try-catch-finally

public class ExceptionExample {
    public static void main(String[] args) {
        try {
            int[] arr = new int[5];
            System.out.println(arr[10]); // This line will cause an ArrayIndexOutOfBoundsException
        } catch (ArrayIndexOutOfBoundsException e) {
            // Catch block handles the specific exception
            System.out.println("Exception caught: " + e.getMessage());
        } finally {
            // Finally block always executes
            System.out.println("This block is always executed, for cleanup or final actions.");
        }
        System.out.println("Program continues after exception handling.");
    }
}