instanceof
Complete Deep Dive

public class BasicInstanceof {

    // Simple class hierarchy
    static class Animal {
        void eat() { System.out.println("Animal eats"); }
    }
    static class Dog extends Animal {
        void bark() { System.out.println("Dog barks!"); }
    }
    static class Cat extends Animal {
        void meow() { System.out.println("Cat meows!"); }
    }
    static class GoldenRetriever extends Dog {
        void fetch() { System.out.println("Fetching!"); }
    }

    public static void main(String[] args) {

        Dog    dog    = new Dog();
        Cat    cat    = new Cat();
        Animal animal = new Animal();
        GoldenRetriever gr = new GoldenRetriever();

        System.out.println("── Dog object checks ──");
        System.out.println("dog instanceof Dog:    "    + (dog instanceof Dog));     // true
        System.out.println("dog instanceof Animal: "    + (dog instanceof Animal));  // true  — subtype
        System.out.println("dog instanceof Object: "    + (dog instanceof Object));  // true  — all objects
        System.out.println("dog instanceof Cat:    "    + (dog instanceof Cat));     // false — sibling

        System.out.println("\n── GoldenRetriever (3 levels deep) ──");
        System.out.println("gr instanceof GoldenRetriever: " + (gr instanceof GoldenRetriever)); // true
        System.out.println("gr instanceof Dog:             " + (gr instanceof Dog));             // true
        System.out.println("gr instanceof Animal:          " + (gr instanceof Animal));          // true
        System.out.println("gr instanceof Object:          " + (gr instanceof Object));          // true
        System.out.println("gr instanceof Cat:             " + (gr instanceof Cat));             // false

        System.out.println("\n── Parent object check ──");
        System.out.println("animal instanceof Animal: " + (animal instanceof Animal));  // true
        System.out.println("animal instanceof Dog:    " + (animal instanceof Dog));     // false! parent ≠ child

        System.out.println("\n── Null check ──");
        Animal nullRef = null;
        System.out.println("null instanceof Animal: "  + (nullRef instanceof Animal));  // false — no NPE!
        System.out.println("null instanceof Object: "  + (nullRef instanceof Object));  // false
    }
}

public class SafeCasting {

    static class Shape {
        void draw() { System.out.println("Drawing shape"); }
    }
    static class Circle extends Shape {
        double radius;
        Circle(double r) { radius = r; }
        double area() { return Math.PI * radius * radius; }
    }
    static class Rectangle extends Shape {
        double w, h;
        Rectangle(double w, double h) { this.w = w; this.h = h; }
        double area() { return w * h; }
    }

    // Mixed shapes ko process karo
    static void processShape(Shape s) {
        System.out.println("Processing: " + s.getClass().getSimpleName());

        // ✅ SAFE: pehle instanceof check, phir cast
        if (s instanceof Circle) {
            Circle c = (Circle) s;           // safe downcast
            System.out.printf("  Circle area = %.2f%n", c.area());
        } else if (s instanceof Rectangle) {
            Rectangle r = (Rectangle) s;    // safe downcast
            System.out.printf("  Rectangle area = %.2f%n", r.area());
        } else {
            System.out.println("  Unknown shape — draw only");
        }
    }

    public static void main(String[] args) {
        Shape[] shapes = {
            new Circle(5.0),
            new Rectangle(4.0, 6.0),
            new Circle(3.0),
            new Shape()
        };
        for (Shape s : shapes) processShape(s);

        System.out.println("\n── ClassCastException Prevention ──");
        Shape genericShape = new Shape();

        // ❌ UNSAFE: bina check ke cast — ClassCastException!
        try {
            Circle bad = (Circle) genericShape;  // boom!
        } catch (ClassCastException e) {
            System.out.println("ClassCastException: " + e.getMessage());
        }

        // ✅ SAFE: instanceof check se bachao
        if (genericShape instanceof Circle) {
            Circle safe = (Circle) genericShape;
        } else {
            System.out.println("Not a Circle — skip kiya safely.");
        }
    }
}

public class PolymorphicRef {

    static class Vehicle { String type = "Vehicle"; }
    static class Car extends Vehicle {
        String type = "Car";
        void drive() { System.out.println("Car driving!"); }
    }
    static class ElectricCar extends Car {
        String type = "ElectricCar";
        void charge() { System.out.println("Charging battery..."); }
    }

    public static void main(String[] args) {
        // Runtime type: ElectricCar, Declared type: Vehicle
        Vehicle v = new ElectricCar();

        System.out.println("Declared type:  Vehicle");
        System.out.println("Runtime class:  " + v.getClass().getSimpleName());

        // Compile-time: v sirf Vehicle methods dekh sakta hai
        // Runtime: actual object ElectricCar hai
        System.out.println("\ninstanceof checks on Vehicle ref (actual: ElectricCar):");
        System.out.println("v instanceof Vehicle:     "     + (v instanceof Vehicle));     // true
        System.out.println("v instanceof Car:         "     + (v instanceof Car));         // true!
        System.out.println("v instanceof ElectricCar: "     + (v instanceof ElectricCar)); // true!

        // Without instanceof — compile error (v.drive() not accessible)
        // v.drive();  ← COMPILE ERROR: Vehicle has no drive() method

        // With instanceof — safe, full access
        if (v instanceof ElectricCar) {
            ElectricCar ec = (ElectricCar) v;
            ec.drive();    // inherited from Car
            ec.charge();   // ElectricCar specific
        }

        // Array of mixed vehicles
        Vehicle[] fleet = {
            new Vehicle(),
            new Car(),
            new ElectricCar(),
            new Car()
        };

        System.out.println("\nFleet analysis:");
        int regularCars = 0, electricCars = 0;
        for (Vehicle veh : fleet) {
            if      (veh instanceof ElectricCar) electricCars++;
            else if (veh instanceof Car)         regularCars++;
        }
        System.out.println("Regular Cars: "  + regularCars);
        System.out.println("Electric Cars: " + electricCars);
    }
}

public class MultiLevelHierarchy {

    abstract static class LivingBeing {
        abstract void breathe();
    }
    abstract static class Animal extends LivingBeing {
        abstract void move();
    }
    static class Mammal extends Animal {
        void breathe() { System.out.println("Breathing with lungs"); }
        void move()    { System.out.println("Moving on legs"); }
        void warmBlood() { System.out.println("Warm-blooded"); }
    }
    static class Dog extends Mammal {
        void bark() { System.out.println("Woof!"); }
    }
    static class Labrador extends Dog {
        void fetch() { System.out.println("Fetching ball!"); }
    }

    public static void main(String[] args) {
        Labrador lab = new Labrador();

        System.out.println("── Labrador instanceof checks (bottom-up) ──");
        System.out.printf("%-35s %s%n", "lab instanceof Labrador:",    lab instanceof Labrador);    // true
        System.out.printf("%-35s %s%n", "lab instanceof Dog:",         lab instanceof Dog);         // true
        System.out.printf("%-35s %s%n", "lab instanceof Mammal:",      lab instanceof Mammal);      // true
        System.out.printf("%-35s %s%n", "lab instanceof Animal:",      lab instanceof Animal);      // true (abstract!)
        System.out.printf("%-35s %s%n", "lab instanceof LivingBeing:", lab instanceof LivingBeing); // true (abstract!)
        System.out.printf("%-35s %s%n", "lab instanceof Object:",      lab instanceof Object);      // true (always!)

        System.out.println("\n── Process by type ──");
        LivingBeing[] beings = {
            new Labrador(), new Dog(), new Mammal()
        };
        for (LivingBeing b : beings) {
            System.out.print(b.getClass().getSimpleName() + " → ");
            if (b instanceof Labrador) {
                ((Labrador) b).fetch();
            } else if (b instanceof Dog) {
                ((Dog) b).bark();
            } else if (b instanceof Mammal) {
                ((Mammal) b).warmBlood();
            }
        }
    }
}

import java.util.Objects;

public class EqualsPattern {

    static class Student {
        String name;
        int    rollNo;
        double cgpa;

        Student(String name, int rollNo, double cgpa) {
            this.name   = name;
            this.rollNo = rollNo;
            this.cgpa   = cgpa;
        }

        @Override
        public boolean equals(Object obj) {
            // Step 1: Same reference? → definitely equal
            if (this == obj) return true;

            // Step 2: instanceof check — null bhi handle ho jaata hai!
            // null instanceof Student → false, NPE nahi aata
            if (!(obj instanceof Student)) return false;

            // Step 3: Safe cast — already verified hai
            Student other = (Student) obj;

            // Step 4: Field comparison
            return this.rollNo == other.rollNo
                && Objects.equals(this.name, other.name)
                && Double.compare(this.cgpa, other.cgpa) == 0;
        }

        @Override
        public int hashCode() {
            return Objects.hash(name, rollNo, cgpa);
        }

        @Override
        public String toString() {
            return "Student{" + name + ", roll=" + rollNo + ", cgpa=" + cgpa + "}";
        }
    }

    public static void main(String[] args) {
        Student s1 = new Student("Rahul", 101, 8.5);
        Student s2 = new Student("Rahul", 101, 8.5);  // same data
        Student s3 = new Student("Priya", 102, 9.1);  // different

        System.out.println("s1.equals(s2): " + s1.equals(s2));  // true — same data
        System.out.println("s1.equals(s3): " + s1.equals(s3));  // false
        System.out.println("s1.equals(null): " + s1.equals(null)); // false — no NPE!
        System.out.println("s1.equals(\"hello\"): " + s1.equals("hello")); // false — wrong type
        System.out.println("s1 == s2: " + (s1 == s2));       // false — different refs
    }
}

public class InterfaceInstanceof {

    interface Flyable  { void fly();  }
    interface Swimmable{ void swim(); }
    interface Walkable { void walk(); }

    static class Duck implements Flyable, Swimmable, Walkable {
        public void fly()  { System.out.println("Duck flying!");    }
        public void swim() { System.out.println("Duck swimming!");  }
        public void walk() { System.out.println("Duck waddling!");  }
    }
    static class Eagle implements Flyable, Walkable {
        public void fly()  { System.out.println("Eagle soaring!");  }
        public void walk() { System.out.println("Eagle walking!");  }
    }
    static class Fish implements Swimmable {
        public void swim() { System.out.println("Fish swimming!");  }
    }

    static void demonstrateCapabilities(Object obj) {
        System.out.println("\nObject: " + obj.getClass().getSimpleName());
        // Runtime pe capabilities check karo — interface instanceof
        if (obj instanceof Flyable)   ((Flyable)  obj).fly();
        if (obj instanceof Swimmable) ((Swimmable)obj).swim();
        if (obj instanceof Walkable)  ((Walkable) obj).walk();
    }

    public static void main(String[] args) {
        Object[] creatures = { new Duck(), new Eagle(), new Fish() };
        for (Object c : creatures) demonstrateCapabilities(c);

        System.out.println("\n── Interface Type Checks ──");
        Duck duck = new Duck();
        System.out.println("duck instanceof Flyable:   "  + (duck instanceof Flyable));
        System.out.println("duck instanceof Swimmable: "  + (duck instanceof Swimmable));
        System.out.println("duck instanceof Walkable:  "  + (duck instanceof Walkable));

        Eagle eagle = new Eagle();
        System.out.println("eagle instanceof Swimmable:"  + (eagle instanceof Swimmable)); // false!

        // Built-in Java interfaces
        System.out.println("\n── Built-in Interface Checks ──");
        Object[] items = { "Hello", 42, 3.14, new java.util.ArrayList<>() };
        for (Object item : items) {
            System.out.printf("%-12s Comparable:%s  Serializable:%s%n",
                item.getClass().getSimpleName(),
                item instanceof Comparable,
                item instanceof java.io.Serializable);
        }
    }
}

public class NullBehavior {

    static class Box {
        String content;
        Box(String c) { content = c; }
        void open() { System.out.println("Box opened: " + content); }
    }

    static void processBox(Object obj) {
        // Single check handles both: null AND wrong type
        if (obj instanceof Box) {
            Box b = (Box) obj;
            b.open();
        } else {
            System.out.println("Not a Box (or null): " + obj);
        }
    }

    public static void main(String[] args) {
        // null instanceof — NEVER throws NPE
        Object  nullObj    = null;
        String  nullStr    = null;
        Box     nullBox    = null;

        System.out.println("null instanceof Object:  " + (nullObj  instanceof Object));  // false
        System.out.println("null instanceof String:  " + (nullStr  instanceof String));  // false
        System.out.println("null instanceof Box:     " + (nullBox  instanceof Box));     // false

        System.out.println("\n── processBox with different inputs ──");
        processBox(new Box("Surprise!"));  // valid Box
        processBox(null);                  // null — handled gracefully
        processBox("Just a String");       // wrong type — handled
        processBox(42);                     // wrong type — handled

        System.out.println("\n── Without instanceof — NPE danger! ──");
        Object maybeNull = null;

        // ❌ Without check — NPE
        try {
            Box bad = (Box) maybeNull;   // null cast — no exception here...
            bad.open();                 // ...but NPE here!
        } catch (NullPointerException e) {
            System.out.println("NPE caught — bina instanceof ke cast unsafe");
        }

        // ✅ With instanceof — completely safe
        if (maybeNull instanceof Box) {  // null se false milega, no NPE
            ((Box) maybeNull).open();
        } else {
            System.out.println("Safely detected: null ya not-a-Box");
        }

        // Null safety in array processing
        System.out.println("\n── Mixed array with nulls ──");
        Object[] mixed = { new Box("A"), null, "String",
                            new Box("B"), null };
        int count = 0;
        for (Object o : mixed) {
            if (o instanceof Box) count++;  // nulls auto-skipped
        }
        System.out.println("Box count (nulls ignored): " + count);
    }
}

public class PatternMatchingDemo {

    static class Shape  { }
    static class Circle    extends Shape { double radius;    Circle(double r) { radius = r; } }
    static class Rectangle  extends Shape { double w, h;      Rectangle(double w, double h) { this.w=w; this.h=h; } }
    static class Triangle   extends Shape { double base, ht;  Triangle(double b, double h) { base=b; ht=h; } }

    // ── OLD STYLE (before Java 16) ──
    static double areaOld(Shape s) {
        if (s instanceof Circle) {
            Circle c = (Circle) s;           // explicit cast — redundant!
            return Math.PI * c.radius * c.radius;
        } else if (s instanceof Rectangle) {
            Rectangle r = (Rectangle) s;    // explicit cast — redundant!
            return r.w * r.h;
        } else if (s instanceof Triangle) {
            Triangle t = (Triangle) s;      // explicit cast — redundant!
            return 0.5 * t.base * t.ht;
        }
        return 0;
    }

    // ── NEW STYLE (Java 16+) Pattern Matching ──
    static double areaNew(Shape s) {
        if      (s instanceof Circle    c) return Math.PI * c.radius * c.radius;
        else if (s instanceof Rectangle r) return r.w * r.h;
        else if (s instanceof Triangle  t) return 0.5 * t.base * t.ht;
        return 0;
    }

    // ── Java 21+ Switch Pattern ──
    static String describeShape(Shape s) {
        return switch (s) {
            case Circle    c -> "Circle with radius "  + c.radius;
            case Rectangle r -> "Rectangle " + r.w + "×" + r.h;
            case Triangle  t -> "Triangle base=" + t.base;
            default          -> "Unknown shape";
        };
    }

    public static void main(String[] args) {
        Shape[] shapes = {
            new Circle(5),
            new Rectangle(4, 6),
            new Triangle(3, 8)
        };

        System.out.printf("%-25s %-10s %-10s%n", "Shape", "Old Area", "New Area");
        System.out.println("─".repeat(50));
        for (Shape s : shapes) {
            System.out.printf("%-25s %-10.2f %-10.2f%n",
                describeShape(s), areaOld(s), areaNew(s));
        }

        // Pattern matching with condition (Java 21 guarded pattern)
        System.out.println("\n── Pattern with Condition ──");
        Object obj = "Hello World";
        if (obj instanceof String s && s.length() > 5) {
            System.out.println("Long string: " + s.toUpperCase());
        }

        // Scope demonstration
        Object num = 42;
        if (num instanceof Integer i) {
            System.out.println("In if block, i = " + i);  // accessible
        }
        // System.out.println(i);  ← COMPILE ERROR — out of scope
        System.out.println("After if block — i is out of scope");
    }
}

import java.util.*;

public class JsonLikeProcessor {

    // Simulate JSON values — could be any type
    static String formatValue(Object value) {
        if      (value instanceof String  s)  return "\"" + s + "\"";
        else if (value instanceof Integer i)  return i.toString();
        else if (value instanceof Double  d)  return String.format("%.2f", d);
        else if (value instanceof Boolean b)  return b ? "true" : "false";
        else if (value instanceof List<?> l) return "[array, size=" + l.size() + "]";
        else if (value == null)              return "null";
        else                                  return value.toString();
    }

    static String getType(Object value) {
        if      (value instanceof String)   return "string";
        else if (value instanceof Integer)  return "integer";
        else if (value instanceof Double)   return "float";
        else if (value instanceof Boolean)  return "boolean";
        else if (value instanceof List)     return "array";
        else if (value == null)            return "null";
        else                                return "unknown";
    }

    public static void main(String[] args) {
        // Simulate a JSON response fields
        Map<String, Object> jsonData = new LinkedHashMap<>();
        jsonData.put("name",    "Rahul Kumar");
        jsonData.put("age",     25);
        jsonData.put("cgpa",    8.75);
        jsonData.put("active",  true);
        jsonData.put("courses", List.of("Java", "DSA", "SQL"));
        jsonData.put("nickname",null);

        System.out.println("{\n  Parsed JSON fields:");
        for (Map.Entry<String, Object> entry : jsonData.entrySet()) {
            System.out.printf("  %-12s: %-20s  [type: %s]%n",
                entry.getKey(),
                formatValue(entry.getValue()),
                getType(entry.getValue()));
        }
        System.out.println("}");

        // Compute stats on numeric values only
        System.out.println("\n── Numeric fields sum ──");
        double numericSum = 0;
        for (Object val : jsonData.values()) {
            if      (val instanceof Integer i) numericSum += i;
            else if (val instanceof Double  d) numericSum += d;
        }
        System.out.printf("Sum of numeric values: %.2f%n", numericSum);
    }
}

import java.util.*;

public class PaymentProcessor {

    interface Payment {
        double getAmount();
        String getPaymentId();
    }

    static class CreditCardPayment implements Payment {
        String id, cardNumber, bank;
        double amount;
        CreditCardPayment(String id, String card, String bank, double amt) {
            this.id = id; this.cardNumber = card; this.bank = bank; this.amount = amt;
        }
        public double getAmount() { return amount; }
        public String getPaymentId() { return id; }
    }

    static class UPIPayment implements Payment {
        String id, upiId, app;
        double amount;
        UPIPayment(String id, String upi, String app, double amt) {
            this.id = id; this.upiId = upi; this.app = app; this.amount = amt;
        }
        public double getAmount() { return amount; }
        public String getPaymentId() { return id; }
    }

    static class NetBankingPayment implements Payment {
        String id, bankCode;
        double amount;
        NetBankingPayment(String id, String code, double amt) {
            this.id = id; this.bankCode = code; this.amount = amt;
        }
        public double getAmount() { return amount; }
        public String getPaymentId() { return id; }
    }

    static void processPayment(Payment payment) {
        System.out.printf("\n[%s] Amount: ₹%.2f%n",
            payment.getPaymentId(), payment.getAmount());

        // instanceof — type specific processing
        if (payment instanceof CreditCardPayment cc) {
            System.out.printf("  Type: Credit Card | Bank: %s | Card: ****%s%n",
                cc.bank, cc.cardNumber.substring(cc.cardNumber.length()-4));
            System.out.println("  → Routing to card gateway...");
        } else if (payment instanceof UPIPayment upi) {
            System.out.printf("  Type: UPI | VPA: %s | App: %s%n", upi.upiId, upi.app);
            System.out.println("  → Routing to UPI gateway...");
        } else if (payment instanceof NetBankingPayment nb) {
            System.out.printf("  Type: Net Banking | Bank Code: %s%n", nb.bankCode);
            System.out.println("  → Routing to bank portal...");
        }
    }

    public static void main(String[] args) {
        List<Payment> transactions = List.of(
            new CreditCardPayment("TXN001", "4111111111111234", "HDFC", 2499.00),
            new UPIPayment("TXN002", "rahul@paytm", "Paytm", 599.00),
            new NetBankingPayment("TXN003", "SBI001", 12000.00),
            new UPIPayment("TXN004", "priya@gpay", "Google Pay", 399.00)
        );

        System.out.println("=== PAYMENT GATEWAY PROCESSOR ===");
        transactions.forEach(PaymentProcessor::processPayment);

        // Summary by type
        System.out.println("\n=== SUMMARY ===");
        double cardTotal = 0, upiTotal = 0, nbTotal = 0;
        for (Payment p : transactions) {
            if      (p instanceof CreditCardPayment) cardTotal += p.getAmount();
            else if (p instanceof UPIPayment)         upiTotal  += p.getAmount();
            else if (p instanceof NetBankingPayment)  nbTotal   += p.getAmount();
        }
        System.out.printf("Credit Card: ₹%.2f | UPI: ₹%.2f | Net Banking: ₹%.2f%n",
            cardTotal, upiTotal, nbTotal);
    }
}

public class GetClassVsInstanceof {

    static class Animal { }
    static class Dog extends Animal { }

    public static void main(String[] args) {
        Animal animal = new Dog();  // Runtime: Dog, Declared: Animal

        // instanceof — hierarchy-aware (is-a check)
        System.out.println("instanceof checks:");
        System.out.println("  animal instanceof Dog:    "    + (animal instanceof Dog));    // true
        System.out.println("  animal instanceof Animal: "    + (animal instanceof Animal));  // true

        // getClass() — exact class match (no hierarchy)
        System.out.println("\ngetClass() checks:");
        System.out.println("  getClass() == Dog.class:    "  + (animal.getClass() == Dog.class));    // true
        System.out.println("  getClass() == Animal.class: "  + (animal.getClass() == Animal.class)); // FALSE!

        System.out.println("\nactual class: " + animal.getClass().getSimpleName()); // "Dog"

        // ── When to use which in equals() ──
        System.out.println("\n── equals() design decision ──");
        System.out.println("Use instanceof when:");
        System.out.println("  → Subclass objects should be equal to parent if same data");
        System.out.println("  → Liskov Substitution Principle followed");
        System.out.println("\nUse getClass() when:");
        System.out.println("  → Only exact same type objects should be equal");
        System.out.println("  → Dog.equals(Animal) should be false even with same data");

        // getClass() works on null? NO — NPE!
        Animal nullAnimal = null;
        System.out.println("\nnull instanceof Animal: " + (nullAnimal instanceof Animal)); // false — safe
        try {
            nullAnimal.getClass();  // NPE!
        } catch (NullPointerException e) {
            System.out.println("null.getClass(): NullPointerException!");
        }
    }
}

public class RefactoringDemo {

    // ❌ BAD: instanceof chain — hard to extend, hard to maintain
    static double areaBAD(Object shape) {
        if (shape instanceof BadCircle) {
            BadCircle c = (BadCircle) shape;
            return Math.PI * c.r * c.r;
        } else if (shape instanceof BadRect) {
            BadRect r = (BadRect) shape;
            return r.w * r.h;
        }
        // Adding new shape? Ye method phir modify karna padega! — Open/Closed Principle violation
        return 0;
    }
    static class BadCircle { double r; BadCircle(double r){ this.r=r; } }
    static class BadRect   { double w,h; BadRect(double w, double h){ this.w=w; this.h=h; } }

    // ✅ GOOD: Polymorphism — adding new shape = just new class, no change here!
    interface GoodShape {
        double area();
        String name();
    }
    static class GoodCircle implements GoodShape {
        double r;
        GoodCircle(double r) { this.r = r; }
        public double area() { return Math.PI * r * r; }
        public String name()  { return "Circle(r=" + r + ")"; }
    }
    static class GoodRect implements GoodShape {
        double w, h;
        GoodRect(double w, double h) { this.w=w; this.h=h; }
        public double area() { return w * h; }
        public String name()  { return "Rect(" + w + "×" + h + ")"; }
    }
    static class GoodTriangle implements GoodShape {
        double b, h;
        GoodTriangle(double b, double h) { this.b=b; this.h=h; }
        public double area() { return 0.5 * b * h; }
        public String name()  { return "Triangle(b=" + b + ")"; }
    }

    public static void main(String[] args) {
        System.out.println("── BAD: instanceof chain ──");
        System.out.printf("Circle area (bad): %.2f%n", areaBAD(new BadCircle(5)));
        System.out.printf("Rect area (bad):   %.2f%n", areaBAD(new BadRect(4, 6)));

        System.out.println("\n── GOOD: Polymorphism — no instanceof needed! ──");
        GoodShape[] shapes = {
            new GoodCircle(5),
            new GoodRect(4, 6),
            new GoodTriangle(3, 8)   // New shape? Zero change to processing code!
        };
        for (GoodShape s : shapes)
            System.out.printf("%-20s area = %.2f%n", s.name(), s.area());
    }
}