BÀI 10: KẾ THỪA VÀ ĐA HÌNH TRONG C#

/* 
 * ============================================================
 * NẠP CHỒNG PHƯƠNG THỨC (METHOD OVERLOADING)
 * ============================================================
 * 
 * ĐỊNH NGHĨA:
 * - Nhiều phương thức có CÙNG TÊN trong cùng một lớp
 * - Nhưng KHÁC NHAU về danh sách tham số
 * 
 * ĐIỀU KIỆN NẠP CHỒNG:
 * 1. Khác số lượng tham số
 * 2. Khác kiểu dữ liệu của tham số
 * 3. Khác thứ tự các kiểu tham số
 * 
 * LƯU Ý QUAN TRỌNG:
 * - Không thể nạp chồng chỉ dựa trên kiểu trả về (return type)
 * - Không thể nạp chồng chỉ dựa trên tham số ref/out
 * - Nạp chồng xảy ra tại thời điểm biên dịch (compile-time polymorphism)
 */
public class Calculator
{
    // ========================================================
    // 1. Nạp chồng dựa trên KIỂU DỮ LIỆU của tham số
    // ========================================================
    
    /* Phương thức Add với 2 tham số int
     * - Dùng cho phép cộng số nguyên
     * - Kiểu trả về: int
     */
    public int Add(int a, int b) => a + b;
    
    /* Phương thức Add với 2 tham số double
     * - Dùng cho phép cộng số thực
     * - Kiểu trả về: double
     * - KHÁC với phương thức trên ở kiểu dữ liệu tham số (int vs double)
     */
    public double Add(double a, double b) => a + b;
    
    // ========================================================
    // 2. Nạp chồng dựa trên SỐ LƯỢNG tham số
    // ========================================================
    
    /* Phương thức Add với 3 tham số int
     * - Dùng để cộng 3 số nguyên
     * - KHÁC với phương thức Add(int a, int b) ở số lượng tham số (2 vs 3)
     */
    public int Add(int a, int b, int c) => a + b + c;
    
    // ========================================================
    // 3. Nạp chồng dựa trên KIỂU DỮ LIỆU khác (string)
    // ========================================================
    
    /* Phương thức Add với 2 tham số string
     * - Dùng để nối chuỗi (concatenation)
     * - KHÁC với các phương thức trên ở kiểu dữ liệu tham số (string)
     * - Lưu ý: đây là phép nối chuỗi, không phải cộng số học
     */
    public string Add(string a, string b) => a + b;
    
    // ========================================================
    // CÁC VÍ DỤ BỔ SUNG (Comment để tham khảo)
    // ========================================================
    
    /* Có thể nạp chồng với tham số có giá trị mặc định
     * public int Add(int a, int b, int c = 0) => a + b + c;
     * Tuy nhiên sẽ gây mơ hồ với Add(int a, int b) 
     * nên C# sẽ báo lỗi
     */
    
    /* KHÔNG THỂ nạp chồng chỉ khác kiểu trả về
     * public int Add(int a, int b) => a + b;
     * public double Add(int a, int b) => (double)(a + b); // ❌ LỖI
     * Vì C# không phân biệt được phương thức nào được gọi
     */
    
    /* Có thể nạp chồng với tham số params
     * public int Add(params int[] numbers) => numbers.Sum();
     * public int Add(int a, int b) => a + b; // ✅ HỢP LỆ
     */
}

// ============================================================
// LỚP PROGRAM ĐỂ MINH HỌA CÁCH SỬ DỤNG
// ============================================================
class Program
{
    static void Main()
    {
        Calculator calc = new Calculator();
        
        // ====================================================
        // VÍ DỤ SỬ DỤNG CÁC PHƯƠNG THỨC ĐÃ NẠP CHỒNG
        // ====================================================
        
        // 1. Gọi phương thức Add(int, int)
        int ketQua1 = calc.Add(5, 10);
        Console.WriteLine($"5 + 10 = {ketQua1}");        // Output: 15
        
        // 2. Gọi phương thức Add(double, double)
        double ketQua2 = calc.Add(5.5, 10.2);
        Console.WriteLine($"5.5 + 10.2 = {ketQua2}");    // Output: 15.7
        
        // 3. Gọi phương thức Add(int, int, int)
        int ketQua3 = calc.Add(5, 10, 15);
        Console.WriteLine($"5 + 10 + 15 = {ketQua3}");   // Output: 30
        
        // 4. Gọi phương thức Add(string, string)
        string ketQua4 = calc.Add("Hello ", "World");
        Console.WriteLine(ketQua4);                       // Output: Hello World
        
        // ====================================================
        // CÁCH TRÌNH BIÊN DỊCH QUYẾT ĐỊNH GỌI PHƯƠNG THỨC NÀO
        // ====================================================
        // 1. Dựa vào SỐ LƯỢNG tham số truyền vào
        // 2. Dựa vào KIỂU DỮ LIỆU của tham số truyền vào
        // 3. Ưu tiên phương thức có kiểu khớp chính xác nhất
        // 4. Nếu có nhiều phương thức phù hợp → LỖI (ambiguous)
        
        // Ví dụ gây lỗi nếu có 2 phương thức mơ hồ:
        // calc.Add(5, 5); // Nếu có cả int và double, sẽ gọi int (khớp chính xác hơn)
    }
}

// ============================================================
// SO SÁNH NẠP CHỒNG VỚI CÁC KHÁI NIỆM KHÁC
// ============================================================
/* 
 * NẠP CHỒNG (Overloading)         vs    GHI ĐÈ (Overriding)
 * --------------------------------------------------------------
 * Xảy ra trong cùng lớp                  Xảy ra giữa lớp cha - lớp con
 * Thời điểm biên dịch                    Thời điểm chạy
 * Không dùng từ khóa override            Dùng từ khóa override
 * Không liên quan đến kế thừa            Phụ thuộc vào kế thừa
 * Cùng tên, khác tham số                 Cùng tên, cùng tham số
 */

// ============================================================
// LỢI ÍCH CỦA NẠP CHỒNG PHƯƠNG THỨC
// ============================================================
/* 
 * 1. Tăng TÍNH NHẤT QUÁN: Cùng tên phương thức cho các thao tác tương tự
 * 2. Tăng KHẢ NĂNG ĐỌC: Dễ hiểu, dễ nhớ
 * 3. LINH HOẠT: Có thể gọi cùng phương thức với nhiều kiểu dữ liệu khác nhau
 * 4. TÁI SỬ DỤNG: Mở rộng chức năng mà không cần đặt tên mới
 * 5. GỌN GÀNG: Giảm số lượng tên phương thức trong lớp
 */