Object-Oriented Programming in Java

Understanding Packages

A package is a collection of related classes and interfaces grouped under a unique namespace. They help avoid name conflicts and improve program structure.

• Built-in packages: java.lang, java.util, java.io, java.awt
• User-defined packages: created using the package keyword

// file: src/com/demo/Calculator.java
package com.demo;

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

// Using the package
import com.demo.Calculator;

public class Main {
  public static void main(String[] args) {
    Calculator c = new Calculator();
    System.out.println(c.add(10, 20));
  }
}

Diagram: package-folder-structure.png

Importing Packages

The import statement allows classes in one package to be visible in another file.

• Specific import: import java.util.ArrayList;
• Wildcard import: import java.util.*;

import java.util.ArrayList;

ArrayList<Integer> list = new ArrayList<>();
list.add(5);

Interfaces

An interface specifies a set of abstract methods that implementing classes must define. Interfaces support abstraction and multiple inheritance in Java.

• Methods are abstract by default (before Java 8)
• Variables are public, static, and final
• A class uses implements to implement an interface

interface Drawable {
  void draw();
}

class Circle implements Drawable {
  public void draw() {
    System.out.println("drawing circle");
  }
}

Drawable d = new Circle();
d.draw();

Diagram: interface-implementation.png

Default and Static Methods in Interfaces

From Java 8 onwards, interfaces can include default and static methods, allowing common functionality without breaking existing implementations.

interface Vehicle {
  void start();
  default void show() {
    System.out.println("Vehicle started");
  }
  static int version() { return 1; }
}

class Car implements Vehicle {
  public void start() {
    System.out.println("Car engine starts");
  }
}

Car c = new Car();
c.start();
c.show();
int v = Vehicle.version();

Putting It All Together

Packages organize code. Interfaces define contracts. When combined, they allow large Java applications to be structured cleanly and extended easily. This module prepares the foundation for frameworks, APIs and modular application design.

Diagrams to add: interface-hierarchy.png, package-namespace.png