C# - Thừa kế: Hướng dẫn chi tiết cho người mới bắt đầu

Xin chào các bạn đang học lập trình! Hôm nay, chúng ta sẽ bắt đầu một hành trình thú vị vào thế giới thừa kế trong C#. Đừng lo lắng nếu bạn mới bắt đầu học lập trình - tôi sẽ là người hướng dẫn thân thiện của bạn, và chúng ta sẽ cùng nhau khám phá khái niệm này từng bước một. Cuối cùng của bài hướng dẫn này, bạn sẽ có được một cái nhìn vững chắc về thừa kế và cách nó có thể làm cho mã của bạn hiệu quả và tổ chức hơn.

Thừa kế là gì?

Trước khi chúng ta đi vào chi tiết, hãy bắt đầu với một ví dụ đơn giản. Hãy tưởng tượng bạn đang tạo một cây gia đình. Mỗi người trong cây đó kế thừa một số đặc điểm từ bố mẹ của họ, phải không? Thừa kế trong lập trình hoạt động theo cách tương tự!

Trong C#, thừa kế là một cơ chế cho phép một lớp mới được dựa trên một lớp đã.exists. Lớp mới kế thừa các thuộc tính và phương thức của lớp đã.exists, giống như bạn có thể kế thừa màu mắt hoặc chiều cao của bố mẹ.

Lớp cơ bản và lớp dẫn xuất

Trong thế giới thừa kế, chúng ta có hai nhân vật chính:

1. Lớp cơ bản (còn gọi là Lớp cha hoặc Lớp siêu): Đây là lớp gốc chứa các thuộc tính và phương thức chung.
2. Lớp dẫn xuất (còn gọi là Lớp con hoặc Lớp con): Đây là lớp mới kế thừa từ lớp cơ bản.

Hãy xem một ví dụ đơn giản:

// Lớp cơ bản
public class Animal
{
public string Name { get; set; }
public int Age { get; set; }

public void Eat()
{
Console.WriteLine($"{Name} đang ăn.");
}
}

// Lớp dẫn xuất
public class Dog : Animal
{
public void Bark()
{
Console.WriteLine($"{Name} nói Woof!");
}
}

Trong ví dụ này, Animal là lớp cơ bản của chúng ta, và Dog là lớp dẫn xuất. Phần : Animal trong khai báo lớp Dog là cách chúng ta告诉 C# rằng Dog kế thừa từ Animal.

Bây giờ, hãy xem cách chúng ta có thể sử dụng các lớp này:

Dog myDog = new Dog();
myDog.Name = "Buddy";
myDog.Age = 3;

myDog.Eat();  // Kế thừa từ Animal
myDog.Bark(); // Định nghĩa trong Dog

Khi chúng ta chạy đoạn mã này, chúng ta sẽ thấy:

Buddy đang ăn.
Buddy nói Woof!

Đó có phải là thú vị không? Lớp Dog của chúng ta có quyền truy cập vào các thuộc tính Name và Age, và phương thức Eat() từ lớp Animal, mà không cần chúng ta phải viết lại toàn bộ mã!

Khởi tạo lớp cơ bản

Bây giờ, bạn có thể đang tự hỏi, "Nếu tôi muốn đặt một số giá trị mặc định cho lớp cơ bản khi tôi tạo một đối tượng lớp dẫn xuất?" Câu hỏi tuyệt vời! Đây là nơi các constructor vào cuộc.

Hãy thay đổi ví dụ của chúng ta:

public class Animal
{
public string Name { get; set; }
public int Age { get; set; }

public Animal(string name, int age)
{
Name = name;
Age = age;
}

public void Eat()
{
Console.WriteLine($"{Name} đang ăn.");
}
}

public class Dog : Animal
{
public Dog(string name, int age) : base(name, age)
{
// Khởi tạo bổ sung cho Dog, nếu cần
}

public void Bark()
{
Console.WriteLine($"{Name} nói Woof!");
}
}

Trong phiên bản cập nhật này, chúng ta đã thêm một constructor vào lớp Animal. Constructor của lớp Dog sử dụng cú pháp : base(name, age) để gọi constructor của lớp cơ bản và truyền các tham số name và age.

Bây giờ chúng ta có thể tạo một đối tượng Dog như này:

Dog myDog = new Dog("Buddy", 3);
myDog.Eat();
myDog.Bark();

Điều này sẽ tạo ra cùng một đầu ra như trước, nhưng.now chúng ta đang khởi tạo các thuộc tính Name và Age ngay khi tạo đối tượng Dog.

Thừa kế đa cấp trong C

Bây giờ, hãy xem một tình huống thú vị: khác với một số ngôn ngữ lập trình khác, C# không hỗ trợ thừa kế đa cấp cho các lớp. Điều này có nghĩa là một lớp không thể kế thừa trực tiếp từ hơn một lớp cơ bản.

Nhưng đừng lo lắng! C# có một giải pháp thay thế thông minh bằng cách sử dụng các interface. Một interface giống như một hợp đồng xác định một lớp nên làm gì, mà không xác định cách nó làm.

Hãy xem một ví dụ:

public interface ISwimmable
{
void Swim();
}

public interface IFlyable
{
void Fly();
}

public class Bird : Animal, IFlyable
{
public Bird(string name, int age) : base(name, age) { }

public void Fly()
{
Console.WriteLine($"{Name} đang bay.");
}
}

public class Fish : Animal, ISwimmable
{
public Fish(string name, int age) : base(name, age) { }

public void Swim()
{
Console.WriteLine($"{Name} đang bơi.");
}
}

public class Duck : Animal, ISwimmable, IFlyable
{
public Duck(string name, int age) : base(name, age) { }

public void Swim()
{
Console.WriteLine($"{Name} đang bơi.");
}

public void Fly()
{
Console.WriteLine($"{Name} đang bay.");
}
}

Trong ví dụ này, chúng ta đã tạo hai interface: ISwimmable và IFlyable. Lớp Bird kế thừa từ Animal và triển khai IFlyable. Lớp Fish kế thừa từ Animal và triển khai ISwimmable. Và nhìn vào lớp Duck của chúng ta - nó kế thừa từ Animal và triển khai cả ISwimmable và IFlyable!

Hãy sử dụng các lớp này:

Bird myBird = new Bird("Tweety", 2);
myBird.Fly();

Fish myFish = new Fish("Nemo", 1);
myFish.Swim();

Duck myDuck = new Duck("Donald", 5);
myDuck.Swim();
myDuck.Fly();

Điều này sẽ đầu ra:

Tweety đang bay.
Nemo đang bơi.
Donald đang bơi.
Donald đang bay.

Đó có phải là tuyệt vời không? Lớp Duck của chúng ta có thể cả bơi và bay, mặc dù C# không hỗ trợ thừa kế đa cấp cho các lớp!

Bảng phương thức

Dưới đây là bảng tóm tắt các phương thức chúng ta đã sử dụng trong các ví dụ:

Lớp/Interface	Phương thức	Mô tả
Animal	Eat()	In ra thông báo rằng động vật đang ăn
Dog	Bark()	In ra thông báo rằng chó đang sủa
ISwimmable	Swim()	Định nghĩa phương thức bơi
IFlyable	Fly()	Định nghĩa phương thức bay
Bird	Fly()	Triển khai phương thức Bay
Fish	Swim()	Triển khai phương thức Bơi
Duck	Swim(), Fly()	Triển khai cả phương thức Bơi và Bay

Và thế là xong! Chúng ta đã bao gồm các khái niệm cơ bản về thừa kế trong C#, từ các lớp cơ bản và dẫn xuất đơn giản đến các tình huống phức tạp hơn sử dụng các interface. Nhớ rằng, thừa kế là tất cả về tái sử dụng mã và tạo ra các mối quan hệ logic giữa các lớp. Nó là một công cụ mạnh mẽ có thể làm cho mã của bạn hiệu quả và dễ bảo trì hơn.

Khi bạn tiếp tục hành trình lập trình của mình, bạn sẽ tìm thấy nhiều cách khác để sử dụng thừa kế để giải quyết các vấn đề phức tạp. Hãy tiếp tục thực hành và đừng ngại thử nghiệm với các khái niệm này. Chúc các bạn lập trình vui vẻ!

Credits: Image by storyset