Bài giảng lập trình hướng đối tượng

Lập trình Hướng đối tượng

MỤC LỤC

Chương 1. Tổng quan về lập trình hướng đối tượng.............................................................. 7
1.1. Phương pháp tiếp cận của lập trình truyền thống............................................ 7
1.1.1. Lập trình tuyến tính ......................................................................................... 7
1.1.2. Lập trình cấu trúc............................................................................................ 8
1.2. Phương pháp tiếp cận lập trình hướng đối tượng ............................................ 9
1.3. Các đặc trưng của lập trình hướng đối tượng ................................................ 10
1.3.1. Tính đóng gói dữ liệu .................................................................................... 10
1.3.2. Tính kế thừa................................................................................................... 10
1.3.3. Tính đa hình .................................................................................................. 11
1.4. Trừu tượng hóa .................................................................................................. 11
1.4.1. Tổ chức trừu tượng theo sự phân cấp lớp..................................................... 11
1.4.2. Trừu tượng hóa – cơ sở của phát triển phần mềm........................................ 13
1.5. Xu hướng phát triển của lập trình hướng đối tượng...................................... 14
1.5.1. Lập trình hướng thành phần (Component-oriented programming-COP) .... 14
1.5.2. Lập trình hướng tác nhân.............................................................................. 15
1.5.3. Lập trình hướng khía cạnh............................................................................ 16

Chương 2. Ngôn ngữ lập trình C#.......................................................................................... 18
2.1. Tổng quan Ngôn ngữ C# ................................................................................... 18
2.1.1. Ngôn ngữ ra đời cùng với .NET .................................................................... 18
2.1.2. C# – mạnh mẽ & bền vững............................................................................ 18
2.1.3. Vai trò C# trong .NET Framework ............................................................... 19
2.1.4. Quá trình dịch CT C#.................................................................................... 19
2.1.5. Quá trình dịch CT C#.................................................................................... 20
2.2. Các loại ứng dụng C#......................................................................................... 20

Trang 1

Trung tâm Tin học – Ngoại ngữ

2.2.1. Ứng dụng Console......................................................................................... 20
2.2.2. Ứng dụng Windows Form ............................................................................. 21
2.2.3. Ứng dụng Web............................................................................................... 22
2.3. Cấu trúc một chương trình C# ......................................................................... 22
2.4. Cú pháp C# cơ bản ............................................................................................ 26
2.5. Kiểu dữ liệu của C#............................................................................................ 29
2.5.1. Kiểu giá trị – value type ................................................................................ 29
2.5.2. Kiểu tham chiếu – reference type.................................................................. 30
2.5.3. Kiểu con trỏ – pointer type............................................................................ 31
2.5.4. Cách chuyển kiểu dữ liệu (Type Conversion) trong C#................................ 32
2.5.5. Một số phương thức chuyển kiểu được xây dựng sẵn ................................... 33
2.6. Biến trong C#...................................................................................................... 34
2.6.1. Khai báo biến ................................................................................................ 35
2.6.2. Khởi tạo biến ................................................................................................. 35
2.6.3. Nhận giá trị dữ liệu từ việc nhập liệu của user: ........................................... 36
2.7. Hằng trong C# .................................................................................................... 37
2.7.1. Định nghĩa hằng trong C# ............................................................................ 37
2.7.2. Hằng số nguyên trong C# ............................................................................. 39
2.7.3. Hằng số thực trong C# .................................................................................. 39
2.7.4. Hằng ký tự trong C#...................................................................................... 40
2.7.5. Hằng chuỗi trong C#..................................................................................... 41
2.8. Toán tử trong C#................................................................................................ 41
2.8.1. Toán tử số học ............................................................................................... 41
2.8.2. Toán tử quan hệ............................................................................................. 42
2.8.3. Toán tử logic ................................................................................................. 44

Trang 2

Lập trình Hướng đối tượng

2.8.4. Toán tử trên bit.............................................................................................. 45
2.8.5. Toán tử gán ................................................................................................... 47
2.8.6. Toán tử hỗn hợp ............................................................................................ 48
2.8.7. Độ ưu tiên của toán tử................................................................................... 49
2.8.8. Các câu lệnh điều kiện trong C#................................................................... 51
2.8.9. Toán tử điều kiện........................................................................................... 56
2.8.10. Vòng lặp trong C# ......................................................................................... 57
Chương 3. Lớp và đối tượng................................................................................................... 67
3.1. Class, trừu tượng hóa, lập trình hướng đối tượng.......................................... 67
3.1.1. Class và trừu tượng hóa................................................................................ 67
3.1.2. Object và cụ thể hóa...................................................................................... 67
3.2. Class trong lập trình hướng đối tượng và C#.................................................. 68
3.2.1. Khai báo class trong C#................................................................................ 68
3.2.2. Biến thành viên.............................................................................................. 71
3.2.3. Một số vấn đề khi sử dụng biến thành viên................................................... 75
3.2.4. Phương thức thành viên ................................................................................ 77
3.2.5. Tham số của phương thức trong C#: value type và reference type .............. 80
3.2.6. Tham số out ................................................................................................... 84
3.2.7. Tham số tùy chọn........................................................................................... 87
3.2.8. Tham số params ............................................................................................ 89
3.3. Nạp chồng phương thức (method overloading) trong C# .............................. 91
3.3.1. Nạp chồng phương thức trong C# là gì? ...................................................... 91
3.3.2. Signature của phương thức trong C#............................................................ 92
3.4. Một số vấn đề khác của phương thức trong C# .............................................. 94
3.4.1. Phương thức với Expression body ................................................................ 94

Trang 3

Trung tâm Tin học – Ngoại ngữ

3.4.2. Named Arguments ......................................................................................... 94
3.5. Properties trong C#............................................................................................ 95
3.6. Hàm dựng trong C# và khởi tạo đối tượng ................................................... 106

3.6.1. Xây dựng constructor cho class C# ............................................................ 107
3.6.2. Khởi tạo object với constructor................................................................... 109
3.6.3. Khởi tạo object với property ....................................................................... 109
3.7. Một số vấn đề khác với constructor trong C# ............................................... 111
3.7.1. Default constructor trong class C# ............................................................. 111
3.7.2. Chuỗi constructor trong class C#, constructor initializer .......................... 111
3.8. Vấn đề khởi tạo và sử dụng object ................................................................. 113
3.8.1. Quan hệ class và object............................................................................... 113
3.8.2. Khai báo và khởi tạo object ........................................................................ 114
3.8.3. Truy xuất các thành viên của object ........................................................... 114
3.8.4. Từ khóa this ................................................................................................. 115
3.9. Lớp lồng nhau................................................................................................... 116
3.10. Nested types ...................................................................................................... 119
3.11. Thành viên Static ............................................................................................. 121
3.12. Biến tĩnh (static field)....................................................................................... 121
3.13. Phương thức tĩnh (static method)................................................................... 125
3.14. Hàm dựng tĩnh (static constructor)................................................................ 127
3.15. Đặc tính tĩnh (static property) ........................................................................ 129
3.16. Lớp tĩnh (static class)....................................................................................... 130
3.17. Extension method............................................................................................. 132
Chương 4. Kế thừa và đa hình trong C# ............................................................................. 135
4.1. Kế thừa.............................................................................................................. 135

Trang 4

Lập trình Hướng đối tượng

4.1.1. Đặc điểm của kế thừa trong C# .................................................................. 138
4.1.2. Lớp Object và kế thừa trong C#.................................................................. 139
4.1.3. Quan hệ giữa kế thừa và đa hình trong C#................................................. 140
4.2. Che giấu phương thức (method hiding) trong C#......................................... 142
4.3. Ghi đè phương thức (method overriding) trong C# ..................................... 144
4.4. Lớp trừu tượng và kế thừa.............................................................................. 147
4.4.1. Lớp và trừu tượng hóa ................................................................................ 147
4.4.2. Lớp trừu tượng trong C#............................................................................. 148
4.4.3. Phương thức trừu tượng.............................................................................. 148
4.5. Interface trong C#............................................................................................ 150
4.5.1. Quan hệ phụ thuộc giữa các class .............................................................. 150
4.5.2. Khái niệm interface trong C#...................................................................... 150
4.5.3. Kỹ thuật lập trình với Interface trong C# ................................................... 154
4.5.4. Thực thi interface ........................................................................................ 155
4.5.5. Sử dụng interface trong C# ......................................................................... 157
4.6. Partial class trong C#....................................................................................... 160
4.6.1. Khái niệm partial class ............................................................................... 160
4.6.2. Sử dụng partial class trong C# project ....................................................... 161
4.6.3. Một số vấn đề khi sử dụng partial class trong C# ...................................... 163
4.7. Partial method trong C#.................................................................................. 164
4.7.1. Khái niệm partial method............................................................................ 164
4.7.2. Sử dụng partial method trong C#................................................................ 164
4.7.3. Các lưu ý khi sử dụng partial method trong C#.......................................... 167
Chương 5. Nạp chồng toán tử............................................................................................... 169
5.1.1. Khái niệm nạp chồng toán tử ...................................................................... 169

Trang 5

Trung tâm Tin học – Ngoại ngữ
5.1.2. Cách nạp chồng toán tử trong C#............................................................... 169
5.1.3. Một số lưu ý khi nạp thực hiện chồng toán tử............................................. 172
5.1.4. Nạp chồng phép toán indexer trong C# ...................................................... 174
5.1.5. Cú pháp nạp chồng indexer ........................................................................ 175
5.1.6. Nạp chồng toán tử indexer cho lớp Vector ................................................. 175
Chương 6. Ngoại lệ................................................................................................................. 179
6.1. Khái niệm exception trong C# ........................................................................ 179
6.1.1. Cơ chế xử lý exception trong C# ................................................................. 179
6.1.2. Kỹ thuật xử lý ngoại lệ (Exception Handling) trong C# ............................. 180
6.1.3. Exception và chế độ Debug trong C# ......................................................... 180
6.1.4. Xử lý ngoại lệ ở chế độ Release .................................................................. 182
6.2. Cấu trúc Try – Catch - Finally ....................................................................... 182

Trang 6

Lập trình Hướng đối tượng

CHƯƠNG 1. TỔNG QUAN VỀ LẬP TRÌNH HƯỚNG ĐỐI TƯỢNG

Nội dung chương này nhằm giới thiệu một cách tổng quan về cách tiếp cận hướng
đối tượng. Nội dung trình bày bao gồm:

• Giới thiệu về cách tiếp cận của lập trình truyền thống.
• Giới thiệu cách tiếp cận của lập trình hướng đối tượng.
• Sự trừu tượng hóa là cơ sở của phát triển phần mềm hướng đối tượng.
• Nêu các đặc trưng của lập trình hướng đối tượng.
• Xu hướng hiện nay của lập trình hướng đối tượng.

1.1. Phương pháp tiếp cận của lập trình truyền thống

Lập trình truyền thống đã trải qua hai giai đoạn:

• Giai đoạn sơ khai, khi khái niệm lập trình mới ra đời, là lập trình tuyến tính.
• Giai đoạn tiếp theo, là lập trình hướng cấu trúc.

1.1.1. Lập trình tuyến tính

Đặc trưng cơ bản của lập trình tuyến tính là tư duy theo lối tuần tự. Chương trình sẽ
được thực hiện tuần tự từ đầu đến cuối, lệnh này kế tiếp lệnh kia cho đến khi kết thúc
chương trình.

Đặc trưng

Lập trình tuyến tính có hai đặc trưng:

• Đơn giản: chương trình được tiến hành đơn giản theo lối tuần tự, không phức tạp.
• Đơn luồng: chỉ có một luồng (thread) công việc duy nhất, và các công việc được

thực hiện tuần tự trong luồng đó.

Tính chất
• Ưu điểm: Do tính đơn giản, lập trình tuyến tính có ưu điểm là chương trình đơn

giản, dễ hiểu. Lập trình tuyến tính được ứng dụng cho các chương trình đơn giản.

• Nhược điểm: Với các ứng dụng phức tạp, người ta không thể dùng lập trình tuyến
tính để giải quyết.

Trang 7

Trung tâm Tin học – Ngoại ngữ

• Ngày nay, lập trình tuyến tính chỉ tồn tại trong phạm vi các mô đun nhỏ nhất của
các phương pháp lập trình khác. Ví dụ trong một chương trình con của lập trình
cấu trúc, các lệnh cũng được thực hiện theo tuần tự từ đầu đến cuối chương trình
con.

1.1.2. Lập trình cấu trúc

Trong lập trình hướng cấu trúc, chương trình chính được chia nhỏ thành các chương
trình con và mỗi chương trình con thực hiện một công việc xác định. Chương trình chính
sẽ gọi đến chương trình con theo một giải thuật, hoặc một cấu trúc được xác định trong
chương trình chính.

Các ngôn ngữ lập trình cấu trúc phổ biến là Pascal, C và C++. Riêng C++ ngoài việc
có đặc trưng của lập trình cấu trúc do kế thừa từ C, còn có đặc trưng của lập trình hướng
đối tượng. Cho nên C++ còn được gọi là ngôn ngữ lập trình nửa cấu trúc, nửa hướng đối
tượng.

Đặc trưng

Đặc trưng cơ bản nhất của lập trình cấu trúc thể hiện ở mối quan hệ:

Chương trình = CTDL + Giải thuật

Trong đó:
• CTDL là cách tổ chức dữ liệu, cách mô tả bài toán dưới dạng ngôn ngữ lập trình
• Giải thuật là một quy trình để thực hiện một công việc xác định Trong chương

trình, giải thuật có quan hệ phụ thuộc vào CTDL:
• Một CTDL chỉ phù hợp với một số hạn chế các giải thuật.
• Nếu thay đổi CTDL thì phải thay đổi giải thuật cho phù hợp.
• Một giải thuật thường phải đi kèm với một CTDL nhất định.

Tính chất
• Mỗi chương trình con có thể được gọi thực hiện nhiều lần trong một chương trình

chính.

Trang 8

Lập trình Hướng đối tượng

• Các chương trình con có thể được gọi đến để thực hiện theo một thứ tự bất kỳ, tuỳ
thuộc vào giải thuật trong chương trình chính mà không phụ thuộc vào thứ tự khai
báo của các chương trình con.

• Các ngôn ngữ lập trình cấu trúc cung cấp một số cấu trúc lệnh điều khiển chương
trình.

Ưu điểm

• Chương trình sáng sủa, dễ hiểu, dễ theo dõi.
• Tư duy giải thuật rõ ràng.

Nhược điểm

• Lập trình cấu trúc không hỗ trợ việc sử dụng lại mã nguồn: Giải thuật luôn phụ
thuộc chặt chẽ vào CTDL, do đó, khi thay đổi CTDL, phải thay đổi giải thuật,
nghĩa là phải viết lại chương trình.

• Không phù hợp với các phần mềm lớn: tư duy cấu trúc với các giải thuật chỉ phù
hợp với các bài toán nhỏ, nằm trong phạm vi một mô đun của chương trình. Với
dự án phần mềm lớn, lập trình cấu trúc tỏ ra không hiệu quả trong việc giải quyết
mối quan hệ vĩ mô giữa các mô đun của phần mềm.

Vấn đề

Vấn đề cơ bản của lập trình cấu trúc là bằng cách nào để phân chia chương trình chính
thành các chương trình con cho phù hợp với yêu cầu, chức năng và mục đích của mỗi bài
toán.

1.2. Phương pháp tiếp cận lập trình hướng đối tượng

Xuất phát từ hai hạn chế chính của phương pháp lập trình cấu trúc:

• Không quản lý được sự thay đổi dữ liệu khi có nhiều chương trình cùng thay đổi
một biến chung. Vấn đề này đặc biệt nghiêm trọng khi các ứng dụng ngày càng
lớn, người ta không thể kiểm soát được sự truy nhập đến các biến dữ liệu chung.

• Không tiết kiệm được tài nguyên con người: Giải thuật gắn liền với CTDL, nếu
thay đổi CTDL, sẽ phải thay đổi giải thuật, và do đó, phải viết lại mã chương trình
từ đầu.

Trang 9

Trung tâm Tin học – Ngoại ngữ

Để khắc phục được hai hạn chế này khi giải quyết các bài toán lớn, người ta xây dựng
một phương pháp tiếp cận mới, là phương pháp lập trình hướng đối tượng, với hai mục
đích chính:

• Đóng gói dữ liệu để hạn chế sự truy nhập tự do vào dữ liệu, không quản lý được.
• Cho phép sử dụng lại mã nguồn, hạn chế việc phải viết lại mã từ đầu cho các

chương trình.

Ngôn ngữ lập trình hướng đối tượng phổ biến hiện nay là Java và C++. Tuy nhiên,
C++ mặc dù cũng có những đặc trưng cơ bản của lập trình hướng đối tượng nhưng vẫn
không phải là ngôn ngữ lập trình thuần hướng đối tượng. Java thật sự là một ngôn ngữ lập
trình thuần hướng đối tượng.

1.3. Các đặc trưng của lập trình hướng đối tượng
1.3.1. Tính đóng gói dữ liệu

Dữ liệu luôn được tổ chức thành các thuộc tính của lớp đối tượng. Việc truy nhập đến
dữ liệu phải thông qua các phương thức của đối tượng lớp.

Trong một đối tượng, dữ liệu hay thao tác hay cả hai có thể là riêng (private) hoặc
chung (public) của đối tượng đó. Thao tác hay dữ liệu riêng là thuộc về đối tượng đó chỉ
được truy cập bởi các thành phần của đối tượng, điều này nghĩa là thao tác hay dữ liệu
riêng không thể truy cập bởi các phần khác của chương trình tồn tại ngoài đối tượng. Khi
thao tác hay dữ liệu là chung, các phần khác của chương trình có thể truy cập nó mặc dù
nó được định nghĩa trong một đối tượng. Các thành phần chung của một đối tượng dùng
để cung cấp một giao tiếp có điều khiển cho các thành thành riêng của đối tượng.

Cơ chế đóng gói (encapsulation) là phương thức tốt để thực hiện cơ chế che dấu thông
tin so với các ngôn ngữ lập trình cấu trúc.

1.3.2. Tính kế thừa

Cho phép sử dụng lại mã nguồn. Các lớp đối tượng có thể kế thừa (inheritance) từ
các lớp đối tượng khác. Khi đó, trong các lớp kế thừa, có thể sử dụng các phương thức hoạt
động của các lớp bị kế thừa, mà không cần phải định nghĩa lại.

Trang 10

Lập trình Hướng đối tượng

Việc cho phép sử dụng lại mã nguồn được thực hiện thông qua cơ chế kế thừa trong
lập trình hướng đối tượng. Theo đó:

• Các lớp có thể được kế thừa nhau để tận dụng các thuộc tính, các phương thức của
nhau.
• Trong lớp dẫn xuất (lớp kế thừa) có thể sử dụng lại các phương thức của lớp cơ sở
(lớp bị lớp khác kế thừa) mà không cần thiết phải cài đặt lại mã nguồn.
• Ngay cả khi lớp dẫn xuất định nghĩa lại các phương thức cho mình, lớp cơ sở cũng
không bị ảnh hưởng và không phải sửa lại bất kỳ một đoạn mã nguồn nào.

1.3.3. Tính đa hình

Khả năng để cho một thông điệp có thể thay đổi cách thực hiện của nó theo lớp cụ
thể của đối tượng nhận thông điệp. Khi một lớp dẫn xuất được tạo ra, nó có thể thay đổi
cách thực hiện các phương thức nào đó mà nó thừa hưởng từ lớp cơ sở của nó. Một thông
điệp khi được gởi đến một đối tượng của lớp cơ sở, sẽ dùng phương thức đã định nghĩa
cho nó trong lớp cơ sở. Nếu một lớp dẫn xuất định nghĩa lại một phương thức thừa hưởng
từ lớp cơ sở của nó thì một thông điệp có cùng tên với phương thức này, khi được gởi tới
một đối tượng của lớp dẫn xuất sẽ gọi phương thức đã định nghĩa cho lớp dẫn xuất.

Như vậy đa hình (polymorphism) là khả năng cho phép gởi cùng một thông điệp đến
những đối tượng khác nhau có cùng chung một đặc điểm, nói cách khác thông điệp được
gởi đi không cần biết thực thể nhận thuộc lớp nào, chỉ biết rằng tập hợp các thực thể nhận
có chung một tính chất nào đó. Chẳng hạn, thông điệp vẽ hình được gởi đến cả hai đối
tượng hình hộp và hình tròn. Trong hai đối tượng này đều có chung phương thức vẽ hình,
tuy nhiên tuỳ theo thời điểm mà đối tượng nhận thông điệp, hình tương ứng sẽ được vẽ lên.

1.4. Trừu tượng hóa
1.4.1. Tổ chức trừu tượng theo sự phân cấp lớp

Thậm chí mặc dù con người giỏi ở sự trừu tượng các khái niệm như bản đồ đường đi
và cảnh quan, vẫn còn số lượng rất lớn các công việc trừu tượng hoá riêng lẻ mà chúng ta

Trang 11

Trung tâm Tin học – Ngoại ngữ
thường gặp trong cuộc sống. Để đối phó sự phức tạp này con người phải sắp xếp thông tin
một cách có hệ thống theo các tiêu chuẩn nào đó; Xử lý này gọi là sự phân lớp
(classification).

Ví dụ như khoa học đã phân cấp theo lớp tất cả đối tượng tự nhiên thuộc về động vật,
hoặc cây, hoặc khoáng sản. Để được phân là động vật, nó phải thoả điều kiện sau:

• Vật thể sống.
• Tự di chuyển.
• Phản ứng khi bị kích thích.
Qui luật cho một đối tượng là cây thì hơi khác:
• Vật thể sống (như động vật).
• Không có hệ thần kinh.
• Có màn cellulose.
Sau khi phân lớp đơn giản như trên ta có thể thêm vài qui luật để có các loại động vật
cụ thể hơn cho đến khi có một sự phân cấp theo sự trừu tượng từ cao (đỉnh) xuống thấp
(đáy). Sơ đồ phân cấp trừu tượng của các đối tượng tự nhiên được thể hiện như hình 1.1.

Trang 12

Lập trình Hướng đối tượng

Hình 1-1. Sơ đồ phân cấp trừu tượng các đối tượng tự nhiên
1.4.2. Trừu tượng hóa – cơ sở của phát triển phần mềm

Khi ghi nhận các yêu cầu cho một dự án phần mềm, chúng ta thường bắt đầu bằng
cách thu thập thông tin chi tiết về tình hình thực tế mà trên đó hệ thống sẽ hoạt động. Những
chi tiết này thường là một sự tổng hợp của

• Thông tin từ những người sử dụng hệ thống được chúng ta phỏng vấn.
• Những hoạt động mà chúng ta quan sát từ nghiệp vụ hàng ngày của người sử dụng

hệ thống.
Kế đến chúng ta phải chọn lọc ra những chi tiết nào liên quan tới mục đích sử dụng
hệ thống. Việc này là cần thiết vì chúng ta không thể tự động hoá tất cả hệ thống nghiệp
vụ bằng phần mềm! Việc bao gồm quá nhiều chi tiết sẽ làm hệ thống phức tạp và khó khăn
hơn trong việc thiết kế, kiểm tra chương trình, dò lỗi, tạo sưu liệu, bảo trì và mở rộng
chương trình sau này.

Trang 13

Trung tâm Tin học – Ngoại ngữ

Sự trừu tưởng hoá sẽ giúp người phân tích hệ thống có được các nét đặc trưng của hệ
thống trong miền (domain) bài toán, tập trung vào vấn đề của hệ thống dự định phát triển.
Như khi thể hiện một người trong chương trình, màu mắt của họ có quan trọng không? Về
gen ? Lương ? Sở thích ? Câu trả lời là bất kỳ đặc tính nào của người có thể liên quan hay
không liên quan tuỳ thuộc vào hệ thống mà ta định phát triển là:

• Chương trình tính lương
• Chương trình tiếp thị theo tuổi tác
• CSDL bệnh nhân nhãn khoa
• Hệ thống theo dõi những kẻ bị truy nã

Một khi đã xác định các đặc trưng quan trọng của một tình huống, ta cần chuẩn bị
một mô hình hoá cho nó. Mô hình hoá là xử lý nhằm phát triển một khuôn mẫu để tạo ra
một thứ gì đó; ví dụ như bản thiết kế ngôi nhà, sơ đồ mạch điện, một khuôn bánh. Một mô
hình đối tượng của hệ thống phần mềm là một mẫu như vậy. Mô hình hoá và trừu tượng
hoá luôn đi với nhau vì một mô hình là sự mô tả đồ hoạ hay vật lý của trừu tượng; Trước
khi mô hình vật gì đó một cách có hiệu quả, ta phải xác định các chi tiết cần thiết của chủ
thể cần được mô hình.

1.5. Xu hướng phát triển của lập trình hướng đối tượng
1.5.1. Lập trình hướng thành phần

Lập trình hướng thành phần (Component-oriented programming-COP) xuất phát từ
lập trình hướng đối tượng, tư duy lập trình hướng thành phần theo ý tưởng:

• Giải quyết bài toán bằng cách xây dựng một tập các thành phần (component) có
tính độc lập tương đối với nhau. Mỗi thành phần đảm nhiệm một phần công việc
nhất định.

• Sau đó, người ta ghép các thành phần với nhau để thu được một phần mềm thoả
mãn một tập các yêu cầu xác định.

Với lập trình hướng thành phần, người ta có thể tiến hành lập trình theo phương pháp
sau:

Trang 14

Lập trình Hướng đối tượng

• Xây dựng một thư viện các thành phần, mỗi thành phần thực hiện một công việc
xác định.

• Khi cần phát triển một phần mềm cụ thể, người ta chỉ cần chọn những thành phần
có sẵn trong thư viện để ghép lại với nhau. Người lập trình chỉ phải phát triển thêm
các thành phần mình cần mà chưa có trong thư viện.

Phương pháp này có những ưu điểm rất lớn:

• Lập trình viên có thể chia sẻ với nhau những thành phần mình đã xây dựng cho
nhiều người khác dùng chung.

• Khi cần, lập trình viên có thể lắp ghép các thành phần có sẵn khác nhau để tạo
thành các chương trình có chức năng khác nhau. Tất cả chỉ cần dựa trên công nghệ
lắp ghép thành phần, tiết kiệm được rất nhiều công sức lập trình.

Trong xu hướng lập trình hướng thành phần, một số phương pháp lập trình khác đã
nảy sinh và đang phát triển mạnh mẽ:

• Lập trình hướng tác nhân (Agent-Oriented Programming)
• Lập trình hướng khía cạnh (Aspect-Oriented Programming-AOP)

1.5.2. Lập trình hướng tác nhân

Lập trình hướng agent có thể xem là một mức trừu tượng cao hơn của lập trình hướng
thành phần.

Trong đó, các agent là các thành phần có khả năng hoạt động độc lập, tự chủ để hoàn
thành công việc của mình. Hơn nữa, các agent có khả năng chủ động liên lạc với các agent
khác để có thể phối hợp, cộng tác hay cạnh tranh nhau để hoàn thành nhiệm vụ.

Lập trình hướng agent có hai đặc trưng cơ bản:

• Thứ nhất là khả năng tự chủ của mỗi agent để hoàn thành nhiệm vụ riêng của nó.
• Thứ hai là tính tổ chức xã hội giữa các agent, cho phép các agent phối hợp, cộng

tác, cạnh tranh nhau để hoàn thành nhiệm vụ chung của toàn hệ thống.

Trang 15

Trung tâm Tin học – Ngoại ngữ

1.5.3. Lập trình hướng khía cạnh

Phương pháp lập trình hướng khía cạnh là phương pháp lập trình phát triển tư duy
tách biệt các mối quan tâm khác nhau thành các mô đun khác nhau. Ở đây, một mối quan
tâm thường không phải một chức năng nghiệp vụ cụ thể và có thể đóng gói mà là một khía
cạnh (thuộc tính) chung mà nhiều mô đun phần mềm trong cùng hệ thống nên có, ví dụ lưu
vết thao tác và lỗi (error logging).

Với AOP, chúng ta có thể cài đặt các mối quan tâm chung cắt ngang hệ thống bằng
các mô đun đặc biệt gọi là aspect thay vì dàn trải chúng trên các mô đun nghiệp vụ liên
quan. Các aspect sau đó được tự kết hợp với các mô đun nghiệp vụ khác bằng quá trình
gọi là đan (weaving) bằng bộ biên dịch đặc biệt.

AspectJ là một công cụ AOP cho ngôn ngữ lập trình Java. Trình biên dịch AspectJ sẽ
đan xen chương trình Java chính với các aspect thành các tập tin bytecode chạy trên máy
ảo Java.

TỔNG KẾT CHƯƠNG 1

Nội dung chương 1 đã trình bày các vấn đề tổng quan liên quan đến phương pháp tiếp
cận hướng đối tượng trong lập trình:

• Các phương pháp tiếp cận truyền thống: lập trình tuyến tính và lập trình cấu trúc.
• Phương pháp tiếp cận hướng đối tượng với các đặc trưng cơ bản: đóng gói dữ liệu,

tính đa hình và sử dụng lại mã nguồn.
• Lập trình hướng đối tượng trên nền tảng là trừu tượng hoá là cơ sở lập trình hiện

đại.
• Hiện nay, lập trình hướng thành phần, lập trình hướng agent và lập trình hướng

aspect tiến hoá từ lập trình hướng đối tượng đang là xu hướng phát triển mạnh mẽ.

❖ BÀI TẬP

Trang 16

Lập trình Hướng đối tượng
1. Vẽ một sơ đồ phân cấp lớp cho các lớp sau đây: táo, chuối, thịt bò, nước giải khát, phó

mát, thứ có thể ăn uống, sản phẩm bơ sửa, đồ ăn, trái cây, đậu xanh, thịt, sửa, thịt heo,
rau muống, rau.
2. Những đặc điểm nào của tivi mà chúng cần thiết để được trừu tượng từ góc nhìn của
• Một khách hàng?
• Một kỹ sư thiết kế?
• Người bán?
• Nhà sản xuất?

Trang 17

Trung tâm Tin học – Ngoại ngữ

CHƯƠNG 2. NGÔN NGỮ LẬP TRÌNH C#
2.1. Tổng quan Ngôn ngữ C#

C # là một ngôn ngữ lập trình hiện đại được phát triển bởi Microsoft và được phê
duyệt bởi European Computer Manufacturers Association (ECMA) và International
Standards Organization (ISO). C # được phát triển bởi Anders Hejlsberg và nhóm của ông
trong việc phát triển .Net Framework.

C # được thiết kế cho các ngôn ngữ chung cơ sở hạ tầng (Common Language
Infrastructure – CLI), trong đó bao gồm các mã (Executable Code) và môi trường thực thi
(Runtime Environment) cho phép sử dụng các ngôn ngữ cấp cao khác nhau trên đa nền
tảng máy tính và kiến trúc khác nhau.

2.1.1. Ngôn ngữ ra đời cùng với .NET

• Kết hợp C++ và Java.
• Hướng đối tượng.
• Hướng thành phần.
• Mạnh mẽ (robust) và bền vững (durable).
• Mọi thứ trong C# đều Object oriented.
• Kể cả kiểu dữ liệu cơ bản.

o Chỉ cho phép đơn kế thừa.
• Dùng interface để khắc phục.
• Lớp Object là cha của tất cả các lớp.

o Mọi lớp đều dẫn xuất từ Object.
• Cho phép chia chương trình thành các thành phần nhỏ độc lập nhau.
• Mỗi lớp gói gọn trong một file, không cần file header như C/C++.

Bổ sung khái niệm namespace để gom nhóm các lớp.

• Bổ sung khái niệm “property” cho các lớp.
• Khái niệm delegate & event.

2.1.2. C# – mạnh mẽ & bền vững

• Garbage Collector
o Tự động thu hồi vùng nhớ không dùng.

Trang 18

Lập trình Hướng đối tượng

• Kiểm soát và xử lý ngoại lệ exception
o Đoạn mã bị lỗi sẽ không được thực thi.

• Type – safe
o Không cho gán các kiểu dữ liệu khác nhau.

• Versioning
o Đảm bảo sự tương thích giữa lớp con và lớp cha.

2.1.3. Vai trò C# trong .NET Framework

• .NET runtime sẽ phổ biến và được cài trong máy client.
o Việc cài đặt App C# như là tái phân phối các thành phần .NET
o Nhiều App thương mại sẽ được cài đặt bằng C#.

• C# tạo cơ hội cho tổ chức xây dựng các App Client/Server n-tier.
• Kết nối ADO.NET cho phép truy cập nhanh chóng & dễ dàng với SQL Server,

Oracle…
• Cách tổ chức .NET cho phép hạn chế những vấn đề phiên bản.

o Loại bỏ “DLL Hell”…
• ASP.NET viết bằng C#.

o GUI thông minh.
o Chạy nhanh hơn (đặc tính của .NET)
o Mã ASP.NET ko còn là mới hỗn độn.
o Khả năng bẫy lỗi tốt, hỗ trợ mạnh trong quá trình xây dựng App Web.

2.1.4. Quá trình dịch CT C#

• Mã nguồn C# (tập tin *.cs) được biên dịch qua MSIL.
o MSIL: tập tin .exe hoặc .dll

• MSIL được CLR thông dịch qua mã máy.
o Dùng kỹ thuật JIT (just-in-time) để tăng tốc độ.

Trang 19

Trung tâm Tin học – Ngoại ngữ

2.1.5. Quá trình dịch chương trình C#

2.2. Các loại ứng dụng C#

Sử dụng C#, ta có thể tạo ra rất nhiều kiểu ứng dụng, ở đây ta quan tâm đến ba kiểu
ứng dụng chính: Console, Window và ứng dụng Web

2.2.1. Ứng dụng Console

• Giao tiếp với người dùng bằng bàn phím.
• Không có giao diện đồ họa (GUI).

Ứng dụng Console là ứng dụng có giao diện text, chỉ xử lý nhập xuất trên màn hình
Console, tương tự với các ứng dụng DOS trước đây.

Ứng dụng Console thường đơn giản, ta có thể nhanh chóng tạo chương trình hiển thị
kết xuất trên màn hình. Do đó, các minh hoạ, ví dụ ngắn gọn ta thường sử dụng dạng
chương trình Console để thể hiện.

Để tạo ứng dụng Console ta làm như sau

Trong Visual Studio, chọn File → New → Project. Visual Studio sẽ trình bày hộp
thoại New Project.

Trong hộp thoại New Project, kích biểu tượng ứng dụng Console (Console
Application). Trong ô name, gõ tên chương trình (dự án). Trong ô Location, gõ tên của thư
mục mà ta muốn Visual Studio lưu dự án. Nhấn OK.

Trang 20

Lập trình Hướng đối tượng

Visual Studio sẽ hiển thị cửa sổ. Ta nhập code vào trong cửa sổ này.

Ví dụ: Chương trình Console sau đây sử dụng hai phương thức Console.ReadLine và
Console.Writeline để nhập và xuất số nguyên a ra màn hình:

static void Main(string[] args)
{

int a = int.Parse(Console.ReadLine());
Console.WriteLine("a = " + a);
Console.ReadLine();
}

Chạy chương trình: Để chạy chương trình, ta chọn Debug → Start hoặc nhấn F5,
Visual Studio sẽ hiển thị cửa sổ Console cho phép nhập và in số nguyên.

2.2.2. Ứng dụng Windows Form

• Giao tiếp với người dùng bằng bàn phím và mouse.
• Có giao diện đồ họa và xử lý sự kiện.

Là ứng dụng được hiển thị với giao diện cửa sổ đồ họa. Chúng ta chỉ cần kéo và thả
các điều khiển (control) lên cửa sổ Form. Visual Studio sẽ sinh mã trong chương trình để
tạo ra, hiển thị các thành phần trên cửa sổ.

Để tạo ứng dụng Window ta làm như sau:

File → New → Project. Visual Studio sẽ trình bày hộp thoại New Project.

Trong hộp thoại New Project, kích biểu tượng ứng dụng Windows (Windows
Application). Trong ô Name, gõ tên mô tả chương trình mà ta dự định tạo (tên dự án). Tiếp
theo, trong ô Location, gõ tên của thư mục mà ta muốn Visual Studio lưu dự án. Nhấn OK.
Visual Studio sẽ hiển thị cửa sổ thiết kế. Ta có thể kéo và thả các thành phần giao diện
(control) lên Form.

Để hiển thị cửa sổ Toolbox chứa những điều khiển mà ta có thể kéo và thả lên Form,
ta chọn View → Toolbox từ menu.

Trang 21

Trung tâm Tin học – Ngoại ngữ

Biên dịch và chạy chương trình: Để biên dịch chương trình, ta chọn Build → Build
Solution. Để chạy chương trình, ta chọn Debug → Start. Nếu ta có thay đổi nội dung của
Form, như đặt thêm điều khiển khác lên Form chẳng hạn, ta phải yêu cầu Visual Studio
biên dịch lại.

2.2.3. Ứng dụng Web

• Kết hợp với ASP .NET, C# đóng vài trò xử lý bên dưới (underlying code).
• Có giao diện đồ họa và xử lý sự kiện.

Môi trường .NET cung cấp công nghệ ASP.NET giúp xây dựng những trang Web
động. Để tạo ra một trang ASP.NET, người lập trình sử dụng ngôn ngữ biên dịch như C#
hoặc C# để viết mã. Để đơn giản hóa quá trình xây dựng giao diện người dùng cho trang
Web, .NET giới thiệu công nghệ Webform. Cách thức tạo ra các Web control tương tự
như khi ta xây dựng ứng dụng trên Window Form.

2.3. Cấu trúc một chương trình C#

Xét ví dụ sau:

using System;
namespace LTHDT
{

class HelloWorld
{

static void Main(string[] args)
{

/* Chương trình C# đầu tiên của tôi */
Console.WriteLine("Hello SV He thong Thong tin");
Console.ReadKey();
}
}
}

Khi đoạn code này biên dịch và thực thi sẽ hiện ra màn hình console dòng chữ “Hello
SV He thong Thong tin”.

Ta sẽ chỉ ra các thành phần trong đoạn code này:

Trang 22

Lập trình Hướng đối tượng

• Câu đầu tiên- using System; với từ khóa using được dùng để gọi đến namespace
System của chương trình. Một chương trình có thể có nhiều câu lệnh

• Câu tiếp theo là namespace declaration, một namespace là một tập hợp nhiều class.
HelloWorldApplication có chứa class

• Dòng tiếp theo là khai báo một class với tên HelloWorld, class này chứa dữ liệu
và xác định các phương thức mà chương trình sử dụng. Phương thức xác định hành
vi của class. Tuy nhiên ví dụ này chỉ có một phương thức Main.

• Dòng tiếp theo xác định một Main method. Đây là entry point của một chương
trình C#. Main method nói lên công việc của chương trình khi thực thi. Ở ví dụ
trên, hành vi được xác định là câu lệnh WriteLine(“Hello SV He thong Thong
tin”); với chức năng hiển thị câu “Hello world” lên màn hình. WriteLine là một
phương thức của class Console thuộc namespace System được hổ trợ sẵn bởi C#.

• Dòng tiếp theo /*..*/ là một dòng comment. Nó sẽ bị phớt lờ khi biên dịch chương
trình. Nó được sử dụng để viết chú thích cho code.

• Dòng cuối cùng ReadKey(); có tác dụng đợi một hành động nhấn phím, nhầm
ngăn màn hình console đóng quá nhanh khi người dùng chưa xem được kết quả.

Một số lưu ý khi bắt đầu tiếp xúc với C#:
• C# rất nhạy bén
• Những câu lệnh và biểu thức luôn kết thúc bằng dấu chấm phẩy (;)
• Một chương trình bắt đầu thực thi tại Main method.
• Không giống với java, tên program file C# có thể khác với tên class.

Để biên dịch và thực thi một chương trình C# từ Visual studio .NET, các bạn làm
theo các bước:

• Mở Visual studio
• Tại menu bar, chọn File->New->Project. Hoặc ta có thể sử dụng tổ hợp phím

Ctrl+Shift+N.

Trang 23

Trung tâm Tin học – Ngoại ngữ

• Chọn visual C# từ các mẫu cung cấp và chọn Windows
• Chọn tiếp Console Application

Trang 24

Lập trình Hướng đối tượng
• Đặt tên cho project và click OK. Đến đây ta đã tạo được một project trong Solution
Explorer.

• Ta sẽ viết code trong vùng code Editor
• Click Start hoặc F5 để thực thi project. Một màn hình console sẽ xuất hiện chứa

dòng chữ Hello SV He thong Thong tin.

Câu lệnh
• Các câu lệnh được viết trong thân của phương thức (ở đây là phương thức Main)
• Thực hiện một công việc nào đó
• Kết thúc bởi dấu chấm phẩy (;)
Khoảng trắng, bao gồm:
• Ký tự trắng, ký tự xuống dòng, ký tự tab.
Trang 25

Trung tâm Tin học – Ngoại ngữ

• Dòng trống.

Chú thích

• Chú thích (comment) được dùng để giải thích về chương trình và các câu lệnh.
• Giúp cho chương trình dễ hiểu hơn.
• Được bỏ qua khi biên dịch.
• Không ảnh hưởng tới kết quả thực thi của chương trình.
• Có thể phát sinh ra documentation của chương trình qua chú thích XML.

Hai cách tạo chú thích cơ bản

• Gõ phần chú thích sau cặp ký tự //
• Gõ phần chú thích giữa cặp ký tự /* và */

2.4. Cú pháp C# cơ bản

C# là ngôn ngữ lập trình hướng đối tượng. Trong phương pháp lập trình hướng đối
tượng, một chương trình bao gồm nhiều đối tượng khác nhau có tác động qua lại lẫn nhau
bởi những hành vi của chúng, cái được gọi là method. Những đối tượng cùng loại chất thì
được cho là cùng kiểu hay cùng một class.

Hãy xét một class Hình chữ nhật với hai thuộc tính là chiều dài và chiều rộng. Về mặt
thiết kế, ta cần phải gán giá trị cho chiều dài, chiều rộng và có các xử lý tính chu vi, diện
tích và hiển thị các thông số trên.

Sau đây là một thể hiện đầy đủ của class Rectangle bằng cú pháp C# cơ bản:

using System;
namespace LTHDT
{

class Rectangle
{

// Khai báo biến
double length;
double width;
public void Acceptdetails()
{

length = 4.5;

Trang 26

Lập trình Hướng đối tượng

width = 3.5;
}

public double GetArea()
{

return length * width;
}

public double GetCircuit()
{

return (length + width)*2;
}

public void Display()
{

Console.WriteLine("Length: {0}", length);
Console.WriteLine("Width: {0}", width);
Console.WriteLine("Area: {0}", GetArea());
Console.WriteLine("Circuit: {0}", GetCircuit());
}
}

class ExecuteRectangle
{

static void Main(string[] args)
{

Rectangle r = new Rectangle();
r.Acceptdetails();
r.Display();
Console.ReadLine();
}
}
}

Phân tích đoạn code trên:

• Biến: Biến là thuộc tính hoặc dữ liệu của lớp, được sử dụng để lưu trữ dữ liệu. Ở
chương trình trên, class Rectangle có hai biến là length và width.

• Hàm: hàm là một nhóm các câu lệnh đảm nhiệm một chức năng riêng biệt. Hàm
của một class được khai báo bên trong class. Trong ví dụ class Rectangle chứa 4
hàm: AccesptDetails, GetArea, GetCircuit và Display.

Trang 27

Trung tâm Tin học – Ngoại ngữ

• Khởi tạo một class: class ExcuteRectangle trong ví dụ trên bao gồm phương thức
Main() và khởi tạo đối tượng Rectangle bên trong phương thức.

• Định danh: một định danh là tên dùng để xác định một class, biến, hàm hay bất
kỳ một item do người dùng định nghĩa. Quy tắc cơ bản để đặt tên class trong C#
được qui định như sau:
o Tên phải bắt đầu bằng một chữ cái, theo sau có thể là chuỗi chữ cái, con số
hoặc dấu gạch dưới. Ký tự đầu tiên của tên không được là con số.
o Tên không được chứa bất kỳ khoảng trắng hoặc ký tự đặc biệt như ? – + ! @
# $ % ^ & * ( ) [ ] { } . ; : “ ‘ / và \.
o Tên không được trùng từ khóa của C#.

• Từ khóa: là những từ dành riêng được định nghĩa từ trước bởi người biên soạn ra
ngôn ngữ C#. Những từ khóa đó không thể sử dụng như một định danh. Tuy nhiên,
nếu bạn muốn sử dụng từ khóa đó như định danh, bạn có thể thêm tiền tố @ vào
trước từ khóa. Trong C#, một số định danh có ý nghĩa đặt biệt trong phạm vi code,
chẳng hạn như get và set được gọi là từ khóa theo ngữ cảnh. Dưới đây là danh
sách từ khóa dành riêng và từ khóa ngữ cảnh trong C#:

Các từ khóa

abstract as base bool break byte case
catch char checked class const continue decimal
default delegate do double else enum event
explicit extern false finally fixed float for
foreach goto if implicit in in int
(generic
interface internal is lock long modifier) new
out out namespace params
null object operator (generic override
readonly modifier) sbyte
private protected public stackallo ref return struct
sealed c static string
short sizeof true uint
switch ushort try typeof void
ulong this throw using virtual
volatile
unchecked unsafe

while

Từ khóa ngữ cảnh

add alias ascending descending dynamic from get
global group orderby partial
into join let (type)
partial remove
(method) select set

Trang 28

Lập trình Hướng đối tượng

2.5. Kiểu dữ liệu của C#

2.5.1. Kiểu giá trị – value type

• Biến kiểu này có thể được gán giá trị trực tiếp. Chúng được bắt nguồn từ class

ValueType

• Kiểu giá trị chứa dữ liệu trực tiếp. Ví dụ như kiểu int, char và float lần lượt chứa

số, ký tự alphabet và số dấu chấm động. Khi ta khai báo một biến kiểu int, hệ

thống cấp phát vùng nhớ để chứa giá trị.

• Dưới đây là danh sách kiểu dữ liệu trong C#

Kiểu Biểu diễn Dãy giá trị Giá trị mặc
định

bool Giá trị Boolean True hoặc False False

byte Kiểu unsigned 0 tới 255 0
integer (8 bit)
char U +0000 tới U +ffff ‘\0’
Kiểu Unicode
decimal character (-7.9 x 1028 tới 7.9 x 1028) / 0.0M
double (16 bit) 100 to 28 0.0D
float 0.0F
Kiểu thập phân (+/-)5.0 x 10-324 tới (+/-)1.7 x
int (128 bit) 10308 0
long 0L
sbyte Kiểu double -3.4 x 1038 tới + 3.4 x 1038 0
short (64 bit) 0
uint -2,147,483,648 tới 0
ulong Kiểu float 2,147,483,647 0
ushort (32 bit) 0
-9,223,372,036,854,775,808 tới
Kiểu integer 9,223,372,036,854,775,807
(32 bit)
-128 tới 127
Kiểu signed
integer (64 bit) -32,768 tới 32,767

Kiểu signed 0 tới 4,294,967,295
integer (8 bit)
0 tới
Kiểu signed 18,446,744,073,709,551,615
integer (16 bit)
0 tới 65,535
Kiểu unsigned
integer (32 bit)

Kiểu unsigned
integer (64 bit)

Kiểu unsigned
integer (16 bit)

• Để biết chính xác độ lớn của một kiểu dữ liệu hoặc một biến bạn có thể sử dụng
phương thức sizeof. Biểu thức sizeof(type) trả về kích thước lưu trữ của đối tượng
hoặc kiểu theo đơn vị byte. Sau đây là một ví dụ để lấy kích thước của biến kiểu

int:

Trang 29

Trung tâm Tin học – Ngoại ngữ

using System;
namespace LTHDT
{

class Program
{

static void Main(string[] args)
{

Console.WriteLine("Kich thuoc kieu du lieu int: {0}",
sizeof(int));
Console.ReadLine();
}
}
}

Kích thước một số kiểu dữ liệu

Tên Kiểu Kích thước
8
sbyte System.SByte 16
32
short System.Int16 64
8
int System.Int32 16
32
long System.Int64 64
32
byte System.SByte 64

ushort System.UInt16 128

uint System.UInt32 16

ulong System.UInt64

float System.Single

double System.Double

decimal System.Decimal

bool System.Boolean

char System.Char

2.5.2. Kiểu tham chiếu – reference type

Kiểu này không chứa dữ liệu thực sự mà nó chứa một sự tham khảo trong biến. Nói
cách khác, nó tham chiếu tới một vùng nhớ. Kiểu tham chiếu có thể tạo ra nhiều biến cùng
tham chiếu đến một vùng nhớ. Nếu dữ liệu trong vùng nhớ bị thay đổi bới một biến nào
đó, thì những biến khác cũng sẽ thay đổi giá trị một cách tự động. Ví dụ object, dynamic
và string là kiểu tham chiếu.

Trang 30

Lập trình Hướng đối tượng

• Kiểu object: là class nền tảng cơ bản cho mọi kiểu dữ liệu trong C# common type
system (CTS). Object là một bí danh của class Object. Kiểu object có thể gán giá
trị của mọi kiểu dữ liệu khác, kiểu giá trị, kiểu tham chiếu, kiểu định nghĩa trước
hoặc do người dùng định nghĩa. Tuy nhiên trước khi gán giá trị, nó cần chuyển
kiểu. Khi chuyển kiểu value sang object, đó được gọi là boxing và mặt khác, khi
kiểu object được chuyển sang kiểu value được gọi là unboxing.

Ví dụ:

object obj;
obj = 100; // this is boxing

• Kiểu dynamic: ta có thể lưu bất kỳ kiểu giá trị nào trong biến kiểu dữ liệu động.
Kiểm tra kiểu cho kiểu của biến dynamic diễn ra vào thời gian chạy. Cú pháp để
khai báo biến kiểu dynamic là:

dynamic <variable_name> = value;

Kiểu dynamic tương tự kiểu object ngoại trừ kiểm tra kiểu cho kiểu biến object diễn
ra tại thời điểm biên dịch, nhưng trái lại kiểm tra kiểu cho kiểu dynamic diễn ra vào thời
gian chạy.

• Kiểu string: cho phép gán giá trị là chuỗi vào biến. Kiểu string là một bí danh của
class String. Nó có nguồn gốc từ kiểu object. Giá trị gán sử dụng một trong 2 cách
quoted và @quoted.

String str = "SV He thong thong tin";-> quoted
@"SV He thong thong tin";->@quoted

• Những kiểu tham chiếu do người dùng định nghĩa là class, interface hoặc
delegate.

2.5.3. Kiểu con trỏ – pointer type

Biến kiểu con trỏ lưu địa chỉ bộ nhớ của kiểu khác. Con trỏ trong C# có cùng khả
năng như con trỏ trong C hoặc C++. Cú pháp để khai báo biến kiểu con trỏ là: type*
identifier.

Trang 31

Trung tâm Tin học – Ngoại ngữ

Ví dụ:

char* cptr;
int* iptr;

2.5.4. Cách chuyển kiểu dữ liệu (Type Conversion) trong C#

Chuyển kiểu là chuyển đổi từ một kiểu dữ liệu này sang một kiểu dữ liệu khác. Nó
còn được gọi là ép kiểu. Có 2 cách chuyển giá trị từ kiểu này sang kiểu khác đó là:

• Chuyển kiểu ngầm định (implicit type-cast)
• Chuyển kiểu chỉ định (explicit type-cast)

Sau đây chúng ta cùng làm rõ nhé

• Chuyển kiểu ngầm định (implicit type-cast): một kiểu chuyển đổi an toàn được
xây dựng bởi C#, Không cần lập trình viên can thiệp.

Ví dụ như chuyển đổi từ kiểu có phạm vi nhỏ đến lớn hơn và chuyển đổi từ các lớp
kế thừa thành các lớp cơ sở.

Ví dụ: Ép từ kiểu nhỏ qua kiểu lớn:

int i = 59;
double x = i;

Ví dụ: Ép từ lớp dẫn xuất qua lớp cơ sở

string s = "Hello";
object o = s;

From To

sbyte short, int, long, float, double, decimal
byte
short short, ushort, int, uint, long, ulong, float, double,
decimal

int, long, float, double, decimal

ushort int, uint, long, ulong, float, double, decimal

int long, float, double, decimal

uint long, ulong, float, double, decimal

long, ulong float, double, decimal

float double

char ushort, int, uint, long, ulong, float, double, decimal

Trang 32

Lập trình Hướng đối tượng

• Chuyển kiểu tường minh (explicit type-cast): Loại này được thực hiện tường
minh bởi người dụng bằng cách sử dụng những hàm định nghĩa trước. Nó yêu cầu
một toán tử ép kiểu.

Ép từ kiểu lớn qua kiểu nhỏ: có thể mất giá trị.

double x = 74.86;
int i = (int)x; // i = 74

Ép từ lớp cơ sở qua lớp dẫn xuất:

• string s = "Hello";
• object o = s;
• string s2 = (string)o;

2.5.5. Một số phương thức chuyển kiểu được xây dựng sẵn

STT Phương thức Mô tả
1 ToBoolean Chuyển một kiểu sang kiểu Boolean nếu có thể.
2 ToByte Chuyển đổi một kiểu thành dạng byte
3 ToChar Chuyển thành kiểu ký tự Unicode nếu có thể.
4 ToDateTime Chuyển kiểu int hoặc string về dạng DateTime.
Chuyển kiểu dấu chấm động hoặc kiểu int sang kiểu
5 ToDecimal thập phân.
Chuyển thành kiểu double.
6 ToDouble Chuyển thành kiểu 16/32/64-bit integer
7 ToInt16/32/64 Chuyển thành kiểu byte có dấu.
8 ToSbyte Chuyển thành kiểu số dấu chấm động nhỏ.
9 ToSingle Chuyển kiểu bất kỳ thành chuỗi.
10 ToString Chuyển thành kiểu in/long/bit không dấu.
11 ToUInt16/32/64

Using Convert class: Thường dùng khi cần chuyển đổi giữa các kiểu không có liên
hệ với nhau.

Cú pháp:

Convert.toDataType(SourceValue)

Ví dụ: Chuyển từ chuỗi sang số thực

Trang 33

Trung tâm Tin học – Ngoại ngữ

string s1 = "56.8";
string s2 = "95";
double x = Convert.ToDouble(s1); // x = 56.8
int i = Convert.ToInt32(s2); // i = 95
byte j = Convert.ToByte(x); // j = 56, ít dùng

2.6. Biến trong C#

Một biến (Variable) có tên quy định, một vùng lưu trữ để chương trình có thể hoạt

động. Mỗi biến trong C # có một kiểu dữ liệu cụ thể, được xác định kích thước và bố trí

một bộ nhớ biến. Các giá trị có thể được lưu trữ trong bộ nhớ và thiết lập các phép tính áp

dụng cho các biến.

Nói tóm lại biến là:

• Biến là nơi lưu dữ liệu của chương trình
• Dữ liệu của biến

o Nằm trong bộ nhớ vật lý (physical RAM)
o Có thể thay đổi giá trị
• Phải khai báo trước khi dùng
o Identifier: tên để đại diện cho biến
o Data type: dạng lưu trữ dữ liệu của biến
• Phạm vi (scope)
o Được xác định bởi cặp dấu { và }
o Có thể chứa phạm vi nhỏ hơn
• Vị trí khai báo biến
o Trong thân phương thức: biến cục bộ
o Trong thân lớp: thuộc tính
• Biến trong C# chỉ có tác dụng trong phạm vi mà nó được khai báo

Các kiểu giá trị cơ bản được cung cấp bởi C# như:

Kiểu Ví dụ
Integral types
Floating point types sbyte, byte, short, ushort, int, uint, long, ulong,
and char

float and double

Decimal types decimal

Boolean types true or false values, as assigned

Trang 34

Lập trình Hướng đối tượng

Nullable types Nullable data types

C# cũng cho phép các biến kiểu giá trị định nghĩa như enum và kiểu tham chiếu như
class.

2.6.1. Khai báo biến

Cú pháp:

<data_type> <variable_list>;

Với data_type là một kiểu dữ liệu hợp lệ của C# như char, int, float, double hoặc bất
kỳ kiểu dữ liệu do người dùng định nghĩa và variable_list chứa một hoặc nhiều tên định
danh cách nhau bởi dấu phẩy.

Ví dụ:

int i, j, k;
char c, ch;
float f, salary;
double d;

Có thể khởi tạo biến khi khai báo:

int i = 100;

2.6.2. Khởi tạo biến

Hay còn gọi là gán giá trị cho biến với một dấu bằng theo sau là một biểu thức hằng
số. Cấu trúc lệnh khởi tạo là:

variable_name = value;

Biến có thể được khởi tạo khi nó được khai báo:

<data_type> <variable_name> = value;

Ví dụ: khởi tạo biến:

int d = 3, f = 5; /* khởi tạo biến d và f. */

byte z = 22; /* khởi tạo biến z. */

double pi = 3.14159; /* khởi tạo biến pi. */

Trang 35

Trung tâm Tin học – Ngoại ngữ

char x = 'x'; /* khởi tạo biến x */

Việc khởi tạo giá trị cho biến là một thao tác cần thiết và quan trọng, nếu không khởi
tạo giá trị cho biến thì chương trình sẽ gán một giá trị bất kỳ.

Ví dụ:

using System;
namespace LTHDT
{

class Program
{

static void Main(string[] args)
{

short a;
int b ;
double c;
/* khởi tạo giá trị cho biến */
a = 100;
b = 200;
c = a + b;
Console.WriteLine("a = {0}, b = {1}, c = {2}", a, b, c);
Console.ReadLine();
}
}
}

2.6.3. Nhận giá trị dữ liệu từ việc nhập liệu của user:

Class Console trong namespace System cung cấp phương thức Readline để nhận dữ
liệu từ người dùng và lưu nó vào biến.

Ví dụ:

int num;
num = Convert.ToInt32(Console.ReadLine());

Phương thức Convert.ToInt 32 được dùng để chuyển kiểu string sang int vì phương
thức readLine chỉ chấp nhận kiểu string.

Trang 36

Lập trình Hướng đối tượng

2.7. Hằng trong C#

Trong lập trình có một số biến có giá trị không đổi trong suốt chương trình, các biến
này thường được khai báo cố định được gọi là Hằng. ví dụ: số PI = 3.14

Hằng là một biến nhưng giá trị không thay đổi theo thời gian. Khi cần thao tác trên
một giá trị xác định ta dùng hằng. Khai báo hằng tương tự khai báo biến và có thêm từ
khóa const ở trước. Hằng một khi khởi động xong không thể thay đổi được nữa.

Hằng (Constant) có thể sử dụng cho bất kỳ kiểu dữ liệu cơ bản nào trong C#,
như hằng số nguyên, hằng số thực, hằng ký tự, hằng chuỗi …

Hằng được phân làm 3 loại:
• Giá trị hằng (literal)
• Biểu tượng hằng (symbolic constants)
• Kiểu liệt kê (enumerations)

2.7.1. Định nghĩa hằng trong C#

Hằng trong C# được định nghĩa bởi sử dụng từ khóa const.

Cú pháp:

const <data_type> <constant_name> = value;
const <Kieu du lieu> <ten cua bien Hang> = gia tri;

Giá trị hằng:

Ví dụ: x = 100; // 100 được gọi là giá trị hằng

Biểu tượng hằng: gán một tên hằng cho một giá trị hằng.

Ví dụ: const int HANG_SO = 100;

Kiểu liệt kê: là tập hợp các tên hằng có giá trị số không thay đổi (danh sách liệt kê)
Khai báo:

Trang 37

Trung tâm Tin học – Ngoại ngữ

<enum> <Tên_Kiểu_Liệt_Kê> ,
{

<tên_hằng_1> = <giá_trị_số_1>,
<tên_hằng_2> = <giá_trị_số_2>,
…
};

Ví dụ:

enum NhietDoNuoc
{

DoDong = 0, DoNguoi = 20,
DoAm = 40, DoNong = 60,
DoSoi = 100,
};

Chương trình phía dưới sẽ minh họa cách sử dụng hằng trong C#

Nhập vào bán kính, in ra diện tích hình tròn.

using System; {1}", r,
namespace LTHDT
{

class Program
{

static void Main(string[] args)
{

// khai bao hang so pi
const double pi = 3.14159;
// khai bao bien ban kinh
double r;
Console.WriteLine("Nhap vao ban kinh: ");
r = Convert.ToDouble(Console.ReadLine());
double areaCircle = pi * r * r;

Console.WriteLine("Ban kinh: {0}, Dien tich:
areaCircle);
Console.ReadLine();
}
}
}

Trang 38

Lập trình Hướng đối tượng

2.7.2. Hằng số nguyên trong C#

Hằng số nguyên có thể là decimal (cơ số 10), octal (cơ số 8) hay hexadecimal (cơ số
16). Giá trị có tiền tố (prefix) là 0 cho octal, là 0x hay 0X cho hexadecimal.

Một hằng số nguyên cũng có các hậu tố (suffix) U hay L thể hiện kiểu unsigned hay
long. Hậu tố có thể là chữ hoa hoặc chữ thường và có thể trong bất kỳ thứ tự nào.

212 /* Legal */
215u /* Legal */
0xFeeL /* Legal */
85 /* decimal */
0x4b /* hexadecimal */
30 /* int */
30u /* unsigned int */
30l /* long */
30ul /* unsigned long */

2.7.3. Hằng số thực trong C#

Một hằng số thực bao gồm phần nguyên (integer part), dấu chấm thập phân (decimal
point), phần lẻ (fraction part) và phần mũ (exponent part). Chúng ta có thể biểu diễn hằng
số thực theo dạng decimal hay dạng mũ.

Xét các ví dụ sau:

3.123 /* Legal */
334359E-5L /* Legal */
120E /* Illegal: incomplete exponent */
234f /* Illegal: no decimal or exponent */
.e11
/* Illegal: missing integer or fraction */

Khi thể hiện dạng decimal phải bao gồm dấu chấm thập phân, phần mũ hoặc cả hai.
Khi thể hiện dạng mũ phải gồm phần nguyên, phần lẻ hoặc cả hai. Dạng mũ đi kèm với kí
tự E hoặc e.

Trang 39

Trung tâm Tin học – Ngoại ngữ

2.7.4. Hằng ký tự trong C#

Các hằng kí tự trong C# mở đầu và kết thúc bởi dấu nháy đơn. Nếu hằng ký tự bắt
đầu với L (ví dụ L’x’) thì nó là kiểu wchar_t. Nếu không thì, nó là hằng ký tự kiểu char, ví
dụ như ‘x’.

Hằng kí tự có thể là một kí tự (như ‘X’), một escape sequence (như ‘\t’) hay một kí
tự mở rộng (như ‘\u02c0′).

Một số kí tự trong C# khi được đứng trước bởi dấu \ thì chúng sẽ mang một ý nghĩa
đặc biệt như bắt đầu dòng mới ‘\n’ hay tạo một tab ‘\t’. Chúng được biết như là escape
sequence (dãy thoát).

Dãy escape Ký tự
\’ ‘
\” “
\\ \
\0
\b Null
\n Backspace
\r Xuống dòng mới
\t Quay về đầu dòng

Tab

Ví dụ

using System;
namespace LTHDT
{

class Program
{

static void Main(string[] args)
{

Console.WriteLine("Hello\tSV HT Thong tin\n");
Console.ReadLine();
}
}
}

Trang 40

Lập trình Hướng đối tượng

2.7.5. Hằng chuỗi trong C#

Hằng chuỗi chứa trong dấu nháy kép, ví dụ “sinhvientot.net”. Một chuỗi sẽ chứa các
kí tự tương tự hằng ký tự, gồm các ký tự thuần, escape sequence, và các ký tự mở rộng.

Có thể ngắt một dòng dài thành nhiều dòng bằng cách sử dụng hằng chuỗi và phân
biệt chúng bởi các khoảng trắng.

Xét ví dụ một hằng chuỗi trong C# thể hiện theo 3 cách khác nhau:

"chao, SV He thong Thong tin"
"chao, \
SV He thong Thong in"
"chao, " "SV He thong" "Thong tin"
@"chao SV He thong Thong tin"

2.8. Toán tử trong C#

Toán tử là một ký hiệu nói cho bộ biên dịch biết sẽ thực hiện thao tác logic hay toán

học. C# cung cấp nhiều toán tử xây dựng sẵn:

• Toán tử số học
• Toán tử quan hệ
• Toán tử logic
• Toán tử trên bit
• Toán tử gán
• Toán tử hỗn hợp

2.8.1. Toán tử số học

Bảng dưới cho ta thấy những toán tử số học được hỗ trợ bởi C#. Với 2 biến A có giá
trị 10 và B có giá trị 20, ta có:

Toán tử Mô tả Ví dụ
+ Cộng hai toán hạng A + B = 30
– Toán hạng trước trừ toán hạng sau A – B = -10
* Nhân hai toán hạng A * B = 200
/ Chia tử số cho mẫu số B/A=2
% Phép toán lấy phần dư B%A=0

Trang 41

Trung tâm Tin học – Ngoại ngữ

++ Toán tử tăng, tăng giá trị nguyên lên 1 đơn vị A++ = 11

— Toán tử giảm, giảm giá trị nguyên xuống 1 đơn vị A– = 9

Ví dụ:

using System;
namespace LTHDT
{

class Program
{

static void Main(string[] args)
{

int a = 21;
int b = 10;
int c;
c = a + b;
Console.WriteLine("Line 1 - Value of c is {0}", c);
c = a - b;
Console.WriteLine("Line 2 - Value of c is {0}", c);
c = a * b;
Console.WriteLine("Line 3 - Value of c is {0}", c);
c = a / b;
Console.WriteLine("Line 4 - Value of c is {0}", c);
c = a % b;
Console.WriteLine("Line 5 - Value of c is {0}", c);
c = a++;
Console.WriteLine("Line 6 - Value of c is {0}", c);
c = a--;
Console.WriteLine("Line 7 - Value of c is {0}", c);
Console.ReadLine();
}
}
}

2.8.2. Toán tử quan hệ

Bảng dưới đây là các toán tử quan hệ được C# cung cấp. Với giá trị biến A là 10, biến
B là 20, ta có:

Toán tử Mô tả Ví dụ
== (A == B) is not true.
Kiểm tra nếu giá trị 2 biến bằng nhau thì
trả về giá trị true, ngược lại false

Trang 42

Lập trình Hướng đối tượng

!= Kiểm tra nếu giá trị 2 biến khác nhau thì (A != B) is true.
trả về giá trị true, ngược lại false

> Kiểm tra nếu giá trị biến bên trái lớn hơn (A > B) is not true.
biến bên phải thì trả về giá trị true,
ngược lại false

< Kiểm tra nếu giá trị biến bên trái bé hơn (A < B) is true.
biến bên phải thì trả về giá trị true,
ngược lại false

>= Kiểm tra nếu giá trị biến bên trái lớn hơn (A >= B) is not true.
hoặc bằng biến bên phải trả về giá trị
true, ngược lại false

<= Kiểm tra nếu giá trị biến bên trái bé hơn (A <= B) is true.
hoặc bằng biến bên phải trả về giá trị
true, ngược lại false

Ví dụ:

using System;
class Program
{

static void Main(string[] args)
{

int a = 21;
int b = 10;
if (a == b)
{

Console.WriteLine("Line 1 - a is equal to b");
}
else
{

Console.WriteLine("Line 1 - a is not equal to b");
}
if (a < b)
{

Console.WriteLine("Line 2 - a is less than b");
}
else
{

Console.WriteLine("Line 2 - a is not less than b");
}
if (a > b)
{

Console.WriteLine("Line 3 - a is greater than b");
}
else
{

Trang 43

Trung tâm Tin học – Ngoại ngữ

Console.WriteLine("Line 3 - a is not greater than b");
}
/* Lets change value of a and b */
a = 5;
b = 20;
if (a <= b)
{

Console.WriteLine("Line 4 - a is either less than or equal to ; b");
}
if (b >= a)
{

Console.WriteLine("Line 5-b is either greater than or equal to b");
}
}
}

2.8.3. Toán tử logic

Với biến A và biến B mang giá trị kiểu Boolean, bảng sau là các toán tử logic được
cung cấp bởi C#.

Toán tử Mô tả Ví dụ
&& (A && B) is false.
Gọi toán tử login AND, nếu cả hai toán
|| hạng đều đúng thì điều kiện đó đúng. (A || B) is true.
Gọi toán tử logic OR, nếu cả hai toán hạng
! đều sai thì điều kiện đó sai. !(A && B) is true.
Gọi toán tử logic NOT, dùng để đảo trạng
thái logic của toán hạng. Nếu một điều
kiện đúng sẽ chuyển thành sai khi dùng
toán tử này.

Ví dụ:

using System;
namespace LTHDT
{

class Program
{

static void Main(string[] args)
{

bool a = true;
bool b = true;
if (a && b)
{

Console.WriteLine("Line 1 - Condition is true");

Trang 44

Lập trình Hướng đối tượng

}
if (a || b)
{

Console.WriteLine("Line 2 - Condition is true");
}
/* lets change the value of&nbsp; a and b */
a = false;
b = true;
if (a && b)
{

Console.WriteLine("Line 3 - Condition is true");
}
else
{

Console.WriteLine("Line 3 - Condition is not true");
}
if (!(a && b))
{

Console.WriteLine("Line 4 - Condition is true");
}
Console.ReadLine();
}
}
}

2.8.4. Toán tử trên bit

Toán tử trên bit làm việc trên các bit. Bảng sau đây là bảng sự thật các toán tử trên
bit:

p q p&q p|q p^q

0 0 000

0 1 011

1 1 110

1 0 011

Với A=60, B=13, Chuyển hai số này sang nhị phân được:

• A = 0011 1100
• B = 0000 1101

Ta có:

Trang 45

Trung tâm Tin học – Ngoại ngữ

Toán tử Mô tả Ví dụ
&
| Toán tử nhị phân AND, copy bit 1 vào kết (A & B) = 12, tương

^ quả nếu nó tồn tại trong cả 2 toán hạng đương 0000 1100

~ Toán tử nhị phân OR, copy bit 1 vào kết (A | B) = 61, tương đương
<<
quả nếu nó tồn tại trong 1 trong 2 toán 0011 1101
>>
hạng.

Toán tử nhị phân XOR, copy bit 1 vào kết (A ^ B) = 49, tương

quả nếu nó chỉ tồn tại trong 1 trong 2 toán đương 0011 0001

hạng

Toán tử nhị phân bù 1 có tác dụng đảo bit (~A ) = 61, tương đương

1100 0011

Toán tử nhị phân dịch trái, dịch bit sang A << 2 = 240, tương

trái một số lượng bit bằng toán hạng bên đương 1111 0000

phải.

Toán tử nhị phân dịch phải, dịch bit sang A >> 2 = 15, tương đương

phải một số lượng bit bằng toán hạng bên 0000 1111

phải.

Ví dụ:

using System;

namespace LTHDT

{

class Program

{

static void Main(string[] args)

{

int a = 60; /* 60 = 0011 1100 */

int b = 13; /* 13 = 0000 1101 */

int c = 0;

c = a & b; /* 12 = 0000 1100 */

Console.WriteLine("Line 1 - Value of c is {0}", c );

c = a | b; /* 61 = 0011 1101 */

Console.WriteLine("Line 2 - Value of c is {0}", c);

c = a ^ b; /* 49 = 0011 0001 */

Console.WriteLine("Line 3 - Value of c is {0}", c);

c = ~a; /*-61 = 1100 0011 */

Console.WriteLine("Line 4 - Value of c is {0}", c);

c = a << 2; /* 240 = 1111 0000 */

Console.WriteLine("Line 5 - Value of c is {0}", c);

c = a >> 2; /* 15 = 0000 1111 */

Console.WriteLine("Line 6 - Value of c is {0}", c);

Console.ReadLine();

Trang 46

Lập trình Hướng đối tượng

}
}
}

2.8.5. Toán tử gán

Toán tử Mô tả Ví dụ
= Gán giá trị toán hạng bên phải cho toán hạng bên
+= trái C = A + B assigns value
-= Cộng toán hạng bên trái và toán hạng bên phải, of A + B into C
*= gán kết quả cho toán hạng bên trái. C += A is equivalent to
/= Toán hạng bên trái trừ toán hạng bên phải và gán C=C+A
%= kết quả này cho toán hạng bên trái. C -= A is equivalent to
<<= Nhân 2 toán hạng và gán kết quả này cho toán C=C–A
>>= hạng bên trái. C *= A is equivalent to
&= Toán hạng bên trái chia toán hạng bên phải và gán C=C*A
^= kết quả này cho toán hạng bên trái. C /= A is equivalent to
|= Toán hạng bên trái chia lấy dư toán hạng bên phải C=C/A
và gán kết quả này cho toán hạng bên trái. C %= A is equivalent to
Toán tử dịch trái. C=C%A
C <<= 2 is same as C =
Toán tử dịch phải C << 2
C >>= 2 is same as C =
Toán tử AND trên bit C >> 2
C &= 2 is same as C =
Toán tử gán và OR loại trừ trên bit C&2
C ^= 2 is same as C = C
Toán tử gán và OR bao hàm trên bit ^2
C |= 2 is same as C = C
|2

Ví dụ:

using System;
namespace OperatorsAppl
{

class Program
{

static void Main(string[] args)
{

int a = 21;
int c;
c = a;
Console.WriteLine("Line 1 - = Value of c = {0}", c);
c += a;

Trang 47

Trung tâm Tin học – Ngoại ngữ

Console.WriteLine("Line 2 - += Value of c = {0}", c);
c -= a;
Console.WriteLine("Line 3 - -= Value of c = {0}", c);
c *= a;
Console.WriteLine("Line 4 - *= Value of c = {0}", c);
c /= a;
Console.WriteLine("Line 5 - /= Value of c = {0}", c);
c = 200;
c %= a;
Console.WriteLine("Line 6 - %= Value of c = {0}", c);
c <<= 2;
Console.WriteLine("Line 7 - <<= Value of c = {0}", c);
c >>= 2;
Console.WriteLine("Line 8 - >>= Value of c = {0}", c);
c &= 2;
Console.WriteLine("Line 9 - &= Value of c = {0}", c);
c ^= 2;
Console.WriteLine("Line 10 - ^= Value of c = {0}", c);
c |= 2;
Console.WriteLine("Line 11 - |= Value of c = {0}", c);
Console.ReadLine();
}
}
}

2.8.6. Toán tử hỗn hợp

Có một số toán tử hỗn hợp quan trọng như sizeof, typeof và ? : được C# cung cấp:

Toán tử Mô tả Ví dụ
sizeof() Trả về kích cỡ của kiểu dữ liệu
typeof() Tả về kiểu của class sizeof(int), returns 4.
& Trả về địa chỉ của một biến
typeof(StreamReader);
* Trỏ đến một biến
&a; returns actual
? : Biểu thức điều kiện address of the
variable.
is Xác định một đới tượng có thuộc loại *a; creates pointer
nào đó named ‘a’ to a
variable.
If Condition is true ?
Then value X :
Otherwise value Y
If( Ford is Car) //
checks if Ford is an
object of the Car
class.

Trang 48

Lập trình Hướng đối tượng

as Ép kiểu mà không gây ra exeption nếu ép Object obj = new

kiểu thất bại. StringReader(“Hello”);

StringReader r = obj as
StringReader;

Ví dụ:

using System;
namespace LTHDT
{

class Program
{

static void Main(string[] args)
{

/* example of sizeof operator */
Console.WriteLine("The size of int is {0}", sizeof(int));
Console.WriteLine("The size of short is {0}",
sizeof(short));
Console.WriteLine("The size of double is {0}",
sizeof(double));

/* example of ternary operator */
int a, b;
a = 10;
b = (a == 1) ? 20 : 30;
Console.WriteLine("Value of b is {0}", b);
b = (a == 10) ? 20 : 30;
Console.WriteLine("Value of b is {0}", b);
Console.ReadLine();
}
}
}

2.8.7. Độ ưu tiên của toán tử

Độ ưu tiên xác định thứ tự thực hiện toán tử trong biểu thức trong một biểu thức. Điều
này ảnh hưởng đến kết quả của một biểu thức. Một số toán tử có độ ưu tiên cao hơn so với
những toán tử khác; Ví dụ, phép nhân có độ ưu tiên cao hơn so với phép cộng.

Ví dụ x = 7 + 3 * 2; : x được gán 13, không phải 20 vì toán tử * có độ ưu tiên cao
hơn +, vì vậy ưu tiên 3 *2 và sau đó 7 được thêm vào nó.

Trang 49

Trung tâm Tin học – Ngoại ngữ

Bảng sau đây là thứ tự ưu tiên của các toán tử. Ở đây, phía trên cùng của bảng là các
toán tử có độ ưu tiên cao nhất và giảm dần về cuối bảng. Trong một biểu thức, các toán tử
có độ ưu tiên cao được thực hiện đầu tiên.

Nhóm Toán tử Kết hợp
Postfix () [] -> . ++ – – Trái đến phải
Unary + – ! ~ ++ – – (type)* & sizeof Trái đến phải
Multiplicative */% Trái đến phải
Additive +– Trái đến phải
Shift << >> Trái đến phải
Relational < <= > >= Trái đến phải
Equality == != Trái đến phải
Bitwise AND & Trái đến phải
Bitwise XOR ^ Trái đến phải
Bitwise OR | Trái đến phải
Logical AND && Trái đến phải
Logical OR || Trái đến phải
Conditional ?: Phải đến trái
Assignment = += -= *= /= %=>>= <<= &= ^= |= Phải đến trái
Comma , Trái đến phải

Ví dụ:

using System;

namespace OperatorsAppl

{

class Program

{

static void Main(string[] args)

{

int a = 20;

int b = 10;

int c = 15;

int d = 5;

int e;

e = (a + b) * c / d; // ( 30 * 15 ) / 5

Console.WriteLine("Value of (a + b) * c / d is : {0}", e);

e = ((a + b) * c) / d; // (30 * 15 ) / 5

Console.WriteLine("Value of ((a + b) * c) / d is : {0}", e);

e = (a + b) * (c / d); // (30) * (15/5)

Trang 50