ความแตกต่างระหว่าง Compile-time Polymorphism และ Runtime Polymorphism ใน Java

**Polymorphism (พอลิมอร์ฟิซึม)** คือความสามารถในการทำหน้าที่เดียวกันได้หลายรูปแบบ ใน Java มี 2 ประเภทหลัก:

ตารางเปรียบเทียบ

1. Compile-time Polymorphism: Method Overloading

เมธอดชื่อเดียวกัน แต่ **parameter list ต่างกัน** (จำนวน ชนิด หรือลำดับ) Compiler รู้ตอน compile ว่าจะเรียกเมธอดไหน

ตัวอย่าง

public class CompileTimePolymorphism {
    // Overloading: ชื่อเดียวกัน parameter ต่างกัน
    public void display() {
        System.out.println("No parameter");
    }
    
    public void display(String msg) {
        System.out.println("With String: " + msg);
    }
    
    public void display(int num) {
        System.out.println("With int: " + num);
    }
    
    public void display(String msg, int num) {
        System.out.println("String + int: " + msg + " " + num);
    }

    public static void main(String[] args) {
        CompileTimePolymorphism obj = new CompileTimePolymorphism();
        obj.display();                    // เรียก display()
        obj.display("Polymorphism");      // เรียก display(String)
        obj.display(42);                  // เรียก display(int)
        obj.display("Count", 10);         // เรียก display(String, int)
    }
}

Output

No parameter
With String: Polymorphism
With int: 42
String + int: Count 10

2. Runtime Polymorphism: Method Overriding

Subclass **override** เมธอดของ Parent class JVM ตัดสินใจตอน runtime ว่าจะเรียกเมธอดของ class ไหน (ขึ้นกับ object จริง)

ตัวอย่าง

// Parent class
class Animal {
    public void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

// Child class
class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Dog barks: Woof!");
    }
}

class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Cat meows: Meow!");
    }
}

public class RuntimePolymorphism {
    public static void main(String[] args) {
        // Polymorphism: Animal reference ชี้ไป Dog object
        Animal myAnimal = new Dog();
        myAnimal.makeSound(); // Output: Dog barks: Woof!
        
        myAnimal = new Cat();
        myAnimal.makeSound(); // Output: Cat meows: Meow!
        
        // ใช้กับ array/collection
        Animal[] animals = {new Dog(), new Cat(), new Animal()};
        for (Animal a : animals) {
            a.makeSound(); // เรียกเมธอดตาม object จริง
        }
    }
}

Output

Dog barks: Woof!
Cat meows: Meow!
Dog barks: Woof!
Cat meows: Meow!
Animal makes a sound

Overloading vs Overriding - สรุปความแตกต่าง

สรุป

• Overloading = Static polymorphism = Multiple methods, same name, different parameters
• Overriding = Dynamic polymorphism = Child redefines parent's method
• ทั้งคู่เป็นพื้นฐานของ OOP และใช้ร่วมกันในการออกแบบ API ที่ยืดหยุ่น