Java Interfaces, Packages, and Exception Handling

Posted on Jan 25, 2026 in Electronic Engineering

Multiple Inheritance via Interfaces

Java does not support multiple inheritance of classes (a class can only extend one other class). However, it achieves multiple inheritance of type and behavior by allowing a class to implement multiple interfaces.

This approach avoids the complex “Diamond Problem” associated with multiple inheritance of concrete methods and fields.

Implementing Multiple Interfaces (Contracts)

By implementing multiple interfaces, a class agrees to fulfill the contracts (provide implementations for all abstract methods) from all of them, effectively inheriting multiple sets of capabilities.

Define Multiple Interfaces (Contracts):

public interface Swimmer {
    void swim();
}

public interface Flyer {
    void fly();
}

Implement Multiple Interfaces in a Class:

The class uses a comma-separated list of interfaces with the implements keyword.

public class Duck implements Swimmer, Flyer {
    @Override
    public void swim() {
        System.out.println("The duck paddles.");
    }

    @Override
    public void fly() {
        System.out.println("The duck takes flight.");
    }

    // This is a method specific to the Duck class
    public void quack() {
        System.out.println("Quack!");
    }
}

Polymorphism: The Duck object can now be treated as a Duck, a Swimmer, or a Flyer type.

Duck myDuck = new Duck();
Swimmer s = myDuck; // Valid
Flyer f = myDuck;  // Valid

Handling Conflicts (Default Methods in Java 8+)

If multiple interfaces define default methods (methods with a body) with the exact same signature, the implementing class must explicitly override the method to resolve the conflict and prevent ambiguity.

Packages: The Basics

A package in Java is a mechanism used to group related classes, interfaces, enumerations, and annotations. It serves three main purposes:

• Namespace Management: It prevents naming conflicts by providing a unique scope for types. Two classes can have the same name (e.g., Date) as long as they are in different packages (e.g., java.util.Date and java.sql.Date).
• Access Control: It controls the visibility of classes and members using access modifiers like public, protected, and the default (package-private) access.
• Code Organization and Reusability: It makes large projects easier to manage, locate, and reuse components.

1. Types of Packages

2. Creating and Using Packages

Creating: The package statement must be the first non-comment line in a Java source file. By convention, package names are written in lowercase, often using reverse domain name notation (e.g., com.example.myapp).

// MyFile.java
package com.example.models;

public class User { 
    // ... class code
}

Using (Importing): To use a class from another package, you use the import statement. Classes in the java.lang package are imported automatically.

import java.util.ArrayList; // Import a single class
import com.example.models.*;  // Import all classes from a package

Creating and Accessing Packages

A package is Java’s way of grouping related classes, interfaces, and sub-packages. It helps in organizing code, managing naming conflicts, and controlling access.

1. Creating User-Defined Packages

Creating a package involves two main steps: defining the package structure and placing the class file in the corresponding directory structure.

A. Defining the Package

The package statement must be the first non-comment line in a Java source file.

• Convention: Package names are typically all lowercase and often use reverse domain name notation (e.g., com.mycompany.app). This ensures global uniqueness.
• Example Code:

// File: MyUtil.java
package com.example.utility;

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

B. Directory Structure

The package structure must be mirrored by the directory (folder) structure on the file system.

• To save MyUtil.java, you must create a directory path like: .../com/example/utility/MyUtil.java
• Compilation: Compile the file from the root directory (the folder containing the com folder):
  javac com/example/utility/MyUtil.java

2. Accessing Packages (Importing)

To use classes from another package, you use the import statement. The import statement tells the compiler where to find the referenced class.

Example of Accessing MyUtil:

package com.example.mainapp; // A new package for the main application

import com.example.utility.MyUtil; // Accessing the user-defined package

public class MainApp {
    public static void main(String[] args) {
        int result = MyUtil.add(10, 5); // Using the imported class
        System.out.println("Result: " + result);
    }
}

3. System Packages

System packages (or built-in packages) are the ones that come standard with the Java Development Kit (JDK) and form the core of the Java API. They contain the vast majority of useful classes you’ll use.

The most important system package is:

Because java.lang is imported by default, you can use classes like String and System.out.println() without an explicit import statement.

Exception Handling Explained

Exception handling is a programming mechanism used to deal with runtime errors (called exceptions) that disrupt the normal flow of a program. Instead of the program crashing, exception handling allows you to gracefully manage these errors, often by performing recovery actions or providing informative messages.

Key Keywords in Exception Handling

The core of exception handling in many languages (like Java, C++, Python) revolves around five keywords: try, catch, finally, throw, and throws.

1. try Block

The try block encloses the section of code where an exception might occur. If an exception does occur within the try block, the program immediately stops executing the try block and jumps to the corresponding catch block.

2. catch Block

The catch block immediately follows the try block and defines the code that should be executed when a specific type of exception is thrown. It takes an exception type and a variable (e.g., catch (IOException e)). This block is where you typically handle the error, log it, or inform the user.

3. finally Block

The finally block, if present, always executes regardless of whether an exception was thrown or caught. This is typically used for cleanup operations, such as closing files, database connections, or releasing system resources.

4. throw Keyword

The throw keyword is used to explicitly raise (or trigger) an exception from within a method. You use it when you detect a situation that should be treated as an error (e.g., an invalid input value) and you want to create and throw a new instance of an exception object. This is often used to implement custom exceptions.

5. throws Keyword

The throws keyword is used in a method’s signature to declare that the method might throw one or more specific types of exceptions. This is a notification to the caller of the method that they need to handle (or declare they will throw) that exception. This is primarily used for checked exceptions (exceptions that the compiler forces you to handle).

Simple Example Analogy

Imagine a kitchen where you’re trying to bake a cake: