ការទទួលមរតក (Inheritance)

Inheritance (ការទទួលមរតក) ក្នុង Java

🧬 Inheritance គឺជាអ្វី?

Inheritance គឺជា mechanism ដែល class មួយអាចទទួល (inherit) properties និង methods ពី class មួយទៀត។

ឧទាហរណ៍ក្នុងជីវិតពិត:

• កូន ទទួលមរតកពី ឪពុកម្តាយ: ពណ៌សក់, ពណ៌ភ្នែក, កម្ពស់
• រថយន្ត ទទួលពី យានយន្ត: engine, wheels, steering
• សត្វឆ្កែ ទទួលពី សត្វ: ស៊ី, ដេក, ដើរ

📚 ហេតុអ្វីត្រូវការ Inheritance?

1. Code Reusability: ប្រើកូដពី parent class ម្តងទៀត
2. កាត់បន្ថយកូដ: មិនចាំបាច់សរសេរដដែលៗ
3. Method Overriding: អាចកែប្រែ behavior របស់ parent
4. Polymorphism: ជាមូលដ្ឋានសម្រាប់ polymorphism
5. Hierarchical Organization: រៀបចំ classes តាម hierarchy

🔑 ពាក្យគន្លឹះសំខាន់

🏗️ Syntax

// Parent class (Super class)
class Parent {
    // properties និង methods
}

// Child class (Sub class)
class Child extends Parent {
    // inherit ទាំងអស់ពី Parent
    // + properties និង methods ថ្មី
}

🎯 ឧទាហរណ៍មូលដ្ឋាន

// Parent class
class Animal {
    String name;
    
    void eat() {
        System.out.println(name + " is eating");
    }
    
    void sleep() {
        System.out.println(name + " is sleeping");
    }
}

// Child class
class Dog extends Animal {
    void bark() {
        System.out.println(name + " is barking");
    }
}

// ប្រើប្រាស់
Dog myDog = new Dog();
myDog.name = "Bobby";
myDog.eat();    // ទទួលពី Animal
myDog.sleep();  // ទទួលពី Animal
myDog.bark();   // របស់ Dog ផ្ទាល់

📊 ប្រភេទ Inheritance

🔄 Method Overriding & super Keyword

🔄 Method Overriding គឺជាអ្វី?

Method Overriding គឺការកែសម្រួល method របស់ parent classក្នុង child class ដើម្បីផ្តល់ implementation ថ្មី។

📋 ចំណុចសំខាន់សម្រាប់ Overriding:

1. ឈ្មោះដូចគ្នា: Method name ត្រូវដូចគ្នា
2. Parameters ដូចគ្នា: Same parameter list
3. Return type ដូចគ្នា: ឬ subtype (covariant)
4. Access level: មិនអាចតូចជាង parent
5. @Override annotation: (optional but recommended)

✅ Valid Overriding

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

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

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

// ប្រើប្រាស់
Animal myDog = new Dog();
Animal myCat = new Cat();

myDog.makeSound();  // Output: Dog barks: Woof! Woof!
myCat.makeSound();  // Output: Cat meows: Meow! Meow!

🔑 super Keyword

superប្រើដើម្បីចូលប្រើ members របស់ parent class។

3 ការប្រើ super:

1. super.variable - ចូលប្រើ parent's variable
2. super.method() - ហៅ parent's method
3. super() - ហៅ parent's constructor

💡 ឧទាហរណ៍ super

class Vehicle {
    int speed = 50;
    
    void display() {
        System.out.println("This is a vehicle");
    }
}

class Car extends Vehicle {
    int speed = 100;  // hide parent's speed
    
    void showSpeed() {
        System.out.println("Car speed: " + speed);        // 100
        System.out.println("Vehicle speed: " + super.speed);  // 50
    }
    
    @Override
    void display() {
        super.display();  // ហៅ parent's method
        System.out.println("This is a car");
    }
}

// Output:
// This is a vehicle
// This is a car

🏗️ super() Constructor Call

class Person {
    String name;
    int age;
    
    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

class Student extends Person {
    String studentId;
    
    Student(String name, int age, String studentId) {
        super(name, age);  // ហៅ parent constructor
        this.studentId = studentId;
    }
    
    void display() {
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
        System.out.println("ID: " + studentId);
    }
}

⚠️ ចំណុចសំខាន់

• super() ត្រូវនៅ line ទី 1ក្នុង constructor
• ប្រសិនបើគ្មាន super() Java ហៅ parent's default constructor ស្វ័យប្រវត្តិ
• Cannot override: final, static, private methods

🎯 Final Keyword & Access Modifiers

🔒 final Keyword

finalប្រើដើម្បីការពារការផ្លាស់ប្តូរ។

🔐 Access Modifiers in Inheritance

🎯 Real-World Example

// Parent class
class Employee {
    protected String name;
    protected double salary;
    
    public Employee(String name, double salary) {
        this.name = name;
        this.salary = salary;
    }
    
    public void displayInfo() {
        System.out.println("Name: " + name);
        System.out.println("Salary: $" + salary);
    }
    
    public double calculateBonus() {
        return salary * 0.10;  // 10% bonus
    }
}

// Child class 1
class Manager extends Employee {
    private int teamSize;
    
    public Manager(String name, double salary, int teamSize) {
        super(name, salary);
        this.teamSize = teamSize;
    }
    
    @Override
    public double calculateBonus() {
        return salary * 0.20;  // 20% bonus for managers
    }
    
    @Override
    public void displayInfo() {
        super.displayInfo();
        System.out.println("Team Size: " + teamSize);
        System.out.println("Bonus: $" + calculateBonus());
    }
}

// Child class 2
class Developer extends Employee {
    private String programmingLanguage;
    
    public Developer(String name, double salary, String language) {
        super(name, salary);
        this.programmingLanguage = language;
    }
    
    @Override
    public double calculateBonus() {
        return salary * 0.15;  // 15% bonus for developers
    }
    
    @Override
    public void displayInfo() {
        super.displayInfo();
        System.out.println("Language: " + programmingLanguage);
        System.out.println("Bonus: $" + calculateBonus());
    }
}

// ប្រើប្រាស់
Manager m = new Manager("John", 5000, 10);
Developer d = new Developer("Sarah", 4000, "Java");

m.displayInfo();
System.out.println();
d.displayInfo();

💡 Best Practices

• IS-A relationship: ប្រើ inheritance តែនៅពេល IS-A ពិត
• Favor composition: HAS-A ល្អជាង IS-A ក្នុងករណីច្រើន
• @Override: ប្រើជានិច្ច annotation ដើម្បីបញ្ជៀស errors
• protected: ប្រើសម្រាប់ members ដែល subclass ត្រូវការ
• Don't break parent: Overriding មិនត្រូវបំបាក់ parent's behavior
• Avoid deep hierarchies: កុំធ្វើ inheritance chain យូរពេក