Interface — Complete Deep
Revision Guide

interface Animal {
    String type = "Living Being"; // automatically public static final
    void sound(); // automatically public abstract
    void eat();
}

class Dog implements Animal {
    public void sound() {
        System.out.println("Dog says: Woof!");
    }
    public void eat() {
        System.out.println("Dog eats bones.");
    }
}

public class BasicInterface {
    public static void main(String[] args) {
        Dog d = new Dog();
        d.sound();
        d.eat();
        System.out.println("Type: " + Animal.type); // static final - interface name se access
    }
}

interface Shape {
    double area();
}

class Circle implements Shape {
    double radius;
    Circle(double r) { this.radius = r; }
    public double area() {
        return 3.14 * radius * radius;
    }
}

class Rectangle implements Shape {
    double l, b;
    Rectangle(double l, double b) { this.l = l; this.b = b; }
    public double area() {
        return l * b;
    }
}

public class InterfaceReference {
    public static void main(String[] args) {
        Shape s; // interface ka reference

        s = new Circle(5);
        System.out.println("Circle Area: " + s.area());

        s = new Rectangle(4, 6);
        System.out.println("Rectangle Area: " + s.area());
    }
}

interface Flyable {
    void fly();
}

interface Swimmable {
    void swim();
}

class Duck implements Flyable, Swimmable {
    public void fly() {
        System.out.println("Duck is flying!");
    }
    public void swim() {
        System.out.println("Duck is swimming!");
    }
}

public class MultipleInterface {
    public static void main(String[] args) {
        Duck duck = new Duck();
        duck.fly();
        duck.swim();

        // Interface reference
        Flyable f = new Duck();
        f.fly();
    }
}

interface Vehicle {
    void start();
}

interface ElectricVehicle extends Vehicle {
    void charge();
}

class Tesla implements ElectricVehicle {
    public void start() {
        System.out.println("Tesla starting silently...");
    }
    public void charge() {
        System.out.println("Tesla charging at supercharger.");
    }
}

public class InterfaceExtends {
    public static void main(String[] args) {
        Tesla t = new Tesla();
        t.start();
        t.charge();

        Vehicle v = new Tesla(); // parent interface reference
        v.start();
    }
}

interface BankAccount {
    void deposit(double amount);
    void withdraw(double amount);
    double getBalance();
}

class SavingsAccount implements BankAccount {
    private double balance;
    private final double MIN_BALANCE = 500;

    SavingsAccount(double initial) { this.balance = initial; }

    public void deposit(double amount) {
        balance += amount;
        System.out.println("[Savings] Deposited: " + amount
            + " | Balance: " + balance);
    }

    public void withdraw(double amount) {
        if (balance - amount >= MIN_BALANCE) {
            balance -= amount;
            System.out.println("[Savings] Withdrew: " + amount
                + " | Balance: " + balance);
        } else {
            System.out.println("[Savings] Min balance ₹500 required!");
        }
    }

    public double getBalance() { return balance; }
}

class CurrentAccount implements BankAccount {
    private double balance;

    CurrentAccount(double initial) { this.balance = initial; }

    public void deposit(double amount) {
        balance += amount;
        System.out.println("[Current] Deposited: " + amount
            + " | Balance: " + balance);
    }

    public void withdraw(double amount) {
        if (balance >= amount) {
            balance -= amount;
            System.out.println("[Current] Withdrew: " + amount
                + " | Balance: " + balance);
        } else {
            System.out.println("[Current] Insufficient funds!");
        }
    }

    public double getBalance() { return balance; }
}

public class InterfaceBank {
    public static void main(String[] args) {
        BankAccount[] accounts = {
            new SavingsAccount(5000),
            new CurrentAccount(10000)
        };

        accounts[0].deposit(2000);
        accounts[0].withdraw(6600); // min balance check
        accounts[0].withdraw(1000);

        System.out.println();

        accounts[1].deposit(3000);
        accounts[1].withdraw(15000); // insufficient check
        accounts[1].withdraw(5000);
    }
}

interface Greeting {
    void sayHello(String name);

    default void sayBye(String name) { // default method - body hai
        System.out.println("Goodbye, " + name + "!");
    }
}

class EnglishGreeting implements Greeting {
    public void sayHello(String name) {
        System.out.println("Hello, " + name + "!");
    }
    // sayBye override nahi kiya - default use hoga
}

class HindiGreeting implements Greeting {
    public void sayHello(String name) {
        System.out.println("Namaste, " + name + "!");
    }
    // sayBye override kar diya
    public void sayBye(String name) {
        System.out.println("Alvida, " + name + "!");
    }
}

public class DefaultMethod {
    public static void main(String[] args) {
        EnglishGreeting eg = new EnglishGreeting();
        eg.sayHello("Rahul");
        eg.sayBye("Rahul"); // interface ka default use hoga

        HindiGreeting hg = new HindiGreeting();
        hg.sayHello("Rahul");
        hg.sayBye("Rahul"); // overridden version use hoga
    }
}

interface MathOperation {
    int operate(int a, int b);

    static int square(int n) { // static method
        return n * n;
    }

    static void info() {
        System.out.println("This is MathOperation interface.");
    }
}

class Addition implements MathOperation {
    public int operate(int a, int b) {
        return a + b;
    }
}

public class StaticMethod {
    public static void main(String[] args) {
        // Static method - interface name se call, object ki zaroorat nahi
        System.out.println("Square of 5: " + MathOperation.square(5));
        MathOperation.info();

        // Normal method
        MathOperation m = new Addition();
        System.out.println("Addition: " + m.operate(3, 4));
    }
}

interface A {
    default void show() {
        System.out.println("A's default show");
    }
}

interface B {
    default void show() {
        System.out.println("B's default show");
    }
}

// Dono interfaces mein same default method - conflict!
// Solution: Override karna COMPULSORY hai
class C implements A, B {
    public void show() {
        A.super.show(); // explicitly choose kar sakte ho
        System.out.println("C's own show");
    }
}

public class DefaultConflict {
    public static void main(String[] args) {
        C obj = new C();
        obj.show();
    }
}

interface Printable {
    void printContent(String content);

    default void printHeader() {
        System.out.println("=== Document ===");
    }

    default void printFooter() {
        System.out.println("=== End ===");
    }
}

class BasicLogger implements Printable {
    public void printContent(String content) {
        printHeader();          // default use kar raha hai
        System.out.println(content);
        printFooter();          // default use kar raha hai
    }
}

class PrefixLogger implements Printable {
    public void printContent(String content) {
        printHeader();          // default use kar raha hai
        System.out.println("[INFO] " + content);
        printFooter();
    }

    @Override
    public void printHeader() {  // override kar diya!
        System.out.println("--- PrefixLogger ---");
    }
}

class SilentLogger implements Printable {
    public void printContent(String content) {
        // No header/footer - completely silent
        System.out.println(content);
    }
}

public class DefaultVsOverride {
    public static void main(String[] args) {
        System.out.println("--- BasicLogger ---");
        new BasicLogger().printContent("Hello World");

        System.out.println();
        System.out.println("--- PrefixLogger ---");
        new PrefixLogger().printContent("Application started");

        System.out.println();
        System.out.println("--- SilentLogger ---");
        new SilentLogger().printContent("No header no footer");
    }
}

interface StringUtils {
    void process(String s);  // abstract

    static boolean isEmpty(String s) {
        return s == null || s.trim().isEmpty();
    }

    static String capitalize(String s) {
        if (isEmpty(s)) return s;
        return Character.toUpperCase(s.charAt(0))
               + s.substring(1).toLowerCase();
    }

    static int countWords(String s) {
        if (isEmpty(s)) return 0;
        return s.trim().split("\\s+").length;
    }
}

class TextProcessor implements StringUtils {
    public void process(String s) {
        System.out.println("Processing: " + s);
    }
}

public class StaticUtility {
    public static void main(String[] args) {
        // Static methods - interface name se, no object needed!
        System.out.println("isEmpty(''): "   + StringUtils.isEmpty(""));
        System.out.println("isEmpty('hi'): " + StringUtils.isEmpty("hi"));
        System.out.println("capitalize: "     + StringUtils.capitalize("hELLO wORLD"));
        System.out.println("words: "          + StringUtils.countWords("Java is awesome"));

        // Abstract method via object
        new TextProcessor().process("test input");
    }
}

interface Logger {

    private void log(String msg) { // private - sirf is interface ke andar
        System.out.println("[LOG]: " + msg);
    }

    default void logInfo(String msg) {
        log("INFO - " + msg); // private method use kar raha hai
    }

    default void logError(String msg) {
        log("ERROR - " + msg); // same private method reuse
    }
}

class AppLogger implements Logger {
    // private method nahi dikh raha, sirf default methods accessible hain
}

public class PrivateMethod {
    public static void main(String[] args) {
        AppLogger app = new AppLogger();
        app.logInfo("Application started");
        app.logError("Null pointer exception occurred");
    }
}

interface Validator {

    private static boolean isNotEmpty(String s) { // private static
        return s != null && !s.isEmpty();
    }

    static boolean validateName(String name) {
        return isNotEmpty(name) && name.length() >= 3;
    }

    static boolean validateEmail(String email) {
        return isNotEmpty(email) && email.contains("@");
    }
}

public class PrivateStaticMethod {
    public static void main(String[] args) {
        System.out.println("Name valid: "  + Validator.validateName("Rahul"));
        System.out.println("Name valid: "  + Validator.validateName("AB"));
        System.out.println("Email valid: " + Validator.validateEmail("test@gmail.com"));
        System.out.println("Email valid: " + Validator.validateEmail("testgmail.com"));
    }
}

interface ReportGenerator {

    private void addBorder() {
        System.out.println("+---------------------------------+");
    }

    private void addTimestamp() {
        System.out.println("| Generated: 2025-01-01 10:00 AM |");
    }

    default void generateSalesReport(String data) {
        addBorder();                          // private reuse
        System.out.println("| SALES REPORT                    |");
        System.out.println("| Data: " + data);
        addTimestamp();                       // private reuse
        addBorder();
    }

    default void generateInventoryReport(String data) {
        addBorder();                          // same private method!
        System.out.println("| INVENTORY REPORT                |");
        System.out.println("| Data: " + data);
        addTimestamp();
        addBorder();
    }
}

class CompanyReport implements ReportGenerator {}

public class PrivateHelperDemo {
    public static void main(String[] args) {
        CompanyReport r = new CompanyReport();
        r.generateSalesReport("Q1: 5 Lakh");
        System.out.println();
        r.generateInventoryReport("Items: 200");
    }
}

interface AllMethodTypes {

    // 1. Abstract - must override
    void abstractMethod();

    // 2. Default - optional override
    default void defaultMethod() {
        privateHelper();             // private call kar sakte hain
        System.out.println("Default method called");
    }

    // 3. Static - interface name se call
    static void staticMethod() {
        privateStaticHelper();       // private static call kar sakte hain
        System.out.println("Static method called");
    }

    // 4. Private - sirf interface andar (Java 9+)
    private void privateHelper() {
        System.out.println("[Private helper running]");
    }

    // 5. Private Static - sirf interface andar (Java 9+)
    private static void privateStaticHelper() {
        System.out.println("[Private static helper running]");
    }
}

class Demo implements AllMethodTypes {
    public void abstractMethod() {
        System.out.println("Abstract method implemented!");
    }
}

public class AllMethodTypes {
    public static void main(String[] args) {
        Demo d = new Demo();

        System.out.println("--- 1. Abstract ---");
        d.abstractMethod();          // via object

        System.out.println("--- 2. Default ---");
        d.defaultMethod();            // via object

        System.out.println("--- 3. Static ---");
        AllMethodTypes.staticMethod(); // interface name se

        // d.privateHelper()  → ERROR - not accessible
        // AllMethodTypes.privateStaticHelper() → ERROR - not accessible
    }
}

class Outer {
    // Nested interface - by default public static hota hai
    interface Printable {
        void print();
    }
}

class Document implements Outer.Printable {
    public void print() {
        System.out.println("Document is being printed.");
    }
}

public class NestedInterface {
    public static void main(String[] args) {
        Outer.Printable p = new Document(); // reference type = Outer.Printable
        p.print();
    }
}

interface Database {
    void connect();

    interface Query { // nested interface
        void execute(String sql);
    }
}

class MySQL implements Database {
    public void connect() {
        System.out.println("MySQL connected.");
    }
}

class MySQLQuery implements Database.Query {
    public void execute(String sql) {
        System.out.println("Executing SQL: " + sql);
    }
}

public class InterfaceInsideInterface {
    public static void main(String[] args) {
        Database db = new MySQL();
        db.connect();

        Database.Query q = new MySQLQuery();
        q.execute("SELECT * FROM users");
    }
}

interface Payment {
    String CURRENCY = "INR"; // public static final

    void pay(double amount); // public abstract

    default void receipt(double amount) { // Java 8 default
        System.out.println("Receipt generated for: " + formatAmount(amount));
    }

    static void info() { // Java 8 static
        System.out.println("Payment Interface - Currency: " + CURRENCY);
    }

    private String formatAmount(double amount) { // Java 9 private
        return CURRENCY + " " + amount;
    }

    interface Refund { // Nested interface
        void refund(double amount);
    }
}

class UPIPayment implements Payment, Payment.Refund {
    public void pay(double amount) {
        System.out.println("Paid " + amount + " via UPI");
    }
    public void refund(double amount) {
        System.out.println("Refunded " + amount + " via UPI");
    }
}

public class FinalRevision {
    public static void main(String[] args) {
        Payment.info(); // static method

        UPIPayment upi = new UPIPayment();
        upi.pay(500);
        upi.receipt(500);  // default method
        upi.refund(100);

        // Interface references
        Payment p = new UPIPayment();
        p.pay(200);

        Payment.Refund r = new UPIPayment();
        r.refund(50);
    }
}

interface UIComponent {
    void render();
    void setVisible(boolean visible);

    // Nested interface - event handler
    interface ClickListener {
        void onClick(String componentName);
    }
}

class Button implements UIComponent {
    private String label;
    private boolean visible = true;
    private UIComponent.ClickListener listener;

    Button(String label) { this.label = label; }

    public void render() {
        if (visible)
            System.out.println("[Button rendered: " + label + "]");
    }

    public void setVisible(boolean v) { this.visible = v; }

    public void setOnClickListener(UIComponent.ClickListener l) {
        this.listener = l;
    }

    public void click() {
        if (listener != null) listener.onClick(label);
    }
}

public class NestedRealWorld {
    public static void main(String[] args) {
        Button btn = new Button("Submit");
        btn.render();

        // Anonymous class implementing nested interface
        btn.setOnClickListener(new UIComponent.ClickListener() {
            public void onClick(String name) {
                System.out.println("Button '" + name + "' clicked! Form submitted.");
            }
        });

        btn.click();  // triggers listener
        btn.setVisible(false);
        btn.render(); // nothing shown - not visible
    }
}