Introduction
Imagine you're at a zoo with different animal enclosures. You see an animal and wonder: "Is that a lion? Is it a bird? Can it fly?" The instanceof operator in Java is like asking these questions - it helps you determine what type of object you're dealing with at runtime!
The instanceof operator is used to test whether an object is an instance of a specific class, subclass, or interface. It's essential for type checking, safe casting, and polymorphic behavior.
What is the instanceof Operator?
The instanceof operator is a binary operator that returns true if the object on the left is an instance of the type on the right, otherwise it returns false.
Basic Syntax:
object instanceof Type
Returns:
trueif object is an instance of the specified typefalseif object is not an instance, or isnull
Code Explanation with Examples
Example 1: Basic instanceof Usage
// 🎯 BASE CLASS AND SUBCLASSES class Animal { protected String name; public Animal(String name) { this.name = name; } public void eat() { System.out.println(name + " is eating..."); } } class Mammal extends Animal { public Mammal(String name) { super(name); } public void giveBirth() { System.out.println(name + " is giving birth to live young"); } } class Bird extends Animal { public Bird(String name) { super(name); } public void fly() { System.out.println(name + " is flying! 🕊️"); } } class Fish extends Animal { public Fish(String name) { super(name); } public void swim() { System.out.println(name + " is swimming! 🐠"); } } // 🎯 INTERFACES interface Flyable { void fly(); } interface Swimmable { void swim(); } class Duck extends Bird implements Flyable, Swimmable { public Duck(String name) { super(name); } @Override public void fly() { System.out.println(name + " the duck is flying gracefully"); } @Override public void swim() { System.out.println(name + " the duck is paddling in water"); } public void quack() { System.out.println(name + " says: Quack! Quack!"); } } public class BasicInstanceOf { public static void main(String[] args) { System.out.println("=== BASIC instanceof OPERATOR DEMONSTRATION ==="); // 🎯 CREATING DIFFERENT ANIMALS Animal lion = new Mammal("Simba"); Animal eagle = new Bird("Eddie"); Animal salmon = new Fish("Sammy"); Animal donald = new Duck("Donald"); // 🎯 BASIC instanceof CHECKS System.out.println("\n1. BASIC instanceof CHECKS:"); System.out.println("lion instanceof Animal: " + (lion instanceof Animal)); System.out.println("lion instanceof Mammal: " + (lion instanceof Mammal)); System.out.println("lion instanceof Bird: " + (lion instanceof Bird)); System.out.println("eagle instanceof Animal: " + (eagle instanceof Animal)); System.out.println("eagle instanceof Bird: " + (eagle instanceof Bird)); System.out.println("eagle instanceof Mammal: " + (eagle instanceof Mammal)); // 🎯 instanceof WITH INTERFACES System.out.println("\n2. instanceof WITH INTERFACES:"); System.out.println("donald instanceof Flyable: " + (donald instanceof Flyable)); System.out.println("donald instanceof Swimmable: " + (donald instanceof Swimmable)); System.out.println("eagle instanceof Flyable: " + (eagle instanceof Flyable)); // false - Bird doesn't implement Flyable System.out.println("salmon instanceof Swimmable: " + (salmon instanceof Swimmable)); // false - Fish doesn't implement Swimmable // 🎯 NULL CHECKS WITH instanceof System.out.println("\n3. NULL CHECKS WITH instanceof:"); Animal nullAnimal = null; System.out.println("nullAnimal instanceof Animal: " + (nullAnimal instanceof Animal)); System.out.println("null instanceof Object: " + (null instanceof Object)); // 🎯 INHERITANCE CHAIN CHECKS System.out.println("\n4. INHERITANCE CHAIN CHECKS:"); System.out.println("donald instanceof Animal: " + (donald instanceof Animal)); System.out.println("donald instanceof Bird: " + (donald instanceof Bird)); System.out.println("donald instanceof Duck: " + (donald instanceof Duck)); System.out.println("donald instanceof Object: " + (donald instanceof Object)); // 🎯 ARRAY OF ANIMALS - POLYMORPHIC PROCESSING System.out.println("\n5. POLYMORPHIC PROCESSING WITH instanceof:"); Animal[] animals = {lion, eagle, salmon, donald}; for (Animal animal : animals) { System.out.println("\n--- Processing " + animal.name + " ---"); animal.eat(); // 🎯 TYPE CHECKING AND SAFE CASTING if (animal instanceof Mammal) { Mammal mammal = (Mammal) animal; // Safe cast mammal.giveBirth(); } if (animal instanceof Bird) { Bird bird = (Bird) animal; // Safe cast bird.fly(); } if (animal instanceof Fish) { Fish fish = (Fish) animal; // Safe cast fish.swim(); } if (animal instanceof Duck) { Duck duck = (Duck) animal; // Safe cast duck.quack(); duck.swim(); // Duck-specific method } // 🎯 INTERFACE CHECKS if (animal instanceof Flyable) { Flyable flyable = (Flyable) animal; flyable.fly(); } if (animal instanceof Swimmable) { Swimmable swimmable = (Swimmable) animal; swimmable.swim(); } } // 🎯 BENEFITS OF instanceof System.out.println("\n6. BENEFITS OF instanceof OPERATOR:"); System.out.println("✅ Runtime Type Checking: Determine actual type at runtime"); System.out.println("✅ Safe Casting: Avoid ClassCastException"); System.out.println("✅ Polymorphic Behavior: Different actions based on type"); System.out.println("✅ Interface Implementation Checks: Verify capability"); } } Output:
=== BASIC instanceof OPERATOR DEMONSTRATION === 1. BASIC instanceof CHECKS: lion instanceof Animal: true lion instanceof Mammal: true lion instanceof Bird: false eagle instanceof Animal: true eagle instanceof Bird: true eagle instanceof Mammal: false 2. instanceof WITH INTERFACES: donald instanceof Flyable: true donald instanceof Swimmable: true eagle instanceof Flyable: false salmon instanceof Swimmable: false 3. NULL CHECKS WITH instanceof: nullAnimal instanceof Animal: false null instanceof Object: false 4. INHERITANCE CHAIN CHECKS: donald instanceof Animal: true donald instanceof Bird: true donald instanceof Duck: true donald instanceof Object: true 5. POLYMORPHIC PROCESSING WITH instanceof: --- Processing Simba --- Simba is eating... Simba is giving birth to live young --- Processing Eddie --- Eddie is eating... Eddie is flying! 🕊️ --- Processing Sammy --- Sammy is eating... Sammy is swimming! 🐠 --- Processing Donald --- Donald is eating... Donald the duck is flying gracefully Donald the duck is paddling in water Donald says: Quack! Quack! Donald the duck is flying gracefully Donald the duck is paddling in water 6. BENEFITS OF instanceof OPERATOR: ✅ Runtime Type Checking: Determine actual type at runtime ✅ Safe Casting: Avoid ClassCastException ✅ Polymorphic Behavior: Different actions based on type ✅ Interface Implementation Checks: Verify capability
Example 2: Real-World Payment System
import java.time.LocalDateTime; import java.util.ArrayList; import java.util.List; // 🎯 PAYMENT INTERFACE interface Payment { void processPayment(double amount); String getPaymentId(); boolean isSuccessful(); LocalDateTime getTimestamp(); } // 🎯 CREDIT CARD PAYMENT class CreditCardPayment implements Payment { private String paymentId; private String cardNumber; private String cardHolder; private boolean successful; private LocalDateTime timestamp; public CreditCardPayment(String cardNumber, String cardHolder) { this.paymentId = "CC-" + System.currentTimeMillis(); this.cardNumber = maskCardNumber(cardNumber); this.cardHolder = cardHolder; this.timestamp = LocalDateTime.now(); } private String maskCardNumber(String cardNumber) { return "****-****-****-" + cardNumber.substring(cardNumber.length() - 4); } @Override public void processPayment(double amount) { System.out.println("💳 Processing credit card payment of $" + amount); System.out.println(" Card: " + cardNumber); System.out.println(" Holder: " + cardHolder); // Simulate processing this.successful = Math.random() > 0.1; // 90% success rate if (successful) { System.out.println(" ✅ Payment successful!"); } else { System.out.println(" ❌ Payment declined!"); } } @Override public String getPaymentId() { return paymentId; } @Override public boolean isSuccessful() { return successful; } @Override public LocalDateTime getTimestamp() { return timestamp; } // 🎯 CREDIT CARD SPECIFIC METHOD public void refundToCard() { System.out.println("💳 Refunding to credit card: " + cardNumber); } } // 🎯 PAYPAL PAYMENT class PayPalPayment implements Payment { private String paymentId; private String email; private boolean successful; private LocalDateTime timestamp; public PayPalPayment(String email) { this.paymentId = "PP-" + System.currentTimeMillis(); this.email = email; this.timestamp = LocalDateTime.now(); } @Override public void processPayment(double amount) { System.out.println("📧 Processing PayPal payment of $" + amount); System.out.println(" Email: " + email); // Simulate processing this.successful = Math.random() > 0.05; // 95% success rate if (successful) { System.out.println(" ✅ Payment successful!"); } else { System.out.println(" ❌ Payment failed!"); } } @Override public String getPaymentId() { return paymentId; } @Override public boolean isSuccessful() { return successful; } @Override public LocalDateTime getTimestamp() { return timestamp; } // 🎯 PAYPAL SPECIFIC METHOD public void sendPaymentConfirmation() { System.out.println("📧 Sending confirmation email to: " + email); } } // 🎯 CRYPTOCURRENCY PAYMENT class CryptoPayment implements Payment { private String paymentId; private String walletAddress; private String cryptocurrency; private boolean successful; private LocalDateTime timestamp; public CryptoPayment(String walletAddress, String cryptocurrency) { this.paymentId = "CRYPTO-" + System.currentTimeMillis(); this.walletAddress = maskWalletAddress(walletAddress); this.cryptocurrency = cryptocurrency; this.timestamp = LocalDateTime.now(); } private String maskWalletAddress(String address) { return address.substring(0, 8) + "..." + address.substring(address.length() - 8); } @Override public void processPayment(double amount) { System.out.println("₿ Processing " + cryptocurrency + " payment of $" + amount); System.out.println(" Wallet: " + walletAddress); // Simulate processing this.successful = Math.random() > 0.2; // 80% success rate if (successful) { System.out.println(" ✅ Payment confirmed on blockchain!"); } else { System.out.println(" ❌ Transaction failed!"); } } @Override public String getPaymentId() { return paymentId; } @Override public boolean isSuccessful() { return successful; } @Override public LocalDateTime getTimestamp() { return timestamp; } // 🎯 CRYPTO SPECIFIC METHOD public void confirmBlockchainTransaction() { System.out.println("₿ Confirming transaction on " + cryptocurrency + " blockchain..."); } } // 🎯 BANK TRANSFER PAYMENT class BankTransferPayment implements Payment { private String paymentId; private String accountNumber; private String bankName; private boolean successful; private LocalDateTime timestamp; public BankTransferPayment(String accountNumber, String bankName) { this.paymentId = "BANK-" + System.currentTimeMillis(); this.accountNumber = maskAccountNumber(accountNumber); this.bankName = bankName; this.timestamp = LocalDateTime.now(); } private String maskAccountNumber(String accountNumber) { return "***" + accountNumber.substring(accountNumber.length() - 4); } @Override public void processPayment(double amount) { System.out.println("🏦 Processing bank transfer of $" + amount); System.out.println(" Bank: " + bankName); System.out.println(" Account: " + accountNumber); // Simulate processing this.successful = Math.random() > 0.02; // 98% success rate if (successful) { System.out.println(" ✅ Transfer initiated!"); } else { System.out.println(" ❌ Transfer failed!"); } } @Override public String getPaymentId() { return paymentId; } @Override public boolean isSuccessful() { return successful; } @Override public LocalDateTime getTimestamp() { return timestamp; } // 🎯 BANK TRANSFER SPECIFIC METHOD public void generateBankStatement() { System.out.println("🏦 Generating bank statement for account: " + accountNumber); } } // 🎯 PAYMENT PROCESSOR class PaymentProcessor { private List<Payment> paymentHistory; public PaymentProcessor() { this.paymentHistory = new ArrayList<>(); } public void processPayment(Payment payment, double amount) { System.out.println("\n" + "=".repeat(50)); System.out.println("🔄 PROCESSING PAYMENT: " + payment.getPaymentId()); payment.processPayment(amount); paymentHistory.add(payment); // 🎯 POST-PROCESSING BASED ON PAYMENT TYPE handlePostProcessing(payment); System.out.println("=".repeat(50)); } // 🎯 USING instanceof FOR TYPE-SPECIFIC PROCESSING private void handlePostProcessing(Payment payment) { System.out.println("\n📋 POST-PROCESSING:"); if (payment instanceof CreditCardPayment) { CreditCardPayment ccPayment = (CreditCardPayment) payment; if (ccPayment.isSuccessful()) { System.out.println(" 💳 Credit card payment completed"); } else { System.out.println(" 💳 Credit card payment failed - notifying card holder"); } } else if (payment instanceof PayPalPayment) { PayPalPayment ppPayment = (PayPalPayment) payment; if (ppPayment.isSuccessful()) { ppPayment.sendPaymentConfirmation(); } else { System.out.println(" 📧 PayPal payment failed - check email for details"); } } else if (payment instanceof CryptoPayment) { CryptoPayment cryptoPayment = (CryptoPayment) payment; if (cryptoPayment.isSuccessful()) { cryptoPayment.confirmBlockchainTransaction(); System.out.println(" ₿ Crypto payment confirmed - irreversible"); } else { System.out.println(" ₿ Crypto transaction failed - may take time to refund"); } } else if (payment instanceof BankTransferPayment) { BankTransferPayment bankPayment = (BankTransferPayment) payment; if (bankPayment.isSuccessful()) { bankPayment.generateBankStatement(); System.out.println(" 🏦 Bank transfer initiated - may take 1-3 business days"); } else { System.out.println(" 🏦 Bank transfer failed - insufficient funds or invalid account"); } } else { System.out.println(" ℹ️ Unknown payment type"); } } public void generatePaymentReport() { System.out.println("\n📊 PAYMENT PROCESSING REPORT"); System.out.println("=".repeat(40)); int total = paymentHistory.size(); int successful = 0; // 🎯 COUNT BY PAYMENT TYPE USING instanceof int creditCardCount = 0; int paypalCount = 0; int cryptoCount = 0; int bankCount = 0; for (Payment payment : paymentHistory) { if (payment.isSuccessful()) { successful++; } if (payment instanceof CreditCardPayment) { creditCardCount++; } else if (payment instanceof PayPalPayment) { paypalCount++; } else if (payment instanceof CryptoPayment) { cryptoCount++; } else if (payment instanceof BankTransferPayment) { bankCount++; } } System.out.println("Total Payments: " + total); System.out.println("Successful: " + successful); System.out.println("Failed: " + (total - successful)); System.out.println("Success Rate: " + (total > 0 ? (successful * 100 / total) : 0) + "%"); System.out.println("\n--- Breakdown by Payment Method ---"); System.out.println("Credit Cards: " + creditCardCount); System.out.println("PayPal: " + paypalCount); System.out.println("Cryptocurrency: " + cryptoCount); System.out.println("Bank Transfer: " + bankCount); } public void refundPayment(Payment payment) { System.out.println("\n🔄 PROCESSING REFUND: " + payment.getPaymentId()); if (!payment.isSuccessful()) { System.out.println("❌ Cannot refund failed payment"); return; } // 🎯 TYPE-SPECIFIC REFUND PROCESSING if (payment instanceof CreditCardPayment) { CreditCardPayment ccPayment = (CreditCardPayment) payment; ccPayment.refundToCard(); System.out.println("💳 Refund processed to credit card"); } else if (payment instanceof PayPalPayment) { PayPalPayment ppPayment = (PayPalPayment) payment; ppPayment.sendPaymentConfirmation(); System.out.println("📧 Refund processed via PayPal"); } else if (payment instanceof CryptoPayment) { System.out.println("₿ Crypto refunds require manual processing"); System.out.println(" Contact support for assistance"); } else if (payment instanceof BankTransferPayment) { System.out.println("🏦 Bank transfer refund initiated"); System.out.println(" Will be processed in 3-5 business days"); } else { System.out.println("❓ Unknown payment type - cannot process refund"); } } } public class PaymentSystemDemo { public static void main(String[] args) { System.out.println("=== REAL-WORLD PAYMENT SYSTEM WITH instanceof ==="); // 🎯 CREATE PAYMENT PROCESSOR PaymentProcessor processor = new PaymentProcessor(); // 🎯 CREATE DIFFERENT PAYMENT METHODS CreditCardPayment creditCard = new CreditCardPayment("1234567812345678", "John Doe"); PayPalPayment paypal = new PayPalPayment("[email protected]"); CryptoPayment crypto = new CryptoPayment("1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa", "Bitcoin"); BankTransferPayment bankTransfer = new BankTransferPayment("1234567890", "City Bank"); // 🎯 PROCESS PAYMENTS System.out.println("\n1. PROCESSING PAYMENTS:"); processor.processPayment(creditCard, 150.0); processor.processPayment(paypal, 75.50); processor.processPayment(crypto, 200.0); processor.processPayment(bankTransfer, 500.0); // 🎯 GENERATE REPORT processor.generatePaymentReport(); // 🎯 DEMONSTRATE REFUNDS System.out.println("\n2. REFUND DEMONSTRATION:"); Payment[] payments = {creditCard, paypal, crypto, bankTransfer}; for (Payment payment : payments) { if (payment.isSuccessful()) { processor.refundPayment(payment); System.out.println("---"); } } // 🎯 ADVANCED instanceof USAGE System.out.println("\n3. ADVANCED instanceof PATTERNS:"); // 🎯 CHECKING MULTIPLE TYPES Object[] objects = { creditCard, paypal, crypto, bankTransfer, "This is a string", 42, new ArrayList<>() }; for (Object obj : objects) { System.out.print("\n" + obj.getClass().getSimpleName() + ": "); if (obj instanceof Payment) { Payment p = (Payment) obj; System.out.print("Payment ID: " + p.getPaymentId()); // 🎯 COMBINED CHECKS if (obj instanceof CreditCardPayment && p.isSuccessful()) { System.out.print(" (Successful Credit Card)"); } } else if (obj instanceof String) { System.out.print("String: " + obj); } else if (obj instanceof Integer) { System.out.print("Integer: " + obj); } else if (obj instanceof List) { System.out.print("List with " + ((List<?>) obj).size() + " elements"); } else { System.out.print("Unknown type"); } } System.out.println("\n\n4. BENEFITS IN PAYMENT SYSTEMS:"); System.out.println("✅ Type-Specific Processing: Different logic for each payment method"); System.out.println("✅ Safe Casting: Avoid ClassCastException in financial operations"); System.out.println("✅ Flexible Extensibility: Easy to add new payment methods"); System.out.println("✅ Runtime Decisions: Process based on actual payment type"); System.out.println("✅ Error Handling: Specific error messages for each type"); } } Output:
=== REAL-WORLD PAYMENT SYSTEM WITH instanceof === 1. PROCESSING PAYMENTS: ================================================== 🔄 PROCESSING PAYMENT: CC-1701234567890 💳 Processing credit card payment of $150.0 Card: ****-****-****-5678 Holder: John Doe ✅ Payment successful! 📋 POST-PROCESSING: 💳 Credit card payment completed ================================================== ================================================== 🔄 PROCESSING PAYMENT: PP-1701234567891 📧 Processing PayPal payment of $75.5 Email: [email protected] ✅ Payment successful! 📋 POST-PROCESSING: 📧 Sending confirmation email to: [email protected] ================================================== ================================================== 🔄 PROCESSING PAYMENT: CRYPTO-1701234567892 ₿ Processing Bitcoin payment of $200.0 Wallet: 1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa ✅ Payment confirmed on blockchain! 📋 POST-PROCESSING: ₿ Confirming transaction on Bitcoin blockchain... ₿ Crypto payment confirmed - irreversible ================================================== ================================================== 🔄 PROCESSING PAYMENT: BANK-1701234567893 🏦 Processing bank transfer of $500.0 Bank: City Bank Account: ***7890 ✅ Transfer initiated! 📋 POST-PROCESSING: 🏦 Generating bank statement for account: ***7890 🏦 Bank transfer initiated - may take 1-3 business days ================================================== 📊 PAYMENT PROCESSING REPORT ======================================== Total Payments: 4 Successful: 4 Failed: 0 Success Rate: 100% --- Breakdown by Payment Method --- Credit Cards: 1 PayPal: 1 Cryptocurrency: 1 Bank Transfer: 1 2. REFUND DEMONSTRATION: 🔄 PROCESSING REFUND: CC-1701234567890 💳 Refunding to credit card: ****-****-****-5678 💳 Refund processed to credit card --- 🔄 PROCESSING REFUND: PP-1701234567891 📧 Sending confirmation email to: [email protected] 📧 Refund processed via PayPal --- 🔄 PROCESSING REFUND: CRYPTO-1701234567892 ₿ Crypto refunds require manual processing Contact support for assistance --- 🔄 PROCESSING REFUND: BANK-1701234567893 🏦 Bank transfer refund initiated Will be processed in 3-5 business days --- 3. ADVANCED instanceof PATTERNS: CreditCardPayment: Payment ID: CC-1701234567890 (Successful Credit Card) PayPalPayment: Payment ID: PP-1701234567891 CryptoPayment: Payment ID: CRYPTO-1701234567892 BankTransferPayment: Payment ID: BANK-1701234567893 String: String: This is a string Integer: Integer: 42 ArrayList: List with 0 elements 4. BENEFITS IN PAYMENT SYSTEMS: ✅ Type-Specific Processing: Different logic for each payment method ✅ Safe Casting: Avoid ClassCastException in financial operations ✅ Flexible Extensibility: Easy to add new payment methods ✅ Runtime Decisions: Process based on actual payment type ✅ Error Handling: Specific error messages for each type
Example 3: Advanced Patterns and Java 14+ Features
```java
import java.util.*;
// 🎯 SHAPE HIERARCHY
interface Shape {
double area();
double perimeter();
String getName();
}
class Circle implements Shape {
private double radius;
public Circle(double radius) { this.radius = radius; } @Override public double area() { return Math.PI * radius * radius; } @Override public double perimeter() { return 2 * Math.PI * radius; } @Override public String getName() { return "Circle"; } public double getRadius() { return radius; } }
class Rectangle implements Shape {
private double width;
private double height;
public Rectangle(double width, double height) { this.width = width; this.height = height; } @Override public double area() { return width * height; } @Override public double perimeter() { return 2 * (width + height); } @Override public String getName() { return "Rectangle"; } public double getWidth() { return width; } public double getHeight() { return height; } public boolean isSquare() { return width == height; } }
class Triangle implements Shape {
private double side1;
private double side2;
private double side3;
public Triangle(double side1, double side2, double side3) { this.side1 = side1; this.side2 = side2; this.side3 = side3; } @Override public double area() { // Heron's formula double s = perimeter() / 2; return Math.sqrt(s * (s - side1) * (s - side2) * (s - side3)); } @Override public double perimeter() { return side1 + side2 + side3; } @Override public String getName() { return "Triangle"; } public boolean isEquilateral() { return side1 == side2 && side2 == side3; } public boolean isRightAngled() { double[] sides = {side1, side2, side3}; Arrays.sort(sides); return Math.abs((sides[0] * sides[0] + sides[1] * sides[1]) - (sides[2] * sides[2])) < 0.0001; } }
// 🎯 3D SHAPES
interface ThreeDimensional {
double volume();
double surfaceArea();
}
class Sphere extends Circle implements ThreeDimensional {
public Sphere(double radius) {
super(radius);
}
@Override public double volume() { return (4.0 / 3.0) * Math.PI * Math.pow(getRadius(), 3); } @Override public double surfaceArea() { return 4 * Math.PI * Math.pow(getRadius(), 2); } @Override public String getName() { return "Sphere"; } }
class Cube extends Rectangle implements ThreeDimensional {
public Cube(double side) {
super(side, side);
}
@Override public double volume() { return Math.pow(getWidth(), 3); } @Override public double surfaceArea() { return 6 * Math.pow(getWidth(), 2); } @Override public String getName() { return "Cube"; } @Override public double area() { return surfaceArea(); // For 3D shapes, area means surface area } @Override public double perimeter() { return 12 * getWidth(); // Sum of all edges } }
public class AdvancedInstanceOfPatterns {
public static void main(String[] args) {
System.out.println("=== ADVANCED instanceof PATTERNS ===");
// 🎯 CREATE SHAPES List<Object> shapes = Arrays.asList( new Circle(5.0), new Rectangle(4.0, 6.0), new Triangle(3.0, 4.0, 5.0), new Sphere(3.0), new Cube(4.0), "This is a string", 42, new ArrayList<String>() ); // 🎯 TRADITIONAL instanceof WITH CASTING System.out.println("\n1. TRADITIONAL instanceof PATTERN:"); for (Object obj : shapes) { if (obj instanceof Shape) { Shape shape = (Shape) obj; System.out.printf("%s: Area=%.2f, Perimeter=%.2f%n", shape.getName(), shape.area(), shape.perimeter()); // 🎯 ADDITIONAL TYPE-SPECIFIC CHECKS if (obj instanceof Circle && !(obj instanceof Sphere)) { Circle circle = (Circle) obj; System.out.println(" ↳ Radius: " + circle.getRadius()); } else if (obj instanceof Rectangle && !(obj instanceof Cube)) { Rectangle rect = (Rectangle) obj; System.out.println(" ↳ " + (rect.isSquare() ? "Square" : "Rectangle") + " " + rect.getWidth() + "x" + rect.getHeight()); } else if (obj instanceof Triangle) { Triangle triangle = (Triangle) obj; System.out.println(" ↳ " + (triangle.isEquilateral() ? "Equilateral" : triangle.isRightAngled() ? "Right-angled" : "Scalene") + " triangle"); } } } // 🎯 JAVA 14+ PATTERN MATCHING FOR instanceof System.out.println("\n2. JAVA 14+ PATTERN MATCHING (SIMULATED):"); for (Object obj : shapes) { // 🎯 PATTERN: obj instanceof Type variable if (obj instanceof Shape shape) { System.out.printf("📐 %s: Area=%.2f%n", shape.getName(), shape.area()); // 🎯 NESTED PATTERN MATCHING if (shape instanceof Circle circle && !(shape instanceof Sphere)) { System.out.println(" ⭕ Circle with radius: " + circle.getRadius()); } else if (shape instanceof Rectangle rect && !(shape instanceof Cube)) { System.out.println(" ▭ Rectangle " + rect.getWidth() + "x" + rect.getHeight()); } else if (shape instanceof Triangle triangle) { System.out.println(" △ Triangle with sides: " + triangle.perimeter()); } } } // 🎯 3D SHAPES PROCESSING System.out.println("\n3. 3D SHAPES PROCESSING:"); for (Object obj : shapes) { if (obj instanceof ThreeDimensional threeD) { System.out.printf("🧊 %s: Volume=%.2f, Surface Area=%.2f%n", ((Shape) obj).getName(), threeD.volume(), threeD.surfaceArea()); } } // 🎯 COMBINED CHECKS System.out.println("\n4. COMBINED TYPE CHECKS:"); for (Object obj : shapes) { System.out.print(obj.getClass().getSimpleName() + ": "); if (obj instanceof Shape && obj instanceof ThreeDimensional) { System.out.print("3D Shape"); } else if (obj instanceof Shape) { System.out.print("2D Shape"); } else if (obj instanceof String) { System.out.print("String"); } else if (obj instanceof Number) { System.out.print("Number"); } else if (obj instanceof Collection) { System.out.print("Collection"); } else { System.out.print("Unknown"); } System.out.println(); } // 🎯 NULL SAFETY WITH instanceof System.out.println("\n5. NULL SAFETY:"); Object nullObj = null; Object stringObj = "Hello"; Object numberObj = 123; System.out.println("nullObj instanceof String: " + (nullObj instanceof String)); System.out.println("stringObj instanceof String: " + (stringObj instanceof String)); System.out.println("numberObj instanceof Number: " + (numberObj instanceof Number)); System.out.println("numberObj instanceof Integer: " + (numberObj instanceof Integer)); // 🎯 COMPLEX CONDITIONS System.out.println("\n6. COMPLEX instanceof CONDITIONS:"); for (Object obj : shapes) { boolean isShape = obj instanceof Shape; boolean is3D = obj instanceof ThreeDimensional; boolean isCircleFamily = obj instanceof Circle; boolean isRectangleFamily = obj instanceof Rectangle; if (isShape) { String type = "2D Shape"; if (is3D) type = "3D Shape"; if (isCircleFamily) type += " (Circle Family)"; if (isRectangleFamily) type += " (Rectangle Family)"; System.out.println(((Shape) obj).getName() + " → " + type); } } // 🎯 PERFORMANCE CONSIDERATIONS System.out.println("\n7. instanceof PERFORMANCE TIPS:"); System.out.println("✅ Check most specific type first"); System.out.println("✅ Use else-if for mutually exclusive types"); System.out.println("✅ Consider polymorphism over instanceof when possible"); System.out.println("✅ Use pattern matching (Java 14+) for cleaner code"); // 🎯 ALTERNATIVES TO instanceof System.out.println("\n8. ALTERNATIVES TO instanceof:"); System.out.println("🔹 Polymorphism: Override methods in subclasses"); System.out.println("🔹 Visitor Pattern: Separate algorithm from object structure"); System.out.println("🔹 Strategy Pattern: Different behaviors via composition"); System.out.println("🔹 Factory Pattern: Type-specific object creation"); } // 🎯 UTILITY METHOD DEMONSTRATING instanceof BEST PRACTICES public static void processShape(Shape shape) { // 🎯 MOST SPECIFIC CHECKS FIRST if (shape instanceof Sphere sphere) { System.out.println("Processing Sphere with volume: " + sphere.volume()); } else if (shape instanceof Cube cube) { System.out.println("Processing Cube with volume: " + cube.volume()); } else if (shape instanceof Circle circle) { System.out.println("Processing Circle with radius: " + circle.getRadius()); } else if (shape instanceof Rectangle rectangle) { System.out.println("Processing Rectangle: " + rectangle.getWidth() + "x" + rectangle