Solution:

Interfaces in Java:

An interface in Java is a contract that defines what a class can do, without specifying how it does it. It's a reference type that contains only abstract methods and constants.

Key Features of Interfaces:

• 100% Abstract: All methods are implicitly public and abstract (before Java 8)
• Constants: All variables are implicitly public, static, and final
• No Constructors: Interfaces cannot be instantiated directly
• Multiple Inheritance: A class can implement multiple interfaces
• Implementation Mandatory: Implementing class must provide implementation for all abstract methods

Multiple Inheritance Through Interfaces:

Java doesn't support multiple inheritance of classes to avoid ambiguity (Diamond Problem), but it supports multiple inheritance through interfaces because interfaces only define contracts, not implementation.

Practical Example - Smart Device System:

// Interface 1 - WiFi capability
interface WiFiEnabled {
    String WIFI_PROTOCOL = "802.11"; // Constant (implicitly public static final)
    
    void connectToWiFi(String networkName);
    void disconnectFromWiFi();
    boolean isWiFiConnected();
    String getWiFiStatus();
}

// Interface 2 - Bluetooth capability
interface BluetoothEnabled {
    double BLUETOOTH_VERSION = 5.0; // Constant
    
    void enableBluetooth();
    void disableBluetooth();
    void pairDevice(String deviceName);
    boolean isBluetoothOn();
}

// Interface 3 - Camera capability
interface CameraEnabled {
    int MAX_RESOLUTION = 4096; // Constant
    
    void takePhoto();
    void recordVideo();
    void setResolution(int width, int height);
    String[] getSupportedFormats();
}

// Interface 4 - GPS capability
interface GPSEnabled {
    void enableGPS();
    void disableGPS();
    String getCurrentLocation();
    void navigateTo(String destination);
}

// Class implementing multiple interfaces
class Smartphone implements WiFiEnabled, BluetoothEnabled, CameraEnabled, GPSEnabled {
    private String model;
    private boolean wifiConnected;
    private boolean bluetoothOn;
    private boolean gpsEnabled;
    private int cameraWidth = 1920;
    private int cameraHeight = 1080;
    
    public Smartphone(String model) {
        this.model = model;
        this.wifiConnected = false;
        this.bluetoothOn = false;
        this.gpsEnabled = false;
    }
    
    // Implement WiFiEnabled methods
    @Override
    public void connectToWiFi(String networkName) {
        wifiConnected = true;
        System.out.println(model + " connected to WiFi network: " + networkName);
        System.out.println("Using protocol: " + WIFI_PROTOCOL);
    }
    
    @Override
    public void disconnectFromWiFi() {
        wifiConnected = false;
        System.out.println(model + " disconnected from WiFi");
    }
    
    @Override
    public boolean isWiFiConnected() {
        return wifiConnected;
    }
    
    @Override
    public String getWiFiStatus() {
        return wifiConnected ? "WiFi Connected" : "WiFi Disconnected";
    }
    
    // Implement BluetoothEnabled methods
    @Override
    public void enableBluetooth() {
        bluetoothOn = true;
        System.out.println(model + " Bluetooth enabled (Version " + BLUETOOTH_VERSION + ")");
    }
    
    @Override
    public void disableBluetooth() {
        bluetoothOn = false;
        System.out.println(model + " Bluetooth disabled");
    }
    
    @Override
    public void pairDevice(String deviceName) {
        if (bluetoothOn) {
            System.out.println(model + " paired with " + deviceName);
        } else {
            System.out.println("Enable Bluetooth first!");
        }
    }
    
    @Override
    public boolean isBluetoothOn() {
        return bluetoothOn;
    }
    
    // Implement CameraEnabled methods
    @Override
    public void takePhoto() {
        System.out.println(model + " taking photo at " + cameraWidth + "x" + cameraHeight);
    }
    
    @Override
    public void recordVideo() {
        System.out.println(model + " recording video at " + cameraWidth + "x" + cameraHeight);
    }
    
    @Override
    public void setResolution(int width, int height) {
        if (width <= MAX_RESOLUTION && height <= MAX_RESOLUTION) {
            this.cameraWidth = width;
            this.cameraHeight = height;
            System.out.println("Camera resolution set to " + width + "x" + height);
        } else {
            System.out.println("Resolution exceeds maximum: " + MAX_RESOLUTION);
        }
    }
    
    @Override
    public String[] getSupportedFormats() {
        return new String[]{"JPEG", "PNG", "MP4", "AVI"};
    }
    
    // Implement GPSEnabled methods
    @Override
    public void enableGPS() {
        gpsEnabled = true;
        System.out.println(model + " GPS enabled");
    }
    
    @Override
    public void disableGPS() {
        gpsEnabled = false;
        System.out.println(model + " GPS disabled");
    }
    
    @Override
    public String getCurrentLocation() {
        if (gpsEnabled) {
            return "Latitude: 40.7128, Longitude: -74.0060"; // NYC coordinates
        } else {
            return "GPS disabled";
        }
    }
    
    @Override
    public void navigateTo(String destination) {
        if (gpsEnabled) {
            System.out.println(model + " navigating to: " + destination);
        } else {
            System.out.println("Enable GPS for navigation!");
        }
    }
    
    // Additional smartphone-specific method
    public void displayDeviceInfo() {
        System.out.println("=== Device Information ===");
        System.out.println("Model: " + model);
        System.out.println("WiFi Status: " + getWiFiStatus());
        System.out.println("Bluetooth: " + (bluetoothOn ? "On" : "Off"));
        System.out.println("GPS: " + (gpsEnabled ? "Enabled" : "Disabled"));
        System.out.println("Camera Resolution: " + cameraWidth + "x" + cameraHeight);
        System.out.println("==========================");
    }
}

// Demo class showing multiple inheritance through interfaces
public class MultipleInheritanceDemo {
    
    // Methods demonstrating polymorphism
    public static void testWiFiCapability(WiFiEnabled device) {
        device.connectToWiFi("MyHomeNetwork");
        System.out.println("WiFi Status: " + device.getWiFiStatus());
    }
    
    public static void testBluetoothCapability(BluetoothEnabled device) {
        device.enableBluetooth();
        device.pairDevice("Wireless Headphones");
    }
    
    public static void testCameraCapability(CameraEnabled device) {
        device.setResolution(1920, 1080);
        device.takePhoto();
        System.out.println("Supported formats: " + 
                          String.join(", ", device.getSupportedFormats()));
    }
    
    public static void testGPSCapability(GPSEnabled device) {
        device.enableGPS();
        System.out.println("Current location: " + device.getCurrentLocation());
        device.navigateTo("Times Square, New York");
    }
    
    public static void main(String[] args) {
        System.out.println("=== Multiple Inheritance Through Interfaces Demo ===\n");
        
        // Create smartphone object
        Smartphone iPhone = new Smartphone("iPhone 14 Pro");
        
        // Display initial device info
        iPhone.displayDeviceInfo();
        
        System.out.println("\n=== Testing Individual Capabilities ===");
        
        // Test each interface capability (polymorphic behavior)
        System.out.println("\n1. Testing WiFi Capability:");
        testWiFiCapability(iPhone); // iPhone treated as WiFiEnabled
        
        System.out.println("\n2. Testing Bluetooth Capability:");
        testBluetoothCapability(iPhone); // iPhone treated as BluetoothEnabled
        
        System.out.println("\n3. Testing Camera Capability:");
        testCameraCapability(iPhone); // iPhone treated as CameraEnabled
        
        System.out.println("\n4. Testing GPS Capability:");
        testGPSCapability(iPhone); // iPhone treated as GPSEnabled
        
        // Demonstrate interface array (polymorphic array)
        System.out.println("\n=== Polymorphic Array Example ===");
        
        WiFiEnabled[] wifiDevices = {iPhone}; // Can add more WiFi devices
        BluetoothEnabled[] bluetoothDevices = {iPhone}; // Same object, different interface
        
        System.out.println("WiFi devices in array: " + wifiDevices.length);
        System.out.println("Bluetooth devices in array: " + bluetoothDevices.length);
        
        // Updated device info
        System.out.println("\n=== Final Device State ===");
        iPhone.displayDeviceInfo();
        
        System.out.println("\n=== Key Benefits Demonstrated ===");
        System.out.println("1. Single class (Smartphone) implements multiple interfaces");
        System.out.println("2. Each interface provides specific contract/capability");
        System.out.println("3. Same object can be treated as different interface types");
        System.out.println("4. No ambiguity - each interface method has single implementation");
        System.out.println("5. Easy to extend with new interfaces without modifying existing code");
    }
}

How Multiple Inheritance is Achieved:

1. Interface Definition: Multiple interfaces define different contracts
2. Implementation: Single class implements multiple interfaces using 'implements' keyword
3. Method Implementation: Class provides implementation for all abstract methods from all interfaces
4. Polymorphism: Object can be treated as any of its implemented interface types
5. No Ambiguity: Since interfaces don't have implementation (originally), there's no confusion about which method to call

Solution:

Comparison: Interface vs Abstract Class

When to Choose Interface:

Use Interface When:

• Multiple inheritance is needed
• Defining a contract (what classes should do)
• Loose coupling is important
• No shared state among implementations
• Plugin architecture or strategy pattern

Interface Example:

// Example: Media Player Interface
interface Playable {
    void play();
    void pause();
    void stop();
}

interface Downloadable {
    void download(String url);
    boolean isDownloaded();
}

// Class can implement multiple interfaces
class MusicPlayer implements Playable, Downloadable {
    private boolean isPlaying = false;
    private boolean downloaded = false;
    
    @Override
    public void play() {
        isPlaying = true;
        System.out.println("Music is playing");
    }
    
    @Override
    public void pause() {
        isPlaying = false;
        System.out.println("Music paused");
    }
    
    @Override
    public void stop() {
        isPlaying = false;
        System.out.println("Music stopped");
    }
    
    @Override
    public void download(String url) {
        downloaded = true;
        System.out.println("Downloading from: " + url);
    }
    
    @Override
    public boolean isDownloaded() {
        return downloaded;
    }
}

When to Choose Abstract Class:

Use Abstract Class When:

• Shared implementation among related classes
• Common state needs to be maintained
• Constructor is needed
• Code reusability is priority
• Template method pattern

Abstract Class Example:

// Example: Vehicle Abstract Class
abstract class Vehicle {
    // Instance variables (state)
    protected String brand;
    protected String model;
    protected int year;
    protected double fuelLevel;
    
    // Constructor
    public Vehicle(String brand, String model, int year) {
        this.brand = brand;
        this.model = model;
        this.year = year;
        this.fuelLevel = 100.0; // Full tank
    }
    
    // Concrete methods (shared implementation)
    public void startEngine() {
        if (fuelLevel > 0) {
            System.out.println(brand + " " + model + " engine started");
        } else {
            System.out.println("Cannot start - no fuel!");
        }
    }
    
    public void stopEngine() {
        System.out.println(brand + " " + model + " engine stopped");
    }
    
    public void refuel(double amount) {
        fuelLevel = Math.min(100.0, fuelLevel + amount);
        System.out.println("Refueled. Current fuel level: " + fuelLevel + "%");
    }
    
    // Template method - defines algorithm structure
    public final void performMaintenance() {
        System.out.println("Starting maintenance for " + brand + " " + model);
        checkEngine();      // Abstract - subclass implements
        changeFluids();     // Concrete - common for all
        checkSpecificParts(); // Abstract - subclass implements
        System.out.println("Maintenance completed");
    }
    
    // Common concrete method
    private void changeFluids() {
        System.out.println("Changing engine oil and other fluids");
    }
    
    // Abstract methods - must be implemented by subclasses
    public abstract void accelerate();
    public abstract void brake();
    public abstract double getFuelEfficiency();
    protected abstract void checkEngine();
    protected abstract void checkSpecificParts();
    
    // Getters
    public String getBrand() { return brand; }
    public String getModel() { return model; }
    public double getFuelLevel() { return fuelLevel; }
}

// Concrete implementation
class Car extends Vehicle {
    private int numberOfDoors;
    
    public Car(String brand, String model, int year, int doors) {
        super(brand, model, year); // Call parent constructor
        this.numberOfDoors = doors;
    }
    
    @Override
    public void accelerate() {
        if (fuelLevel > 0) {
            fuelLevel -= 0.5;
            System.out.println("Car accelerating smoothly");
        }
    }
    
    @Override
    public void brake() {
        System.out.println("Car braking with ABS");
    }
    
    @Override
    public double getFuelEfficiency() {
        return 15.0; // km per liter
    }
    
    @Override
    protected void checkEngine() {
        System.out.println("Checking car engine and exhaust system");
    }
    
    @Override
    protected void checkSpecificParts() {
        System.out.println("Checking doors (" + numberOfDoors + "), windows, and air conditioning");
    }
    
    // Car-specific method
    public void openTrunk() {
        System.out.println("Car trunk opened");
    }
}

class Motorcycle extends Vehicle {
    private String engineType;
    
    public Motorcycle(String brand, String model, int year, String engineType) {
        super(brand, model, year);
        this.engineType = engineType;
    }
    
    @Override
    public void accelerate() {
        if (fuelLevel > 0) {
            fuelLevel -= 0.8;
            System.out.println("Motorcycle accelerating quickly");
        }
    }
    
    @Override
    public void brake() {
        System.out.println("Motorcycle braking carefully");
    }
    
    @Override
    public double getFuelEfficiency() {
        return 30.0; // km per liter
    }
    
    @Override
    protected void checkEngine() {
        System.out.println("Checking " + engineType + " motorcycle engine");
    }
    
    @Override
    protected void checkSpecificParts() {
        System.out.println("Checking chain, sprockets, and helmet storage");
    }
}

Demonstration Program:

public class InterfaceVsAbstractDemo {
    public static void main(String[] args) {
        System.out.println("=== Interface Example ===");
        
        // Interface allows multiple inheritance
        MusicPlayer player = new MusicPlayer();
        
        // Can be treated as either interface
        Playable playableDevice = player;
        Downloadable downloadableDevice = player;
        
        playableDevice.play();
        downloadableDevice.download("http://music.com/song.mp3");
        
        System.out.println("\n=== Abstract Class Example ===");
        
        // Abstract class provides shared implementation
        Car car = new Car("Toyota", "Camry", 2023, 4);
        Motorcycle bike = new Motorcycle("Honda", "CBR", 2023, "4-Stroke");
        
        // Common methods inherited
        car.startEngine();
        car.refuel(20);
        car.accelerate();
        
        bike.startEngine();
        bike.accelerate();
        
        // Template method pattern
        System.out.println("\n=== Template Method Pattern ===");
        car.performMaintenance();   // Follows same algorithm
        bike.performMaintenance();  // But different implementations
        
        System.out.println("\n=== Decision Guidelines ===");
        System.out.println("Choose Interface when:");
        System.out.println("- Multiple inheritance needed");
        System.out.println("- Defining contracts/capabilities");
        System.out.println("- Loose coupling important");
        
        System.out.println("\nChoose Abstract Class when:");
        System.out.println("- Shared state and behavior needed");
        System.out.println("- Constructor required");
        System.out.println("- Template method pattern");
    }
}

Decision Matrix:

Choose Interface if:

• You need multiple inheritance
• You're defining what classes CAN DO (capabilities)
• Implementations are likely to be very different
• You want loose coupling

Choose Abstract Class if:

• You have common code to share
• You need to maintain state
• You need constructors
• You're defining what classes ARE (identity)

Solution:

Default Methods in Java 8 Interfaces:

Default methods are methods in interfaces that have a default implementation. They were introduced in Java 8 to allow interfaces to evolve without breaking existing implementations.

Interface Evolution Problem:

Before Java 8, adding a new method to an interface would break all existing classes that implement that interface, because they would need to implement the new method.

How Default Methods Solve the Problem:

• Allow adding new methods to interfaces without breaking compatibility
• Provide default implementation that existing classes can inherit
• Implementing classes can choose to override the default implementation
• Enable interface evolution while maintaining backward compatibility

Example: Library Management Interface Evolution

// Original interface (before enhancement)
interface Library {
    void addBook(String title, String author);
    void removeBook(String isbn);
    boolean findBook(String isbn);
}

// Original implementation
class CityLibrary implements Library {
    private Map books = new HashMap<>();
    
    @Override
    public void addBook(String title, String author) {
        String isbn = generateISBN();
        books.put(isbn, title + " by " + author);
        System.out.println("Added: " + title + " by " + author);
    }
    
    @Override
    public void removeBook(String isbn) {
        books.remove(isbn);
        System.out.println("Removed book with ISBN: " + isbn);
    }
    
    @Override
    public boolean findBook(String isbn) {
        return books.containsKey(isbn);
    }
    
    private String generateISBN() {
        return "ISBN-" + System.currentTimeMillis() % 10000;
    }
}

// Enhanced interface with default methods (Java 8+)
interface EnhancedLibrary {
    // Original abstract methods
    void addBook(String title, String author);
    void removeBook(String isbn);
    boolean findBook(String isbn);
    
    // New default methods - don't break existing implementations
    default void displayLibraryInfo() {
        System.out.println("=== Library Information ===");
        System.out.println("Library System Version: 2.0");
        System.out.println("Supports: Books, eBooks, Audiobooks");
        System.out.println("============================");
    }
    
    default void sendOverdueNotice(String memberEmail) {
        System.out.println("Sending overdue notice to: " + memberEmail);
        System.out.println("Please return your books on time.");
        logActivity("Overdue notice sent to " + memberEmail);
    }
    
    default void generateReport() {
        System.out.println("Generating standard library report...");
        System.out.println("Total books: " + getTotalBooks());
        System.out.println("System status: Active");
    }
    
    // Default method calling abstract method
    default int getTotalBooks() {
        // This would need to be overridden in implementation
        return 0; // Default implementation
    }
    
    // Default method with parameters and logic
    default boolean isValidISBN(String isbn) {
        return isbn != null && isbn.startsWith("ISBN-") && isbn.length() >= 9;
    }
    
    // Private method (Java 9+) to support default methods
    private void logActivity(String activity) {
        System.out.println("[LOG] " + java.time.LocalDateTime.now() + ": " + activity);
    }
    
    // Static method in interface
    static String getLibraryStandard() {
        return "ISO 2108 - International Standard Book Number";
    }
}

// Updated implementation - no need to change existing methods
class ModernLibrary implements EnhancedLibrary {
    private Map books = new HashMap<>();
    private int totalBooks = 0;
    
    @Override
    public void addBook(String title, String author) {
        String isbn = generateISBN();
        if (isValidISBN(isbn)) { // Using default method
            books.put(isbn, title + " by " + author);
            totalBooks++;
            System.out.println("Added: " + title + " by " + author + " (ISBN: " + isbn + ")");
        } else {
            System.out.println("Invalid ISBN generated!");
        }
    }
    
    @Override
    public void removeBook(String isbn) {
        if (books.remove(isbn) != null) {
            totalBooks--;
            System.out.println("Removed book with ISBN: " + isbn);
        } else {
            System.out.println("Book not found: " + isbn);
        }
    }
    
    @Override
    public boolean findBook(String isbn) {
        return books.containsKey(isbn);
    }
    
    // Override default method to provide specific implementation
    @Override
    public int getTotalBooks() {
        return totalBooks;
    }
    
    // Can choose to override other default methods
    @Override
    public void generateReport() {
        System.out.println("=== Modern Library Report ===");
        System.out.println("Library Name: Modern City Library");
        System.out.println("Total Books: " + getTotalBooks());
        System.out.println("Standard: " + EnhancedLibrary.getLibraryStandard());
        System.out.println("Digital Catalog: Enabled");
        System.out.println("Online Access: 24/7");
        System.out.println("==============================");
    }
    
    // Custom method to override default behavior
    @Override
    public void sendOverdueNotice(String memberEmail) {
        System.out.println("Sending personalized overdue notice to: " + memberEmail);
        System.out.println("Dear Member,");
        System.out.println("You have overdue books. Please return them to avoid fines.");
        System.out.println("You can also renew online at our website.");
        System.out.println("Thank you - Modern City Library");
        // Note: Can't call private logActivity directly, but default method handles it
    }
    
    private String generateISBN() {
        return "ISBN-" + (1000000000L + System.currentTimeMillis() % 9000000000L);
    }
}

// Legacy implementation - still works without modification
class LegacyLibrary implements EnhancedLibrary {
    private List bookList = new ArrayList<>();
    
    @Override
    public void addBook(String title, String author) {
        bookList.add(title + " by " + author);
        System.out.println("Legacy: Added " + title);
    }
    
    @Override
    public void removeBook(String isbn) {
        // Legacy implementation - remove by title search
        bookList.removeIf(book -> book.contains(isbn));
        System.out.println("Legacy: Attempted to remove book");
    }
    
    @Override
    public boolean findBook(String isbn) {
        return bookList.stream().anyMatch(book -> book.contains(isbn));
    }
    
    // Uses default implementation of other methods
    // No need to implement displayLibraryInfo, sendOverdueNotice, etc.
}

Demonstration Program:

public class DefaultMethodDemo {
    public static void main(String[] args) {
        System.out.println("=== Default Methods Evolution Demo ===\n");
        
        // Modern implementation
        ModernLibrary modernLib = new ModernLibrary();
        
        // Legacy implementation - still works!
        LegacyLibrary legacyLib = new LegacyLibrary();
        
        // Test both implementations
        System.out.println("=== Modern Library ===");
        modernLib.addBook("Java Programming", "John Doe");
        modernLib.addBook("Data Structures", "Jane Smith");
        
        // Use default methods
        modernLib.displayLibraryInfo();
        modernLib.generateReport(); // Overridden implementation
        modernLib.sendOverdueNotice("user@example.com"); // Overridden
        
        System.out.println("\n=== Legacy Library ===");
        legacyLib.addBook("Old Programming Book", "Legacy Author");
        
        // Legacy library gets default implementations automatically!
        legacyLib.displayLibraryInfo(); // Uses default implementation
        legacyLib.generateReport();     // Uses default implementation
        legacyLib.sendOverdueNotice("legacy@example.com"); // Uses default
        
        // Static method usage
        System.out.println("\n=== Interface Static Method ===");
        System.out.println("Library Standard: " + EnhancedLibrary.getLibraryStandard());
        
        // Demonstrate polymorphism with default methods
        System.out.println("\n=== Polymorphic Default Method Usage ===");
        
        EnhancedLibrary[] libraries = {modernLib, legacyLib};
        
        for (EnhancedLibrary lib : libraries) {
            System.out.println("\nTesting library:");
            lib.displayLibraryInfo(); // Same interface, different or same implementation
        }
        
        System.out.println("\n=== Benefits Demonstrated ===");
        System.out.println("1. Backward Compatibility: Legacy code still works");
        System.out.println("2. Interface Evolution: New methods added without breaking changes");
        System.out.println("3. Optional Override: Modern implementations can customize behavior");
        System.out.println("4. Default Behavior: Sensible defaults provided");
        System.out.println("5. Code Reuse: Common logic in default methods");
    }
}

Key Benefits of Default Methods:

1. Backward Compatibility: Existing implementations don't break when interface evolves
2. Interface Evolution: Can add new functionality to existing interfaces
3. Optional Implementation: Implementing classes can choose to override or use default
4. Code Reuse: Common logic can be shared across implementations
5. Library Enhancement: Enables frameworks like Java Collections to add new methods

Rules for Default Methods:

• Must be declared with default keyword
• Must have implementation body
• Cannot be abstract, final, static, or synchronized
• Can be overridden in implementing classes
• Can call other default methods and abstract methods
• If class implements multiple interfaces with same default method, must override to resolve conflict

Real-world Impact:

Default methods enabled Java 8 to add lambda expression support to existing Collection interfaces (like forEach, stream) without breaking millions of existing implementations.