Tính kế thừa trong C

BỘ GIÁO DỤC VÀ ĐÀO TẠO
TRƯỜNG ĐẠI HỌC KINH TẾ THÀNH PHỐ HỒ CHÍ MINH
MƠN CƠ SỞ LẬP TRÌNH
~~~~~~*~~~~~~

BÀI TIỂU LUẬN
CHƯƠNG 6: TÍNH THỪA KẾ TRONG C#

Sinh viên thực hiện
Mã sinh viên
Lớp
Khóa

:
:
:
:

Nguyễn Thị Như Ngọc
31191026004
EC001
45

TPHCM – 6/2021


TRƯỜNG ĐẠI HỌC KINH TẾ TPHCM – CƠ SỞ LẬP TRÌNH

MỤC LỤC TRANG
I.

QUAN HỆ ĐẶC BIỆT HĨA- TỔNG QT HĨA........................................3

II. TÍNH KẾ THỪA TRONG C#..........................................................................4
1. Định nghĩa.......................................................................................................4
2. Ý nghĩa............................................................................................................4
3. Cú pháp để tạo lớp kế thừa..............................................................................4
III.

VIẾT CHƯƠNG TRÌNH CĨ THỪA KẾ....................................................5

1. Sử dụng từ khóa new.......................................................................................5
2. Sử dụng từ khóa virtual và override..............................................................10
TÀI LIỆU THAM KHẢO.......................................................................................15

2


TRƯỜNG ĐẠI HỌC KINH TẾ TPHCM – CƠ SỞ LẬP TRÌNH

CHƯƠNG 6. TÍNH THỪA KẾ TRONG C#
Trong đời sống thực tế, kế thừa là việc được thừa hưởng những gì của người đi
trước để lại. Ví dụ như ba để lại cho con một mảnh đất, vậy là người con được
thừa kế mảnh đất đó mà khơng cần phải kiếm tiền mua đất hay phải đi tìm mua
đất nữa, giờ chỉ việc xây nhà trên mảnh đất được thừa kế đó. Trong lập trình, tính
kế thừa cũng có những điểm tương tự. Trong chương 6 này, ta sẽ tìm hiểu mối
quan hệ giữa các đối tượng trong thế giới thực và cách thức mơ hình hóa mối quan
hệ này trong mã chương trình dựa trên khái niệm kế thừa.
I. QUAN HỆ ĐẶC BIỆT HÓA- TỔNG QUÁT HÓA
Lớp và các thể hiện của lớp tức đối tượng tuy không tồn tại trong cùng một khối,
nhưng chúng tồn tại trong một mạng lưới có sự phụ thuộc và quan hệ lẫn nhau.

Quan hệ là một (is-a) là một sự đặc biệt hóa. Khi chúng ta nói rằng mèo là một
loại động vật có vú, có nghĩa là chúng ta đã nói rằng mèo là một trường hợp đặc
biệt của loại động vật có vú. Nó có tất cả các đặc tính của bất cứ động vật có vú
nào (như sinh ra con, có sữa mẹ và có lơng…). Tuy nhiên, mèo có thêm các đặc
tính riêng được xác định trong họ nhà mèo mà các họ động vật có vú khác khơng
có được. Tương tự, chó cũng là loại động vật có vú, có tất cả các thuộc tính của
động vật có vú, khơng những vậy nó cịn có thêm các thuộc tính riêng xác định họ
lồi chó mà khác với các thuộc tính đặc biệt của lồi khác.
Quan hệ đặc biệt hóa - tổng quát hóa là hai mối quan hệ đối ngẫu và phân cấp với
nhau.
Chúng có quan hệ đối ngẫu vì được xem như là mặt ngược lại của tổng qt. Do
đó, lồi chó và mèo là trường hợp đặc biệt của động vật có vú. Ngược lại động vật
có vú là trường hợp tổng qt từ các lồi chó và mèo.
Chúng có quan hệ là phân cấp bởi vì chúng tạo ra một cây quan hệ, trong đó các
trường hợp đặc biệt là những nhánh của trường hợp tổng quát. Trong cây phân cấp
này nếu di chuyển lên trên cùng ta sẽ được trường hợp tổng quát hóa, và ngược lại
nếu di chuyển xuống ngược nhánh thì ta được trường hợp đặc biệt hóa. Ta có sơ
đồ phân cấp minh họa cho lồi chó, mèo và động vật có vú như sau:

3


TRƯỜNG ĐẠI HỌC KINH TẾ TPHCM – CƠ SỞ LẬP TRÌNH

Trong C#, quan hệ chun biệt hóa - tổng qt hố được thể hiện thơng qua sự kế
thừa bởi vì thông thường khi hai lớp chia sẻ chức năng, dữ liệu với nhau, ta trích
ra các phần chung đó và đưa vào lớp cơ sở chung để có thể nâng cao khả năng sử
dụng lại các mã nguồn chung, cũng như dễ dàng quản lý mã nguồn.
Ví dụ: Giả sử ta có lớp TuGiac chứa thơng tin toạ độ của 4 điểm A, B, C, D. Ta
biết rằng hình vng là một trường hợp đặc biệt của tứ giác (ngược lại tứ giác là

trường hợp tổng qt của hình vng).
Từ đó ta có thể cho lớp HinhVuong kế thừa lại lớp TuGiac để có thể sử dụng lại
các thơng tin như tọa độ 4 điểm A, B, C, D mà khơng cần phải khai báo.
II. TÍNH KẾ THỪA TRONG C#
1. Định nghĩa
Trong ngơn ngữ C#, quan hệ đặc biệt hóa được thực thi bằng cách sử dụng sự kế
thừa. Đây không phải là cách duy nhất để thực thi đặc biệt hóa, nhưng nó là cách
chung nhất và tự nhiên nhất để thực thi quan hệ này.
Trong mơ hình trước, ta có thể nói Mèo kế thừa từ Động vật có vú thì Động vật có
vú được xem như là lớp cha, và Mèo được xem như là lớp con. Như vậy, Mèo
thừa kế tất cả các thuộc tính và hành động từ lớp Động vật có vú và thêm những
phần đặc biệt riêng để xác nhận là Mèo.
Kế thừa là cơ chế cho phép định nghĩa một lớp mới (còn gọi là lớp dẫn xuất Derived Class) dựa trên một lớp đã có sẵn (cịn gọi là lớp cơ sở - Base Class.).
Lớp dẫn xuất có hầu hết các thành phần giống như lớp cơ sở (bao gồm tất cả các
thuộc tính (dữ liệu) và các phương thức của lớp cơ sở). Nói cách khác, lớp dẫn
xuất sẽ kế thừa hầu hết các thành viên của lớp cơ sở.
2. Ý nghĩa
Kế thừa đem lại nhiều ý nghĩa cho việc lập trình:
- Tính nhất qn: những đối tượng có chung nguồn gốc thì sẽ có những đặc
điểm chung giống nhau.
- Tái sử dụng code: những phần code chung chỉ cần định nghĩa một lần tại lớp
cha (Base Class), các lớp con (Derived Class) đều có thể sử dụng mà khơng
cần viết lại.
- Thuận tiện trong việc bảo trì và phát triển. Khi sửa lỗi hay nâng cấp chỉ cần
định nghĩa lại ở lớp cha.
3. Cú pháp để tạo lớp kế thừa
[<quyen_truy_cap>] class <Ten_lop_cha>
{
...
}

[<quyen_truy_cap>] class <Ten_lop_con> : <Ten_lop_cha>
{
...
4


TRƯỜNG ĐẠI HỌC KINH TẾ TPHCM – CƠ SỞ LẬP TRÌNH

}
<quyen_truy_cap> : là public hay private, protected,…
Có thể có hoặc khơng.
class là từ khố để khai báo lớp.
<Ten_lop_con> là tên lớp dẫn xuất – Derived Class, do
người dùng đặt và tuân theo các quy tắc đặt tên.
<Ten_lop_cha> là tên lớp cơ sở – Base Class , lớp ta
muốn kế thừa các đặc tính của nó.
III. VIẾT CHƯƠNG TRÌNH CĨ THỪA KẾ
1. Sử dụng từ khóa new
Cú pháp của các lớp kế thừa có sử dụng từ khóa new:
class Base1 //lop co so
{
private type data1;
private type data2;
public void Method1()
{ }
public void Method 2()
{ }
}
//-----------------------------------------------------class Derived1: Base1 //lop dan xuat 1
{

private type data3; // du lieu moi cua lop Derived1
public new void Method1 ()
{ }
public new void Method2 ()
{ }
}
//-----------------------------------------------------class Derived2: Base1 //lop dan xuat 2
{
private type data4; // du lieu moi cua lop Derived
public new void Method1 ()
{ }
public new void Method2 ()
{ }
}
Trong cú pháp trên:
5


TRƯỜNG ĐẠI HỌC KINH TẾ TPHCM – CƠ SỞ LẬP TRÌNH

public new void Method1 ().
Từ khóa new trong kế thừa khơng phải là tốn tử dùng để khởi tạo đối tượng, mà
nó là một modifier dùng để xác định phạm vi của phương thức.
Trong trường hợp vì một lý do nào đó, nếu muốn tạo một phương thức ở lớp con
có tên giống với tên của một phương thức ở lớp cha, thì để tránh nhập nhằng giữa
2 phương thứ này, ta cần gắn từ khóa new cho phương thức ở lớp con. Từ khóa
new được sử dụng ở đây để chỉ ra rằng người lập trình đang tạo ra một phiên bản
mới cho phương thức này bên trong lớp con.
Ví dụ 6.1 Hãy viết chương trình có thừa kế cho trò chơi Plants and Zombies để
quản lý các lớp thuộc lớp cơ sở Plants (thực vật): lớp Đậu bắn súng (Peashooter),

lớp Đậu tuyết (SnowPea) và lớp Hoa hướng dương (Sunflower).
using System;
class Plants
{
private int Health;
private int Money;
private string Level;
public Plants()
{
Health = 0;
Money = 0;
Level = "";
}
public void Input()
{
Console.Write("Input Level: ");
Level = Console.ReadLine();
Console.Write("Input Health: ");
Health = Int32.Parse(Console.ReadLine());
Console.Write("Input Money: ");
Money = Int32.Parse(Console.ReadLine());
}
public void Show()
{
Console.WriteLine("Level: " + Level + " |
Health: " + Health + "HP | Money: " + Money + "$");
}
}
class Peashooter : Plants
6

TRƯỜNG ĐẠI HỌC KINH TẾ TPHCM – CƠ SỞ LẬP TRÌNH

{
private string description;
public Peashooter() : base()
{
description = "";
}
public new void Input()
{
base.Input();
Console.Write("Input the description: ");
description = Console.ReadLine();
}
public new void Show()
{
base.Show();
Console.WriteLine("Description:
"
+
description);
}
}
class SnowPea : Plants
{
private string description;
public SnowPea() : base()
{

description = "";
}
public new void Input()
{
base.Input();
Console.Write("Input the description: ");
description = Console.ReadLine();
}
public new void Show()
{
base.Show();
Console.WriteLine("Description:
"
+
description);
}
}
class Sunflower: Plants
{ }
7


TRƯỜNG ĐẠI HỌC KINH TẾ TPHCM – CƠ SỞ LẬP TRÌNH

public class InherMain
{
public static void Main(string[] args)
{
Peashooter s1 = new Peashooter();
Console.WriteLine("Peashooter.");

s1.Input();
s1.Show();
Console.WriteLine("SnowPea.");
SnowPea m1 = new SnowPea();
m1.Input();
m1.Show();
Sunflower w1 = new Sunflower();
Console.WriteLine("Sunflower");
w1.Input();
w1.Show();
Console.ReadLine();
}
}
Kết quả:
Peashooter.
Input Level: From the start
Input Health: 80
Input Money: 100
Input the description: Use beans to shoot zombies
Level: From the start | Health: 80HP | Money:100$
Description: Use beans to shoot zombies
SnowPea.
Input Level: 1-6
Input Health: 100
Input Money: 175
Input the description: Use ice bullets to shoot zombies
Level: 1-6 | Health: 100HP | Money:175$
Description: Use ice bullets to shoot zombies
Sunflower.
Input Level: After win 1st round

Input Health: 60
Input Money: 50
Level: After win 1st round | Health: 60HP | Money: 50$
8


TRƯỜNG ĐẠI HỌC KINH TẾ TPHCM – CƠ SỞ LẬP TRÌNH

Trong ví dụ trên, lớp Plants có phương thức Show( ), tuy nhiên phương thức
này chỉ xuất ra các thông tin như Level, Health, Money nên khơng cịn phù hợp
với hai lớp Peashooter và SnowPea nữa. Do đó hai lớp dẫn xuất này định nghĩa
một phiên bản mới của phương thức Show theo cú pháp sau:
public new void Show() { … }
Việc thêm vào từ khóa new chỉ ra rằng người lập trình muốn tạo ra một phiên bản
mới của phương thức này trong các lớp dẫn xuất nhằm che dấu phương thức đã kế
thừa từ lớp cơ sở Plants. Như vậy, trong hàm Main(), khi gọi: s1.Show();
m1.Show(); trình biên dịch sẽ hiểu rằng đây là phương thức Show() của lớp
Peashooter hoặc lớp SnowPea.
Trong ví dụ trên, khi định nghĩa lớp thừa kế ta dùng dấu hai chấm: để tách
giữa hai lớp dẫn xuất và lớp cơ sở. Dấu hai chấm biểu diễn sự kế thừa giữa 2 lớp
trong C#.
class Peashooter: Plant
{ }
Đối với hàm tạo (constructor) ở lớp thừa kế ta phải nhớ có hàm với từ khóa
base() nằm sau dấu hai chấm:
public Peashooter() : base()
{
description = "";
}
Các hàm thành viên, chẳng hạn, hàm Input(), hàm Show() trong cả 3 lớp đều

có tên giống nhau. Các hàm này được gọi là hàm trùng tên hay nạp chồng
(overloading function). Việc gọi hàm thành viên đã có ở lớp cơ sở, ta phải dùng từ
khóa base truy cập qua tốn tử chấm.
base.Input();
9


TRƯỜNG ĐẠI HỌC KINH TẾ TPHCM – CƠ SỞ LẬP TRÌNH

Khi khai báo đối tượng trong hàm Main(), ta khơng hề quan tâm tới lớp cơ
sở. Đối tượng nào thuộc lớp dẫn xuất nào sẽ được khai báo kiểu của lớp dẫn xuất
đó.
Peashooter s1 = new Peashooter();
SnowPea m1 = new SnowPea();
Sunflower w1 = new Sunflower();
Khi định nghĩa các hàm thành viên trong lớp cơ sở, phải luôn nhớ đặt từ khóa new
sau từ khóa public và trước từ khóa void.
2. Sử dụng từ khóa virtual và override
Overriding cho method là một tính năng cho phép lớp con định nghĩa lại
phương thức của lớp cha. Phương thức được khai báo ở lớp con phải cùng tên,
cùng tham số mà lớp cha đã khai báo.
Các biến thuộc lớp cơ sở được khai báo theo kiểu private (hoặc protected).
Các biến thuộc lớp dẫn xuất được khai báo theo kiểu private.
Các hàm thành viên thuộc lớp cơ sở phải có từ khóa virtual trước từ khóa
void.
Các hàm thành viên thuộc lớp dẫn xuất phải có từ khóa override trước từ
khóa void.
Cú pháp như sau:
class Base1
{

private int a,b;
public virtual void Method1()
{ }
class Derived: Base1
{
private int c;
public override void Show()
{ }
}
Ví dụ 6.2 Viết lại chương trình như ví dụ 6.1 theo cách sử dụng từ khóa virtual và
override.
using System;
class Plants
{
private int Health;
private int Money;
private string Level;
public Plants()
{
Health = 0;
10


TRƯỜNG ĐẠI HỌC KINH TẾ TPHCM – CƠ SỞ LẬP TRÌNH

Money = 0;
Level = "";
}
public virtual void Input()
{

Console.Write("Input Level: ");
Level = Console.ReadLine();
Console.Write("Input Health: ");
Health = Int32.Parse(Console.ReadLine());
Console.Write("Input Money: ");
Money = Int32.Parse(Console.ReadLine());
}
public virtual void Show()
{
Console.WriteLine("Level: " + Level + "
Health: " + Health + "HP | Money: " + Money + "$");
}

|

}
class Peashooter : Plants
{
private string description;
public Peashooter() : base()
{
description = "";
}
public override void Input()
{
base.Input();
Console.Write("Input the description: ");
description = Console.ReadLine();
}
public override void Show()

{
base.Show();
Console.WriteLine("Description:
"
+
description);
}
}
class SnowPea : Plants
{
11


TRƯỜNG ĐẠI HỌC KINH TẾ TPHCM – CƠ SỞ LẬP TRÌNH

private string description;
public SnowPea() : base()
{
description = "";
}
public override void Input()
{
base.Input();
Console.Write("Input the description: ");
description = Console.ReadLine();
}
public override void Show()
{
base.Show();
Console.WriteLine("Description:

"
+
description);
}
}
class Sunflower: Plants
{ }
public class InherMain
{
public static void Main(string[] args)
{
Peashooter s1 = new Peashooter();
Console.WriteLine("Peashooter.");
s1.Input();
s1.Show();
Console.WriteLine("SnowPea.");
SnowPea m1 = new SnowPea();
m1.Input();
m1.Show();
Sunflower w1 = new Sunflower();
Console.WriteLine("Sunflower");
w1.Input();
w1.Show();
Console.ReadLine();
}
}
Kết quả tương tự như kết quả của chương trình trong ví dụ 6.1

12

TRƯỜNG ĐẠI HỌC KINH TẾ TPHCM – CƠ SỞ LẬP TRÌNH

Ví dụ 6.3: Viết chương trình có thừa kế để thể hiện một lớp học có học sinh đến từ
nhiều quốc gia khác nhau. Sử dụng từ khóa virtual và override cho phương thức đưa
ra lời chào Greet.
using System;
namespace Cuoiky
{
class Person
{
protected string name;
protected int age;
public Person(string name, int age)
{
this.name = name;
this.age = age;
}
public virtual void Greet() { }
}
class Vietnamese : Person
{
public Vietnamese(string name, int age) :
base(name, age) { }
public
override
void
Greet()
{ Console.WriteLine("Xin chao. Minh ten la {0}. Nam nay
minh {1} tuoi.", this.name, this.age); }

}
class American : Person
{
public American(string name, int age) :
base(name, age) { }
public
override
void
Greet()
{ Console.WriteLine("Hello. My name is {0}. I am {1}
years old.", this.name, this.age); }
}
class French : Person
{

13


TRƯỜNG ĐẠI HỌC KINH TẾ TPHCM – CƠ SỞ LẬP TRÌNH

public French(string name, int age) : base(name,
age) { }
public
override
void
Greet()
{ Console.WriteLine("Bonjour, je m'appelle {0}. J'ai {1}
ans.", this.name, this.age); }
}
class ExamInherit

{
static void Main(string[] args)
{
Person[] students = new Person[3];
students[0] = new Vietnamese("Ngoc", 20);
students[1] = new American("Rosie", 24);
students[2] = new French("Francois", 19);
for (int i = 0; i < 3; i++)
{
students[i].Greet();
}
Console.ReadLine();
}
}
}
Kết quả:
Xin chao. Minh ten la Ngoc. Nam nay minh 20 tuoi.
Hello. My name is Rosie. I am 24 years old.
Bonjour, je m'appelle Francois. J'ai 19 ans.

14


TRƯỜNG ĐẠI HỌC KINH TẾ TPHCM – CƠ SỞ LẬP TRÌNH

TÀI LIỆU THAM KHẢO
Bài giảng Lập trình hướng đối tượng của tác giả Phạm Quang Huy
/>Tính kế thừa trong lập trình C#
/>Thừa kế trong C#
/>Kế thừa trong Lập trình hướng đối tượng

/>Khái niệm kế thừa (Inheritance)
/>Tính kế thừa trong C#
/>
15