Abstraction with abstract classes

abstract class Animal {
    private final String name;

    Animal(String name) {
        this.name = name;
    }

    abstract String sound();

    void speak() {
        System.out.println(name + " says " + sound());
    }
}

class Cow extends Animal {
    Cow(String name) { super(name); }

    @Override
    String sound() { return "Moo"; }
}

class Parrot extends Animal {
    Parrot(String name) { super(name); }

    @Override
    String sound() { return "Ram Ram"; }
}

public class Main {
    public static void main(String[] args) {
        Animal[] zoo = { new Cow("Gauri"), new Parrot("Mithu") };
        for (Animal a : zoo) {
            a.speak();
        }
    }
}

abstract class Account {
    protected final String no;

    Account(String no) {
        this.no = no;
        System.out.println("Account opened: " + no);
    }

    abstract double interestRate();
}

class SavingsAccount extends Account {
    SavingsAccount(String no) {
        super(no);
        System.out.println("Savings account ready");
    }

    @Override
    double interestRate() { return 3.5; }
}

public class Main {
    public static void main(String[] args) {
        Account a = new SavingsAccount("SB-2041");
        System.out.println(a.no + " earns " + a.interestRate() + "%");
    }
}

abstract class Shape {
    abstract double area();
    abstract double perimeter();

    void print() {
        System.out.printf("%s: area %.2f, perimeter %.2f%n",
                getClass().getSimpleName(), area(), perimeter());
    }
}

class Rectangle extends Shape {
    private final double l, w;
    Rectangle(double l, double w) { this.l = l; this.w = w; }

    @Override double area() { return l * w; }
    @Override double perimeter() { return 2 * (l + w); }
}

class Circle extends Shape {
    private final double r;
    Circle(double r) { this.r = r; }

    @Override double area() { return Math.PI * r * r; }
    @Override double perimeter() { return 2 * Math.PI * r; }
}

public class Main {
    public static void main(String[] args) {
        new Rectangle(8, 5).print();
        new Circle(4).print();
    }
}

abstract class HotDrink {
    final void make() {
        System.out.println("Boil water");
        brew();
        System.out.println("Pour into cup");
        extras();
        System.out.println("---");
    }

    abstract void brew();
    abstract void extras();
}

class Chai extends HotDrink {
    @Override void brew() { System.out.println("Boil tea leaves with milk, ginger, elaichi"); }
    @Override void extras() { System.out.println("Add sugar"); }
}

class Coffee extends HotDrink {
    @Override void brew() { System.out.println("Add filter coffee decoction"); }
    @Override void extras() { System.out.println("Add hot milk and froth"); }
}

public class Main {
    public static void main(String[] args) {
        HotDrink[] orders = { new Chai(), new Coffee() };
        for (HotDrink d : orders) {
            d.make();
        }
    }
}

abstract class HotDrink {
    final void make() {
        brew();
        if (wantsSugar()) {
            System.out.println("  + sugar");
        }
    }

    abstract void brew();

    boolean wantsSugar() {          // hook: optional to override
        return true;
    }
}

class Chai extends HotDrink {
    @Override void brew() { System.out.println("Chai brewed"); }
}

class GreenTea extends HotDrink {
    @Override void brew() { System.out.println("Green tea steeped"); }

    @Override boolean wantsSugar() { return false; }
}

public class Main {
    public static void main(String[] args) {
        new Chai().make();
        new GreenTea().make();
    }
}

abstract class BaseEntity {
    private static int nextId = 1;
    protected final int id;

    BaseEntity() {
        id = nextId++;
    }

    String label() {
        return getClass().getSimpleName() + "#" + id;
    }
}

class Product extends BaseEntity {
    private final String name;

    Product(String name) {
        this.name = name;
    }

    String show() {
        return label() + " " + name;
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(new Product("Rice 5kg").show());
        System.out.println(new Product("Dal 1kg").show());
    }
}

abstract class Vehicle {
    abstract int wheels();
    abstract String fuel();

    String info() {
        return getClass().getSimpleName() + ": " + wheels() + " wheels, " + fuel();
    }
}

abstract class TwoWheeler extends Vehicle {
    @Override
    int wheels() { return 2; }
}

class Scooter extends TwoWheeler {
    @Override
    String fuel() { return "petrol"; }
}

class EBike extends TwoWheeler {
    @Override
    String fuel() { return "battery"; }
}

public class Main {
    public static void main(String[] args) {
        Vehicle[] list = { new Scooter(), new EBike() };
        for (Vehicle v : list) {
            System.out.println(v.info());
        }
    }
}

abstract class Account {
    private final String no;
    protected double balance;

    Account(String no, double balance) {
        this.no = no;
        this.balance = balance;
    }

    abstract double charge();

    final void monthEnd() {
        double c = charge();
        balance -= c;
        System.out.printf("%s charge Rs %.2f, balance Rs %.2f%n", no, c, balance);
    }
}

class Savings extends Account {
    Savings(String no, double balance) { super(no, balance); }

    @Override
    double charge() { return balance < 5000 ? 50 : 0; }
}

class Current extends Account {
    Current(String no, double balance) { super(no, balance); }

    @Override
    double charge() { return 200; }
}

public class Main {
    public static void main(String[] args) {
        Account[] accounts = {
            new Savings("SB-1", 3200), new Savings("SB-2", 12000), new Current("CA-9", 85000)
        };
        for (Account a : accounts) {
            a.monthEnd();
        }
    }
}

abstract class Loan {
    private final double principal;
    private final int months;

    Loan(double principal, int months) {
        this.principal = principal;
        this.months = months;
    }

    abstract double yearlyRate();

    final double emi() {
        double r = yearlyRate() / 12 / 100;
        double f = Math.pow(1 + r, months);
        return principal * r * f / (f - 1);
    }
}

class HomeLoan extends Loan {
    HomeLoan(double p, int m) { super(p, m); }
    @Override double yearlyRate() { return 8.5; }
}

class CarLoan extends Loan {
    CarLoan(double p, int m) { super(p, m); }
    @Override double yearlyRate() { return 9.5; }
}

class PersonalLoan extends Loan {
    private final boolean salaried;
    PersonalLoan(double p, int m, boolean salaried) { super(p, m); this.salaried = salaried; }
    @Override double yearlyRate() { return salaried ? 12.5 : 14.0; }
}

public class Main {
    public static void main(String[] args) {
        Loan[] loans = {
            new HomeLoan(3000000, 240), new CarLoan(600000, 60), new PersonalLoan(200000, 24, true)
        };
        for (Loan l : loans) {
            System.out.printf("%-12s %5.2f%%  EMI Rs %,.0f%n",
                    l.getClass().getSimpleName(), l.yearlyRate(), l.emi());
        }
    }
}

abstract class Message {
    protected final String customer;
    protected final String text;

    Message(String customer, String text) {
        this.customer = customer;
        this.text = text;
    }

    abstract String body();

    final String compose() {
        return "Hi " + customer + ",\n" + body() + "\n- Team Kirana Mart";
    }
}

class SmsMessage extends Message {
    SmsMessage(String c, String t) { super(c, t); }

    @Override
    String body() {
        return text.length() > 40 ? text.substring(0, 37) + "..." : text;
    }
}

class EmailMessage extends Message {
    EmailMessage(String c, String t) { super(c, t); }

    @Override
    String body() {
        return "Subject: Order update\n" + text;
    }
}

public class Main {
    public static void main(String[] args) {
        String text = "Your order #812 has been shipped and will arrive by Friday.";
        Message[] out = { new SmsMessage("Meera", text), new EmailMessage("Meera", text) };
        for (Message m : out) {
            System.out.println(m.compose());
            System.out.println("=====");
        }
    }
}