Practice Questions — Abstraction - Abstract Classes and Interfaces

abstract class Shape {
    abstract double area();
}
class Circle extends Shape {
    double r;
    Circle(double r) { this.r = r; }
    double area() { return 3.14 * r * r; }
}
public class Main {
    public static void main(String[] args) {
        Shape s = new Circle(5);
        System.out.println(s.area());
    }
}

abstract class Animal {
    abstract void sound();
}
public class Main {
    public static void main(String[] args) {
        Animal a = new Animal();
    }
}

interface Greetable {
    void greet();
}
class HelloGreeter implements Greetable {
    public void greet() {
        System.out.println("Hello!");
    }
}
public class Main {
    public static void main(String[] args) {
        Greetable g = new HelloGreeter();
        g.greet();
    }
}

interface Constants {
    int VALUE = 100;
}
public class Main {
    public static void main(String[] args) {
        System.out.println(Constants.VALUE);
        // Constants.VALUE = 200;  // Would this work?
    }
}

abstract class Base {
    void concrete() {
        System.out.println("Concrete method");
    }
    abstract void abstractMethod();
}
class Derived extends Base {
    void abstractMethod() {
        System.out.println("Implemented!");
    }
}
public class Main {
    public static void main(String[] args) {
        Base b = new Derived();
        b.concrete();
        b.abstractMethod();
    }
}

abstract class Animal {
    String name;
    Animal(String name) {
        this.name = name;
        System.out.println("Animal: " + name);
    }
    abstract void sound();
}
class Cat extends Animal {
    Cat(String name) {
        super(name);
        System.out.println("Cat: " + name);
    }
    void sound() { System.out.println(name + " says Meow"); }
}
public class Main {
    public static void main(String[] args) {
        Animal a = new Cat("Whiskers");
        a.sound();
    }
}

interface A {
    default void show() { System.out.println("A"); }
}
interface B {
    default void show() { System.out.println("B"); }
}
class C implements A, B {
    public void show() {
        A.super.show();
        B.super.show();
    }
}
public class Main {
    public static void main(String[] args) {
        C c = new C();
        c.show();
    }
}

interface Calculable {
    int calculate(int a, int b);
    
    default void printResult(int a, int b) {
        System.out.println("Result: " + calculate(a, b));
    }
}
class Adder implements Calculable {
    public int calculate(int a, int b) { return a + b; }
}
class Multiplier implements Calculable {
    public int calculate(int a, int b) { return a * b; }
}
public class Main {
    public static void main(String[] args) {
        Calculable c1 = new Adder();
        Calculable c2 = new Multiplier();
        c1.printResult(3, 4);
        c2.printResult(3, 4);
    }
}

interface Util {
    static int doubleIt(int n) { return n * 2; }
}
class MyClass implements Util { }
public class Main {
    public static void main(String[] args) {
        System.out.println(Util.doubleIt(5));
        // MyClass m = new MyClass();
        // m.doubleIt(5);  // Would this work?
    }
}

abstract class AbstractLogger {
    abstract void log(String msg);
    
    void logWithTimestamp(String msg) {
        System.out.print("[LOG] ");
        log(msg);
    }
}
class ConsoleLogger extends AbstractLogger {
    void log(String msg) {
        System.out.println(msg);
    }
}
public class Main {
    public static void main(String[] args) {
        AbstractLogger logger = new ConsoleLogger();
        logger.log("Direct message");
        logger.logWithTimestamp("Timestamped message");
    }
}

abstract class Base {
    Base() {
        System.out.println("Base init");
        init();
    }
    abstract void init();
}
class Child extends Base {
    int value = 5;
    
    Child() {
        System.out.println("Child init, value=" + value);
    }
    
    void init() {
        System.out.println("init called, value=" + value);
    }
}
public class Main {
    public static void main(String[] args) {
        Child c = new Child();
    }
}

interface X {
    default void show() { System.out.println("X"); }
}
interface Y extends X {
    default void show() { System.out.println("Y"); }
}
class Z implements X, Y { }
public class Main {
    public static void main(String[] args) {
        Z z = new Z();
        z.show();
    }
}

@FunctionalInterface
interface Transformer {
    String transform(String s);
}
public class Main {
    static String applyTwice(Transformer t, String s) {
        return t.transform(t.transform(s));
    }
    public static void main(String[] args) {
        Transformer upper = s -> s.toUpperCase();
        Transformer addBang = s -> s + "!";

        System.out.println(applyTwice(upper, "hello"));
        System.out.println(applyTwice(addBang, "hi"));
    }
}

interface Drawable { void draw(); }
interface Resizable { void resize(int factor); }

abstract class UIComponent implements Drawable {
    String id;
    UIComponent(String id) { this.id = id; }
}

class Button extends UIComponent implements Resizable {
    int size = 10;
    Button(String id) { super(id); }
    
    public void draw() { System.out.println("Button[" + id + "] size=" + size); }
    public void resize(int f) { size *= f; }
}

public class Main {
    public static void main(String[] args) {
        Button b = new Button("btn1");
        b.draw();
        b.resize(3);
        b.draw();
        
        Drawable d = b;
        d.draw();
        
        Resizable r = b;
        r.resize(2);
        d.draw();
    }
}

abstract class A {
    abstract void foo();
}
abstract class B extends A {
    abstract void bar();
}
class C extends B {
    void bar() { System.out.println("bar"); }
}

interface Processor {
    default String process(String input) {
        return input.trim();
    }
}
class UpperProcessor implements Processor {
    @Override
    public String process(String input) {
        String trimmed = Processor.super.process(input);
        return trimmed.toUpperCase();
    }
}
public class Main {
    public static void main(String[] args) {
        Processor p = new UpperProcessor();
        System.out.println(p.process("  hello world  "));
    }
}

interface Speakable {
    void speak();
}
class Person implements Speakable {
    String name;
    Person(String name) { this.name = name; }
    public void speak() { System.out.println(name + " is speaking"); }
}
public class Main {
    public static void main(String[] args) {
        Speakable s = new Person("Arjun");
        s.speak();
    }
}

abstract class Template {
    final void execute() {
        step1();
        step2();
        step3();
    }
    void step1() { System.out.println("Default step 1"); }
    abstract void step2();
    void step3() { System.out.println("Default step 3"); }
}
class MyProcess extends Template {
    void step2() { System.out.println("Custom step 2"); }
    void step3() { System.out.println("Custom step 3"); }
}
public class Main {
    public static void main(String[] args) {
        Template t = new MyProcess();
        t.execute();
    }
}

interface Shape {
    double area();
    default String describe() {
        return "Shape with area " + area();
    }
}
class Square implements Shape {
    double side;
    Square(double s) { this.side = s; }
    public double area() { return side * side; }
}
public class Main {
    public static void main(String[] args) {
        Shape s = new Square(4);
        System.out.println(s.describe());
    }
}

interface A {
    default void show() {
        System.out.println("A");
    }
}
class B implements A {
    public void show() {
        System.out.println("B");
    }
}
class C extends B {
}
public class Main {
    public static void main(String[] args) {
        A obj = new C();
        obj.show();
    }
}

abstract class Account {
    double balance;
    Account(double balance) { this.balance = balance; }
    
    abstract double interestRate();
    
    double futureValue(int years) {
        return balance * Math.pow(1 + interestRate(), years);
    }
}
class SavingsAccount extends Account {
    SavingsAccount(double bal) { super(bal); }
    double interestRate() { return 0.04; }
}
class FixedDeposit extends Account {
    FixedDeposit(double bal) { super(bal); }
    double interestRate() { return 0.07; }
}
public class Main {
    public static void main(String[] args) {
        Account[] accounts = {
            new SavingsAccount(10000),
            new FixedDeposit(10000)
        };
        for (Account a : accounts) {
            System.out.printf("%.2f at %.0f%% for 5 years = %.2f%n",
                a.balance, a.interestRate()*100, a.futureValue(5));
        }
    }
}

interface Validator {
    boolean validate(String input);
    
    default Validator and(Validator other) {
        return input -> this.validate(input) && other.validate(input);
    }
}
public class Main {
    public static void main(String[] args) {
        Validator notEmpty = s -> !s.isEmpty();
        Validator shortEnough = s -> s.length() <= 10;
        Validator combined = notEmpty.and(shortEnough);
        
        System.out.println(combined.validate(""));
        System.out.println(combined.validate("Hello"));
        System.out.println(combined.validate("This is a very long string"));
    }
}