Giao trinh Lap trinh can ban B – Delphi 7

TRƯỜNG Đ I HỌC CẦN THƠ
KHOA CÔNG NGHỆ THÔNG TIN & TRUY N THÔNG
Giáo trình lý thuy t
LẬP TRÌNH CĂN BẢN B
MSMH: TN035
(Áp d ng cho ch ng trình tín chỉ)
Biên so n: ThS. VŨ DUY LINH
ThS. NGUYỄN NHỊ GIA VINH
ThS. LÊ THỊ DIỄM
Năm 2010

Bộ môn Tin H c ng Dụng – Khoa Khoa H c Tự Nhiên – Tr ng ĐHCT Trang i
M C L C
CảƯ NẢ 1: D LẤ U VÀ TảUẬT TOÁN................................................................1
I. Dữ liệu và thông tin: .............................................................................................1
I.1. Khái niệm.......................................................................................................1
I.2. Sơ đồ tổng quát c a một quá trình xử lý thông tin.........................................1
II. Từ bài toán t i ch ơng trình................................................................................1
II.1. Các giai đoạn giải một bài toán trên máy tính điện tử..................................1
II.2. Thuật toán (Algorithm).................................................................................2
CảƯ NẢ 2: BORLAND DELPHI .............................................................................5
I. Tổng quan v Delphi.............................................................................................5
I.1. Delphi là gì.....................................................................................................5
I.2. Các phiên bản c a Delphi ..............................................................................5
II. Môi tr ng phát tri n tích hợp (IDE) c a Delphi................................................5
II.1. Cửa sổ chính c a Delphi...............................................................................6
II.2. Thanh thực đơn chính và thanh công cụ.......................................................6
II.3. Bảng ch a các thành phần c a Delphi (Component Palette) .......................7
II.4. Cửa sổ thiết kế bi u mẫu (Form Designer) và Cửa sổ soạn thảo mư lệnh
(Code Editor) .................................................................................................8
II.5. Cửa sổ thuộc tính và sự kiện c a đ i t ợng (Object Inspector) ...................9
II.6. Cửa sổ liệt kê các đ i t ợng dạng cây (Object TreeView).........................10
III. Cấu trúc một dự án Delphi ...............................................................................10
III.1. Tập tin dự án: (Delphi project file) ...........................................................10
III.2. Các tập tin ch a mư lệnh (Unit file)..........................................................11
III.3. Các tập tin đặc tả bi u mẫu (Form file).....................................................11
III.4. Các tập tin tài nguyên (Windows Resource File)......................................13
IV. Các thao tác cơ bản trên Delphi .......................................................................14
IV.1. M một dự án m i.....................................................................................14
IV.2. L u dự án ..................................................................................................14
IV.3. L u Form (tập tin unit) v i tên khác.........................................................18
IV.4. L u dự án v i tên khác..............................................................................18
IV.5. Đóng dự án................................................................................................18
IV.6. Thoát kh i Delphi .....................................................................................18
CảƯ NẢ 3: CÁC TảÀNả PảẦN C B N CỦA NẢÔN NẢ DELPảẤ (OBJECT
PASCAL).............................................................................................19
I. Bộ chữ viết.........................................................................................................19
II. Từ khóa..............................................................................................................19
III. Tên danh hiệu tự đặt.........................................................................................20
IV. Hằng.................................................................................................................20
IV.1. Khái niệm..................................................................................................20
IV.2. Hằng tr ......................................................................................................20

Trang Bộ môn Tin H c ng Dụng – Khoa CNTT & TT – Tr ng ĐHCTii
IV.3. Hằng đ nh ki u: .........................................................................................21
V. Ki u (Type)........................................................................................................21
V.1. Ð nh nghĩa ..................................................................................................21
V.2. Cách khai báo .............................................................................................21
VI. Biến ..................................................................................................................22
VII. Bi u th c.........................................................................................................22
VII.1. Đ nh nghĩa................................................................................................22
VII.2. Th tự u tiên...........................................................................................22
VIII. Chuy n ki u (Typecast).................................................................................23
IX. L i chú thích và các chỉ dẫn biên d ch.............................................................24
X. Cấu trúc một dự án chế độ Form (Form Application)....................................25
CảƯ NẢ 4: CÁC KẤ U D LẤ U S C P CảUẨN, L Nả Đ N.......................26
I. Các ki u dữ liệu sơ cấp (Simple type) ................................................................26
I.1. Ki u s nguyên (Integer)..............................................................................26
I.2. Ki u ký tự (Char) .........................................................................................26
I.3. Ki u s thực (Real type)...............................................................................30
I.4. Ki u logic (Boolean)....................................................................................34
II. Câu lệnh (statement) ..........................................................................................34
III. Lệnh đơn (Simple statement) ...........................................................................35
IV. Lệnh gán (Assignment statement)....................................................................35
V. Lệnh g i th tục và hàm ....................................................................................35
VI. Lệnh Goto.........................................................................................................37
CảƯ NẢ 5: LẬP TRÌNả X LÝ SỰ KẤ N – CÁC TảÀNả PảẦN TRONẢ ẢẤAO
DẤ N DELPảẤ....................................................................................38
I. Lập trình xử lý sự kiện ........................................................................................38
I.1. L p (Class) và đ i t ợng (Object) ...............................................................38
I.2. Thuộc tính ....................................................................................................43
I.3. Ph ơng th c (Method) .................................................................................44
I.4. Sự kiện (Event).............................................................................................44
I.5. Xử lý sự kiện (Event Handlers)....................................................................45
I.6. Trình hỗ trợ mư lệnh (Code Completion /IntelliSense)................................46
II. Sinh mư tự động và một s cách sửa lỗi ............................................................46
II.1. Cách tự động sinh mư (generate code) trong Delphi .................................46
II.2. Cách sửa lỗi sinh mư trong Delphi.............................................................49
II.3. Thêm tập tin unit vào dự án........................................................................54
II.4. Viết lệnh sau khi thêm unit form vào dự án................................................58
II.5. Gỡ b tập tin unit form ra kh i dự án .........................................................62
III. Bi u mẫu (TForm)............................................................................................62
IV. Các thành phần (Component) giao diện phổ biến............................................68
IV.1. Nhãn (TLabel)...........................................................................................68
IV.2. Hộp văn bản (TEdit)..................................................................................71

Bộ môn Tin H c ng Dụng – Khoa Khoa H c Tự Nhiên – Tr ng ĐHCT Trang iii
IV.3. Nút lệnh (TButton)....................................................................................78
IV.4. Nhưn và Hộp nhập (TLabeledEdit)...........................................................80
IV.5. Hộp đánh dấu hay hộp ki m (TCheckbox) ...............................................81
IV.6. Nút tùy ch n (TRadioButton) ...................................................................87
IV.7. Nhóm tùy ch n (TRadioGroup)................................................................88
IV.8. Vùng văn bản (TMemo)............................................................................91
IV.9. Hộp danh sách (TListBox)........................................................................96
IV.10. TSpinEdit ..............................................................................................100
IV.11. Hộp danh sách đánh dấu (TCheckListBox) ..........................................101
IV.12. Hộp danh sách các khoá (TValueListEditor)........................................107
IV.13. Hộp liệt kê thả (TComboBox)...............................................................113
IV.14. L i chuỗi (TStringGrid)......................................................................118
IV.15. Bảng ch a các thành phần (TPanel)......................................................124
IV.16. Thanh thực đơn chính (TMainMenu)....................................................125
IV.17. Thực đơn (TMenuItem) ........................................................................126
IV.18. Menu đ i t ợng (TPopupMenu) ...........................................................134
CảƯ NẢ 6: CÁC L Nả CÓ C U TRÚC.............................................................138
I. Lệnh ghép (Compound statement)....................................................................138
II. Lệnh cấu trúc rẽ nhánh ....................................................................................138
II.1. Lệnh if ... then ... và lệnh if ... then ... else................................................138
II.2. Lệnh Case ... of.........................................................................................146
III. Cấu trúc lệnh lặp.............................................................................................149
III.1. Lệnh lặp có s lần xác đ nh tr c ...........................................................149
III.2. Lệnh lặp có s lần không xác đ nh tr c ................................................155
CảƯ NẢ 7: CảƯ NẢ TRÌNả CON....................................................................164
I. Khái niệm..........................................................................................................164
II. Hàm..................................................................................................................165
III. Th tục............................................................................................................172
IV. Truy n tham s ...............................................................................................175
IV.1. Đ nh ki u và không đ nh ki u cho tham s hình th c.............................175
IV.2. Truy n bằng tham tr (Value parameter).................................................177
IV.3. Truy n bằng tham biến (Variable parameter) .........................................179
IV.4. Truy n bằng tham s hằng (Constant parameter) ...................................181
IV.5. Truy n bằng tham s xuất (Out parameter) ............................................184
V. Ch ơng trình con đệ quy.................................................................................190
CảƯ NẢ 8: KẤ U LẤ T KÊ, MẤỀN CON, TẬP ảỢP ..........................................194
I. Ki u vô h ng liệt kê (Enumerated scalar type) ..............................................194
I.1. Khái niệm...................................................................................................194
I.2. Cách khai báo: Có hai cách khai báo là gián tiếp và trực tiếp ...................194
I.3. Một s hàm chuẩn áp dụng cho ki u vô h ng .........................................195

Trang Bộ môn Tin H c ng Dụng – Khoa CNTT & TT – Tr ng ĐHCTiv
II. Ki u mi n con (Subrange types)......................................................................196
II.1. Khái niệm..................................................................................................196
II.2. Cách khai báo............................................................................................196
III. Ki u tập hợp (Set)...........................................................................................197
III.1. Khái niệm ................................................................................................197
III.2. Cách khai báo ..........................................................................................197
III.3. Mô tả tập hợp...........................................................................................198
III.4. Một s phép toán trên ki u tập hợp .........................................................198
CảƯ NG 9: KẤ U M NẢ.....................................................................................208
I. Khái niệm v mảng (Array-type data) ..............................................................208
II. Mảng tĩnh (Static array)...................................................................................208
II.1. Mảng một chi u (One-Dimensional array)...............................................208
II.2. Mảng nhi u chi u (Multi-Dimensional array)..........................................213
II.3. Mảng hai chi u..........................................................................................215
III. Mảng động (Dynamic array) ..........................................................................222
III.1. Mảng động một chi u.............................................................................222
III.2. Mảng động nhi u chi u ...........................................................................227
III.3. Hằng mảng...............................................................................................228
CảƯ NẢ 10: KẤ U CảUỖẤ KÝ TỰ ......................................................................229
I. Các loại chuỗi ký tự trong Object Pascal ..........................................................229
I.1. Chuỗi ngắn (ShortString) ...........................................................................229
I.2. Chuỗi dài 1 byte (AnsiString) ....................................................................230
I.3. Chuỗi dài 2 byte (WideString) ...................................................................232
II. Các thao tác trên chuỗi.....................................................................................232
II.1. Phép toán cộng chuỗi................................................................................232
II.2. Phép toán so sánh......................................................................................232
II.3. Các th tục và hàm chuẩn xử lý chuỗi ký tự.............................................234
PảỤ LỤC........ .........................................................................................................246
TÀẤ LẤ U TảAM Kả O ..........................................................................................252
B N QUYỀN TÁC ẢẤ ............................................................................................252

Ch ơng 1: Dữ liệu và Thuật toán
Bộ môn Tin H c ng Dụng – Khoa CNTT & TT – Tr ng ĐHCT Trang 1
CH NG 1: D LI U VẨ THU T TOÁN
I. D li u vƠ thông tin:
I.1. Khái ni m
Dữ liệu (Data) là các sự kiện không có cấu trúc, không có ý nghĩa rõ ràng tại th i
đi m xét.
Thông tin (Information) là một khái niệm trừu t ợng đ ợc th hiện qua các thông
báo, các bi u hiện,... đem lại một nhận th c ch quan cho một đ i t ợng nhận tin. Thông
tin là dữ liệu đư đ ợc xử lý xong, mang ý nghĩa rõ ràng tại th i đi m xét.
Một hệ th ng thông tin (Information system) là một tiến trình ghi nhận dữ liệu, xử lý
nó và cung cấp tạo nên dữ liệu m i có ý nghĩa thông tin, liên quan một phần đến một tổ
ch c, đ trợ giúp các hoạt động liên quan đến tổ ch c.
I.2. S đồ t ng quát c a một quá trình x lỦ thông tin
M i quá trình xử lý thông tin bằng máy tính hay bằng con ng i đ u đ ợc thực hiện
theo một quy trình sau:
Dữ liệu đ ợc nhập đầu vào (Input). Máy tính hay con ng i sẽ thực hiện quá trình
xử lý nào đó đ nhận đ ợc thông tin đầu ra (Output).
Hình 1: Mô hình tổng quát quá trình xử lý thông tin
II. T bƠi toán tới ch ng trình
Trong cuộc s ng, chúng ta có rất nhi u bài toán cần phải giải quyết. Sử dụng máy
tính điện tử đ giải các bài toán là đi u rất hiệu quả do khả năng tính toán c a máy tính. Đ
máy tính có th hi u đ ợc, chúng ta cần phải có những b c giải cụ th c a bài toán một
cách đúng logic, từ đó sử dụng một ngôn ngữ ch ơng trình hay phần m m lập trình đ
h ng dẫn máy tính thực hiện các thao tác cần thiết đ tìm ra kết quả c a bài toán.
II.1. Các giai đo n gi i một bƠi toán trên máy tính đi n t
Ð giải quyết một bài toán trên máy tính điện tử, cần qua các giai đoạn sau:
- Tìm hi u mục tiêu chính c a bài toán: dữ liệu nhập vào và kết quả xuất.
- Xây dựng một chuỗi thao tác tính toán theo một th tự logic, g i là thuật giải.
- Lập ch ơng trình diễn tả chi tiết các b c tính theo thuật giải.
- Nhập ch ơng trình vào máy tính, thông d ch và chạy thử đ sửa chữa lỗi.
- Thực hiện giải bài toán v i s liệu thu thập đ ợc và ghi nhận kết quả.
NH P D LI U
(INPUT)
X Lụ
(PROCESSING)
XU T D LI U
(OUTPUT)
L U TR (STORAGE)

Trang Bộ môn Tin H c ng Dụng – Khoa CNTT & TT – Tr ng ĐHCT2
- Thử nghiệm v i nhi u tr ng hợp dữ liệu nhập khác nhau c a bài toán đ
ch ơng trình ki m tra đúng trong m i tr ng hợp tổng quát.
- Phân tích kết quả và hoàn chỉnh ch ơng trình.
Trong các b c trên, việc thiết kế thuật toán là giai đoạn quan tr ng nhất.
II.2. Thu t toán (Algorithm)
II.2.1. ợịnh nghĩa
Thuật toán là một ph ơng pháp trình bày các b c giải quyết một hay nhi u bài toán
theo một tiến trình xác đ nh.
II.2.2. Đặc tính c a thu t toán
- Tính xác đ nh: Các thao tác c a thuật toán là rõ ràng và chắc chắn thực hiện đ ợc
đ dẫn đến kết quả nào đó.
- Tính hữu hạn và dừng: thuật toán phải có một s b c giải nhất đ nh và cu i
cùng phải có kết thúc đi m dừng.
- Tính kết quả: V i dữ liệu hợp lý, thuật toán phải cho kết quả th a yêu cầu.
- Tính phổ dụng: Thuật toán phải giải đ ợc nhi u bài toán có cùng cấu trúc v i các
dữ liệu khác nhau và đ u dẫn đến một kết quả mong mu n.
- Tính hiệu quả: Thuật giải phải đơn giản, dễ hi u trong các b c giải, t i thi u
hoá bộ nh và th i gian thực hiện.
- Tính hình th c: Các b c trong thuật toán là máy móc, nghĩa là nó phải thực hiện
đúng nh quy đ nh mà không cần biết đến mục tiêu cu i cùng.
II.2.3. Các ph ng pháp bi u di n thu t toán
Thuật toán có th đ ợc diễn giải thông qua 3 ph ơng pháp phổ biến, đó là sử dụng
ngôn ngữ tự nhiên, ngôn ngữ giả và ngôn ngữ sơ đồ (l u đồ).
II.2.3.1 Ngôn ngữ tự nhiên
Là cách diễn đạt tự nhiên c a con ng i bằng ngôn ngữ c a mình đ mô tả các b c
giải bài toán.
Ví d 1: Mô tả thuật toán theo ngôn ngữ tự nhiên c a ph ơng trình ax + b = 0
- B c 1: Nhập vào 2 hệ s a và b.
- B c 2: Xét đi u kiện a = 0?
Nếu đúng là a = 0, thì đi đến b c 3, nếu không (nghĩa là a  0) thì đi đến b c 4.
- B c 3: Xét đi u kiện b = 0?
Nếu b = 0, thì báo ph ơng trình có vô s nghiệm. Ði đến b c 5.
Nếu b  0, thông báo ph ơng trình vô nghiệm. Ði đến b c 5.
- B c 4: Thông báo ph ơng trình có một nghiệm duy nhất là x = - b/a.
- B c 5: Kết thúc thuật toán.

II.2.3.2 Ngôn ngữ giả
Là cách diễn đạt các b c giải c a bài toán thông qua một s câu lệnh có cấu trúc
(nh câu lệnh if..then..else, for..to..do, while..do, repeat..until)
Ví d 2: Mô tả thuật toán theo ngôn ngữ giả c a ph ơng trình bậc nhất ax + b = 0
- B c 1: Nhập vào 2 hệ s a và b.
- B c 2: if (a=0) then
if (b=0) then ph ơng trình vô s nghiệm
else ph ơng trình vô nghiệm
else ph ơng trình có một nghiệm duy nhất x = -b/a
- B c 3: Kết thúc thuật toán.
II.2.3.3 Ngôn ngữ lưu đồ (Flowchart)
Là cách diễn đạt các b c giải c a bài toán thông qua các ký hiệu c a l u đồ. Một s
qui c ký hiệu l u đồ:
KỦ hi u Mô t
Đi m bắt đầu hoặc kết thúc thuật toán
Thao tác nhập hay xuất
Kh i xử lý công việc
Kh i quyết đ nh ch n lựa
Đi m n i
Chuẩn b
Tập hợp các tập tin dữ liệu
Kh i ch ơng trình con
Các ghi chú, giải thích
Dòng tính toán, thao tác c a ch ơng trình
Hình 2: Các ký hiệu l u đồ

Ví d 3: Mô tả thuật toán theo ngôn ngữ l u đồ c a ph ơng trình ax + b = 0
Hình 3: L u đồ thuật toán PTB1
Bắt đầu
Nhập a,b
a=0
b=0
Ph ơng trình
vô s nghiệm
Ph ơng trình
vô nghiệm
x := -b/a
Kết thúc
Đúng
Đúng
Sai
Sai
Xuất nghiệm x

Ch ơng 2: Borland Delphi
CH NG 2: BORLAND DELPHI
I. T ng quan v Delphi
I.1. Delphi là gì
Delphi là một ngôn ngữ lập trình cấp cao, có trình biên d ch hoàn hảo, hỗ trợ mạnh
v các ki u dữ liệu có cấu trúc và thiết kế h ng đ i t ợng dựa trên n n tảng ngôn ngữ lập
trình h ng đ i t ợng (OOP: Object-Oriented Programming) c a Borland Pascal. Ngày
nay, Delphi đư đ ợc phát tri n thành môi tr ng xây dựng ng dụng t c th i RAD (Rapid
Application Development). Từ những công cụ c a RAD, bạn có th giải quyết những vấn
đ ph c tạp trong qua trình phát tri n phần m m nh : lập trình ng dụng v cơ s dữ liệu
(Database), lập trình mạng và Internet (Internet/Networking), lập trình Multimedia
(Animation, sound), lập trình trò chơi (Game) cũng nh đồ h a (Graphic) hoặc lập trình hệ
th ng, v.v… không những trên n n Windows mà còn cho cả Linux và .NET. Trong giáo
trình này, chúng tôi chỉ gi i thiệu các khái niệm c a Delphi trong phạm vi hệ đi u hành
Windows. V i khả năng mạnh nh vậy c a Delphi, bạn an tâm khi dùng nó đ tri n khai
các ng dụng c a bạn quy mô nh hay l n. Đi u cần quan tâm Delphi là một ngôn ngữ
rất thân thiện v i ng i dùng, phù hợp cho những ng i bắt đầu làm quen v i nó cũng nh
những nhà lập trình chuyên nghiệp.
Vì đây là giáo trình đ ợc soạn dành cho đ i t ợng là các sinh viên bắt đầu h c Tin
h c Đại c ơng thông qua ngôn ngữ Delphi. Do vậy, giáo trình này chỉ gi i thiệu những
khái niệm căn bản nhằm giúp cho ng i h c có một s kiến th c nhất đ nh đ đ vận dụng
vào giải các bài toán hoặc viết những ch ơng trình ng dụng nh . Các ch ơng trong giáo
trình này sẽ trình bày các phần tử cơ bản c a Delphi đ tạo một ch ơng trình chạy trên
n n Windows, đó chính là môi tr ng phát tri n tích hợp IDE (Integrated Development
Environment) và ngôn ngữ h ng đ i t ợng Borland Pascal. Các bạn sẽ đ ợc h c cách
thiết kế (Design), phát tri n (Develop) hay viết mư lệnh (Code), và ki m tra lỗi (Test)
ch ơng trình ng dụng b i việc sử dụng Delphi.
I.2. Các phiên b n c a Delphi
Ti n thân c a Delphi chính là ngôn ngữ đ i t ợng Borland Pascal, và đến ngày nay
Delphi đư có một quá trình phát tri n vững mạnh từ phiên bản 1 (Delphi1) vào năm 1995,
đến phiên bản 8 (Delphi for .NET) năm 2005. Trong giáo trình này, chúng tôi th ng nhất
trình bày v i các bạn Delphi 7. Đây là phiên bản phù hợp nhất và dễ dùng nhất hiện nay
cho các bạn, đ i t ợng là các sinh viên h c Tin h c Đại c ơng.
II. Môi tr ờng phát tri n tích h p (IDE) c a Delphi
Môi tr ng soạn thảo và thiết kế ng dụng c a Delphi 7 chia ra làm 5 phần: Cửa sổ
chính c a ch ơng trình Delphi, cửa sổ thiết kế bi u mẫu (Form designer), cửa sổ liệt kê các
thành phần, đ i t ợng dạng cây (Object TreeView), cửa sổ thiết lập thuộc tính đ i t ợng
(Object Inspector), và cửa sổ soạn thảo mư lệnh (Code Editor). V i môi tr ng IDE này,
bạn sẽ có một giao diện (Interface) đ thiết kế (Design), biên d ch (Compile) và gỡ lỗi
(Debug) dự án mà bạn đang phát tri n.

Hình 1: Giao diện c a dự án m i tạo trong Delphi 7
 Cửa sổ chính c a Delphi 7
 Cửa sổ thiết kế bi u mẫu
 Cửa sổ liệt kê các đ i t ợng dạng cây
 Cửa sổ thiết lập các thuộc tính và sự kiện c a đ i t ợng
 Cửa sổ soạn thảo mư lệnh
II.1. C a s chính c a Delphi
Cửa sổ chính c a Delphi chính là cửa sổ có thành tiêu đ ch a tên dự án (Project
name) mà bạn đang phát tri n, nó bao gồm thực đơn chính (Main menu), thanh công cụ
(Toolbar), và bảng thành phần (Component palette).
II.2. Thanh th c đ n chính vƠ thanh công c
II.2.1. Thanh th c đ n chính
Bao gồm các thực đơn thả xu ng (Drop-down menu) nh : File, Edit, Search,
View,… và Help. Trong mỗi menu thả xu ng có nhi u ch c năng khác nhau nh : m một
dự án m i, l u dự án, biên d ch, gỡ lỗi, chạy ch ơng trình,… mà giáo trình sẽ trình bày chi
tiết phần sau.






Hình 2: Thanh thực đơn chính
II.2.2. Thanh công c (Toolbars)
Trong Delphi có nhi u thanh công cụ, nh : thanh công cụ chuẩn (Standard), thanh gỡ
lỗi (Debug), thanh hi n th (View),… Mỗi nút (Button) trên thanh công cụ th ng là một
thao tác hay một lệnh mà khi ta Click vào nó sẽ thi hành, ví dụ nh : Biên d ch (Compile),
chạy (Run) hoặc kết thúc chạy ch ơng trình (Program Reset), …
Hình 3: Các thanh công cụ
II.3. B ng chứa các thƠnh ph n c a Delphi (Component Palette)
Thành phần (Component), hay còn đ ợc g i là đi u khi n, chính là đ i t ợng có sẵn
trong Delphi mà bạn có th thao tác trên nó trong th i đi m thiết kế form. Có 2 loại thành
phần, đó là thành phần trực quan (visual component): nhìn thấy khi chạy ch ơng trình, và
thành phần không trực quan (nonvisual component): không nhìn thấy khi chạy ch ơng
trình. Mỗi thành phần có một s tính chất riêng, và đ ợc quản lý thông qua các thuộc tính
(Properties), sự kiện (Events) và các ph ơng th c (Methods). Các thuộc tính này giúp bạn
có th quản lý và đi u khi n ch ơng trình c a bạn. Khi bạn đặt một thành phần lên form,
thì nó sẽ xuất hiện trong cửa sổ Object TreeView và Object Inspector – sẽ đ ợc trình bày
phần sau.
Trong bảng ch a các thành phần có nhi u thẻ (tab) khác nhau, nh thẻ Standard,
Addition, Win32, System, Data Access, ADO, Internet, Rave, Server,… Trên mỗi thẻ ch a
các bi u t ợng (icon) đại diện cho các thành phần.
Hình 4: Bảng ch a các thành phần trong thẻ Standard

II.4. C a s thi t k bi u m u (Form Designer) vƠ C a s so n th o mư l nh
(Code Editor)
II.4.1. C a s thi t k bi u m u
Khi bạn tạo một dự án m i, môi tr ng phát tri n tích hợp IDE c a Delphi sẽ tự tạo
ra một bi u mẫu m i (Form) đ bạn tùy nghi thiết lập các giá tr c a thuộc tính dựa trên
Properties, và các th tục sự kiện dựa vào Events, đ ợc xác đ nh trong Object Inspector,
cho việc thiết kế ch ơng trình. Trong hầu hết tr ng hợp, một dự án th ng có ít nhất một
form. Cùng v i các thành phần trên bảng các thành phần, bạn sẽ thiết kế đ ợc một giao
diện cho ch ơng trình mà bạn đang xây dựng là thân thiện nhất cho ng i sử dụng.
TLabel (StdCtrls) TEdit (StdCtrls)
TButton (StdCtrls)
TMemo (StdCtrls)
Hình 5: Form “Giai phuong trinh bac nhat” và các Components
Các giá tr c a form và các giá tr c a các component đặt trên form đ ợc l u trong
tập tin form (form file) và có phần m rộng .dfm, v i phần tên đ ợc xác đ nh gi ng nh
phần tên c a đơn v ch ơng trình form. Tập tin form này ch a đựng các giá tr c a form
cũng nh các giá tr c a các component mà ta đặt trên form trong quá trình thiết kế.
II.4.2. C a s so n th o mư l nh
Mỗi một form trong dự án đ ợc quản lý trong một tập tin đơn v ch ơng trình (Unit
file/ Form unit), tên tập tin c a form unit này đ ợc đặt tên trong qua trình l u (Save) và có
phần m rộng là .pas, nội dung c a tập tin form unit này ch a đựng các khai báo thông
th ng c a unit (sẽ đ cập chi tiết phần sau) cũng nh các hàm sự kiện t ơng ng cho
form và các component trên nó.

Hình 6: Cửa sổ soạn thảo mư lệnh cho form unit untPtb1.Pas
Đ chuy n đổi giữa cửa sổ soạn thảo mư lệnh v i cửa sổ thiết kế bi u mẫu, ta sử
dụng ch c năng View/Toggle Form/Unit từ main menu hoặc gõ phím ch c năng F12.
Ví d 1: Trong project “Giai phuong trinh bac nhat” trên, ta l u unit file v i tên
untPtb1.Pas và form file sẽ đ ợc tự động đặt theo là untPtb1.dfm
II.5. C a s thuộc tính vƠ s ki n c a đối t ng (Object Inspector)
Hình 7: thẻ Properties c a Form và thẻ Events c a Button
Cửa sổ Object Inspector c a form hay component đ u có 2 thẻ: Properties và Events.
Thẻ Properties dùng đ xác đ nh các tính chất c a đ i t ợng nói chung (Form, component)
hiện hành một cách trực quan, chẳng hạn nh Caption, Name, Position, Visible,… Thẻ
Events dùng đ lập trình sự kiện: xác đ nh những đáp ng c a đ i t ợng khi nhận tác động

từ chuột (Mouse) hoặc bàn phím (Keyboard) nh : nhắp chuột (OnClick), đóng cửa sổ
(OnClose), gõ phím Enter (OnEnter),… thông qua các th tục sự kiện.
Khi thay đổi các giá tr trong thẻ Properties trong quá trình thiết kế, thì mư lệnh
t ơng ng c a đ i t ợng sẽ đ ợc thay đổi theo trong cửa sổ soạn thảo mư lệnh.
II.6. C a s li t kê các đối t ng d ng cơy (Object TreeView)
Hình 8: Cửa sổ liệt kê các đ i t ợng dạng cây trên frmPTB1
Object TreeView liệt kê các thành phần trực quan và không trực quan mà bạn đặt
chúng trên form hiện hành. Mỗi th i đi m chỉ có một form duy nhất đ ợc liệt kê.
III. C u trúc một d án Delphi
III.1. T p tin d án: (Delphi project file)
Hình 9: Tập tin dự án prjPtb1.dpr

Khi bạn bắt đầu m m i một ch ơng trình ng dụng bằng thao tác:
File/New/Application, Delphi 7 sẽ tự động tạo ra một tập tin dự án có tên mặc nhiên ban
đầu là Project1. Khi bạn l u dự án, Delphi sẽ lần l ợt nhắc bạn đặt tên cho các form unit
và tên dự án. ví dụ giải ph ơng trình bậc nhất trên, form unit có tên là untPTB1.pas
và tên dự án là prjPTB1.dpr. Phần tên c a tập tin dự án cũng chính là tên c a ch ơng
trình, đ ợc khai báo sau từ khóa program.
Bạn chú ý: ti n t c a unit file là unt, còn project file là prj. Ví dụ nh untPTB1.pas
và prjPTB1.dpr
Đ hi n th tập tin dự án, ta vào ch c năng Project/View Source
Mư lệnh nguồn (Source code) đ ợc Delphi tự động sinh ra trong tập tin dự án bao
gồm:
- Tên ch ơng trình, đ ợc khai báo b i từ khóa program, đây cũng chính là tên
ch ơng trình ng dụng (Application file).
- Các câu lệnh chỉ dẫn t i các form và các unit đ ợc sử dụng trong dự án đ ợc
khái báo sau từ khóa uses.
- Chỉ th biên d ch {$R *.res}: sử dụng các tập tin tài nguyên (Resources).
- Kh i lệnh thân ch ơng trình chính, bắt đầu b i từ khóa begin và kết thúc là end.
+ Initialize : Kh i động ch ơng trình ng dụng.
+ CreateForm : Tạo form chính (Main form).
+ Run : Chạy ch ơng trình ng dụng.
Tập tin dự án là tập tin trung tâm c a một dự án đ ợc tri n khai b i Delphi. Tập tin
này ch a đựng các tham khảo (Reference) t i tất cả các file khác trong dự án và liên kết
v i các form cũng nh tập tin đơn v (Unit file) kèm theo c a form. Khi ch ơng trình đ ợc
thi hành (Run, execute), nó sẽ bắt đầu từ tập tin dự án này.
Tập tin này đ ợc tự động sinh ra, và nh vậy, bạn không nên thay đổi nội dung c a
nó ngoại trừ trong những tr ng hợp cần thiết.
Tập tin dự án đ ợc l u v i phần m rộng .dpr
III.2. Các t p tin chứa mư l nh (Unit file)
Trong mỗi ng dụng đ ợc viết b i Delphi th ng gồm có 1 tập tin dự án (Project file) và
nhi u tập tin đơn v ch ơng trình (Unit file) – xem lại phần "Cửa sổ soạn thảo mư lệnh"
phần trên. Mỗi khi ta thêm vào m i một form (hoặc Data Module, Frame,…) thì một tập
tin unit sẽ đ ợc tạo ra. Thông th ng một dự án đ ợc tri n khai trong thực tế sẽ có nhi u
tập tin unit này. Nội dung tập tin unit này ch a đựng mư lệnh c a ch ơng trình và c a các
sự kiện đi u khi n (Event handles) trên form cũng trên các thành phần (Component) mà
chúng đ ợc đặt trên nó.
Unit file đ ợc l u v i phần m rộng là .pas
III.3. Các t p tin đặc t bi u m u (Form file)
Nội dung c a tập tin này xác đ nh một cách chi tiết các tính chất hay thuộc tính
(Properties) c a form và tất cả các đ i t ợng (nói chung) lập trình viên đư thiết kế. Tập tin
này luôn đi kèm v i một tập tin unit file.
Form file đ ợc l u v i phần m rộng là .dfm
Đ hiện th nội dung tập tin này, bạn RClick trên form rồi ch n View as Text.

Ví d 2: Xem nội dung tập tin form file có tên untPTB1.dfm nh sau:
Từ chế độ thiết kế c a form có tên là frmPTB1, bạn RClick trên form rồi ch n View
as Text nh hình sau:
Hình 10: Chuy n cách hi n th từ dạng Form sang dạng Text
Nội dung c a tập tin untPTB1.dfm dạng văn bản sẽ có nh hình sau:
Hình 11: Hi n th dạng text c a untPTB1.dfm
Đ chuy n đổi từ cách hiện th dạng Text sang dạng Form, ta sử dụng ch c năng
RClick ch n ch c năng View as Form hay tổ hợp phím Alt+F12:

Hình 12: Chuy n cách hi n th dạng Text sang dạng Form.
III.4. Các t p tin tƠi nguyên (Windows Resource File)
Tập tin này cũng đ ợc tự động sinh ra. Nội dung c a nó ch a đựng các thông tin v
phiên bản (Version) cũng nh bi u t ợng c a ng dụng (Application icon) dạng mư nh
phân.
Tập tin này có phần m rộng .res
Ta có th m tập tin tài nguyên này chế độ thiết kế (Design) bằng ch ơng trình
Image Editor đ ợc kèm theo bộ Delphi.
Hình 13: Giao diện ch ơng trình xử lý ảnh – Image Editor

IV. Các thao tác c b n trên Delphi
IV.1. Mở một d án mới
Đ tạo một dự án m i, bạn sử dụng lệnh File/New/Application. Hình ảnh một dự án
m i tạo nh hình sau:
Hình 14: Dự án m i tạo
IV.2. L u d án
Một dự án trong Delphi sẽ sinh ra khá nhi u tập tin. Do vậy, khi l u dự án, bạn cần
phải tạo ra 1 th mục đ ch a các tập tin trong dự án đó. Quá trình l u dự án nh sau:
Đ l u một dự án, bạn sử dụng lệnh: File/Save All hay tổ hợp phím Shift+Ctrl+S.
Thông th ng bạn phải l u các form tr c (mỗi form là một tập tin unit có phần m rộng
là pas), rồi sau đó m i l u tập tin dự án (phần m rộng là dpr).
Ví d 3: L u dự án hi n th câu "Hello world!..." chỉ có một form, vào th mục
S:HelloWorld nh sau:
Hình 15: Cửa sổ thiết kế Form

- Từ cửa sổ thiết kế, ch n lệnh File/Save All, Delphi sẽ xuất hiện ra cửa sổ "Save
Uniti File" (v i i =1..n) nh sau:
Hình 16: Hộp thoại Save Uniti As
Click ch n hộp liệt kê thả "Save in" đ ch n ổ đĩa S: nh hình sau:
Hình 17: Hộp thoại Save Uniti As: Chọn đĩa

Tiếp đến, Click ch n bi u t ợng "Create New Folder" đ tạo th mục m i ch a các
tập tin c a dự án mà bạn mu n l u (th mục HelloWorld).
Hình 18: Hộp thoại Save Uniti As: T o th m c
Sau khi tạo th mục xong, bạn Click nút lệnh Open đ m th mục HelloWorld ra.
Hình 19: Hộp thoại Save Uniti As: Mở th m c

Tiếp đến, bạn gõ tên tập tin unit mà bạn mu n l u vào trong hộp liệt kê thả "File
name", đây là tên untHelloWorld.pas, rồi Click Save.
Hình 20: Hộp thoại Save Uniti As: Nh p vƠo tên t p tin unit
Đến đây, Delphi sẽ tiếp tục xuất hiện hộp thoại "Save Projecti As" đ bạn l u tập tin
dự án. Bạn gõ vào tên tập tin dự án vào trong hộp liệt kê thả "File name", ví dụ này là tên
prjHelloWorld.dpr, và Click Save.
Hình 21: Hộp thoại Save Projecti As: Nh p tên t p tin d án

Dự án đư đ ợc l u và đặt tên xong. Sau việc này, nếu bạn có chỉnh sửa ch ơng trình,
đ l u lại những sự thay đổi này, bạn chỉ cần ra lệnh File/Save All đ Delphi tự động l u
toàn bộ lại dự án.
Hình d i đây cho bạn thấy s l ợng các tập tin trong một dự án Hello World đư
đ ợc l u, thông qua cửa sổ Windows Explorer nh sau:
Hình 22: Các tập tin c a dự án Hello Wolrd trong th mục S:HelloWorld
IV.3. L u Form (t p tin unit) với tên khác
Bạn ch n lệnh File/Save As đ l u.
IV.4. L u d án với tên khác
Bạn ch n lệnh File/Save Project As đ l u dự án.
IV.5. Đóng d án
Bạn ch n lệnh File/Close All đ đóng lại toàn bộ dự án.
IV.6. Thoát khỏi Delphi
Sau khi l u lại toàn bộ dự án. Đ thoát kh i Delphi, bạn sử dụng lệnh: File/Exit

Ch ơng 3: Các thành phần cơ bản c a ngôn ngữ Delphi (Object Pascal)
CH NG 3: CÁC THẨNH PH N C B N C A NGÔN NG
DELPHI (OBJECT PASCAL)
Trong ch ơng này và ch ơng 4 tiếp theo sau, đ giúp cho việc làm quen v i các khái
niệm cơ bản đ ợc dễ dàng. Giáo trình sẽ xây dựng các ví dụ theo dạng ch ơng trình chế
độ văn bản (Text mode) hay không hỗ trợ đồ hoạ (Console Application). Đ tạo một
project m i theo dạng Console Application, bạn sử dụng ch c năng
File/New/Other/Console Application.
I. Bộ ch vi t
- Bộ 26 chữ Latin:
o Chữ in : A, B, C, ..., X, Y, Z
o Chữ th ng : a, b, c, ..., x, y, z
- Bộ chữ s thập phân : 0, 1, 2, 3, ..., 8, 9
- Ký tự gạch n i : _
- Các ký hiệu toán h c : +, -, *, /, =, <, >, (, ), [, }
II. T khóa
Là các từ riêng c a Object Pascal, có ngữ nghĩa đư đ ợc xác đ nh, không đ ợc dùng
nó vào các việc khác hoặc đặt tên m i trùng v i các từ khóa.
T Ệểóa cểunỂ: program, begin, end, procedure, function
- Từ khóa đ khai báo: const, var, type, array, string, record, set, file, label, class,...
- Từ khóa c a lệnh lựa ch n: if ... then ... else, case ... of
- Từ khóa c a lệnh lặp: for... to... do, for... downto... do, while... do, repeat...
until
- Từ khóa đi u khi n: with, goto, exit, halt
- Từ khóa toán tử: and, or, not, in, div, mod
D i đây là danh sách một s từ khóa thông dụng:
and
array
begin
case
class
const
div
do
downto
for
function
goto
if
implementation
interface
label
mod
object
record
repeat
set
to
try
type
unit
until
uses

Ch ơng 3: Các thành phần cơ bản c a ngôn ngữ Delphi (Object Pascal).
else
end
finalization
finally
of
procedure
program
property
var
while
with
B ng 1: Các t khoá
III. Tên danh hi u t đặt
Trong Delphi đ đặt tên cho các biến, hằng, ki u, ch ơng trình con ta dùng các danh
hiệu (Identifier). Quy tắc đặt tên c a danh hiệu trong Delphi là:
- Chi u dài t i đa: 256 ký tự.
- Bắt đầu bằng ch cái hoặc dấu _ (gạch d i); tiếp theo có th kết hợp s và các
ký tự khác.
- Không đựợc ch a khoảng tr ng.
- Không trùng v i các từ khóa.
- Không phân biệt chữ hoa và chữ th ng.
- Các đ nh danh lồng nhau đ ợc dùng dấu . (dấu chấm) đ truy xuất.
Ví d 1:
- Danh hiệu tự đặt hợp lệ:x; s1; delta; pt_bac_2;
- Danh hiệu tự đặt không hợp lệ: 1S (bắt đầu bằng s ), Del ta (tên có khoảng
trắng),...
IV. Hằng
IV.1. Khái ni m
Hằng là một đại l ợng có giá tr không đổi trong quá trình chạy ch ơng trình. Ta
dùng tên hằng đ ch ơng trình đ ợc rõ ràng và dễ sửa đổi.
Cú pháp khai báo:
Const
Tên_hằng = bi u_th c_xác_đ nh_giá_tr _c a_hằng;
IV.2. Hằng trị
Trong tr ng hợp này thì bi u_th c_xác_đ nh_giá_tr _c a_hằng là một tr xác đ nh.
Giá tr c a bi u th c này sẽ đ ợc đ nh tr một lần và không thay đổi.
Ví d 2:
Const MaxSize = 100;
Const x = Abs(-100)+Length('Chao ban'); // hằng x =108
Const St = 'Borland'+ ' Delphi'; // hằng St = 'Borland Delphi'

Chú ý: Bi u th c hằng đây có th là s , chuỗi ký tự, các hằng true, false, nil,… kết
hợp v i các toán tử thích hợp. Bi u th c hằng không th ch a các l i g i hàm, biến hay
con tr , ngoại trừ một s hàm đơn giản nh : Abs, Chr, Length, Succ, Odd,…
IV.3. Hằng định ki u:
Có th ch a các giá tr ki u mảng, bản ghi, ki u th tục và ki u con tr .
Cú pháp khai báo hằng đ nh ki u:
Const
Tên_hằng: ki u_dữ_liệu = giá_tr _hằng;
Ví d 3:
Const MaxSize : Integer =100;
Trong ví dụ trên chúng ta khai báo một hằng có tên là MaxSize, có ki u Integer và
mang giá tr bằng 100. Chúng ta thấy, cách khai báo hằng ki u này rất gi ng khai báo và
kh i tạo biến (chúng ta sẽ xem trong phần biến). Nếu ng i lập trình bật chỉ th biên d ch
{$J+} thì hằng đ ợc xem nh biến; t c là chúng ta có thể thay đổi giá trị của hằng lúc
ch ơng trình thực thi.
Hằng mảng, hằng ki u bản ghi, hằng ki u th tục chúng ta sẽ tìm hi u chi tiết trong
các phần sau.
V. Ki u (Type)
V.1. ợịnh nghĩa
Ngoài các ki u đư đ nh sẵn, Delphi còn cho phép ta đ nh nghĩa các ki u dữ liệu khác
từ các ki u căn bản theo qui tắc xây dựng c a Delphi.
V.2. Cách khai báo
Type
Tên_ki u = Mô_tả_xây_dựng_ki u;
Ví d 4: Đ nh nghĩa các ki u dữ liệu ng i dùng (ki u dữ liệu m i) và khai báo
biến theo ki u vừa đ nh nghĩa
type //Khai báo ki u ng i dùng
SoNguyen = integer;
Diem = single;
Tuoi = 1 .. 100;
Color = (Red, Blue, Green);
Thu = (ChuNhat, Hai, Ba, Tu, Nam, Sau, Bay);
Và khi đư khai báo ki u thì ta có quy n sử dụng ki u đư đ nh nghĩa đ khai báo biến
nh sau:
var //Khai báo biến theo ki u ng i dùng đ nh nghĩa
i, j: SoNguyen;
dtb: Diem;
t: Tuoi;

mau: Color;
ngay_hoc: Thu;
VI. Bi n
Biến là một cấu trúc ghi nh có tên (đó là tên biến hay danh hiệu c a biến). Biến ghi
nh một dữ liệu nào đó g i là giá tr (value) c a biến. Giá tr c a biến có th đ ợc biến đổi
trong th i gian sử dụng biến.
Sự truy xuất c a biến nghĩa là đ c giá tr hay thay đổi giá tr c a biến đ ợc thực hiện
thông qua tên biến.
Cú pháp khai báo biến:
Var
tên_biến [hoặc danh_sách_tên_biến] : Ki u_biến;
Nếu chúng ta khai báo một danh sách các biến có cùng ki u thì mỗi tên biến cách
nhau một dấu phẩy. Ki u biến là một ki u dữ liệu chuẩn trong Delphi hoặc ki u đ ợc đ nh
nghĩa b i ng i dùng.
Ví d 5:
var a : extended ; // khai báo a là một biến ki u s thực
b, c : integer ; // khai báo 2 biến b, c có ki u s nguyên
hten : shortstring;
m_Ok: boolean; // khai báo m_Ok là một biến ki u logic
Chon : char; // khai báo Chon là một biến ki u ký tự
Cần khai báo các biến tr c khi sử dụng chúng trong ch ơng trình. Khai báo một
biến là khai báo sự tồn tại c a biến đó và cho biết nó thuộc ki u gì.
VII. Bi u thức
VII.1. Định nghĩa
Một bi u th c là một công th c tính toán bao gồm các phép toán (toán tử), hằng,
biến, hàm và các dấu ngoặc.
Ví d 6:
5 + u * sqrt(t) / sin(pi/2) ;
(a=5) and (b<>7) or (c >= 10);
max(x,y); // g i hàm
Trong đó: a, b, c, x, y, u, t là các biến đư đ ợc khai báo.
VII.2. Thứ t u tiên
 Toán t :
Trong Delphi gồm có các toán tử đ ợc phân chia nh sau:
- Toán tử s h c : +, -, *, /, div, mod

- Toán tử logic : not, and, or, xor
- Toán tử quan hệ : =, >, <, <>, <=, >=
- Toán tử bitwise : not, and, or, xor, shl, shr
- Toán tử làm việc trên tập hợp : +, -, *, /, <=, >=, <>*, in
- Toán tử thao tác trên con tr : +, -, @ , ^, =, <>
- Toán tử xử lý l p đ i t ợng : as, is
Khi tính giá tr c a một bi u th c, ngôn ngữ Delphi qui c th tự u tiên c a các
phép toán từ cao đến thấp nh sau:
Phép toán Thứ t u tiên
@, not u tiên 1
*, /, div, mod, and, shl, shr, as u tiên 2
+, -, or, xor u tiên 3
=, <>, <, >, <=, >=, in, is u tiên 4
B ng 2: Th tự u tiên toán tử
 Qui ớc tính thứ t u tiên:
Khi tính một bi u th c có 3 qui tắc v th tự u tiên nh sau:
Qui tắc 1. Các phép toán nào có u tiên cao hơn sẽ đ ợc tính tr c.
Qui tắc 2. Trong các phép toán có cùng th tự u tiên thì sự tính toán sẽ đ ợc thực
hiện từ trái sang phải.
Qui tắc 3. Phần trong ngoặc từ trong ra ngoài đ ợc tính toán đ tr thành một giá
tr đơn.
VIII. Chuy n ki u (Typecast)
Chuy n ki u hay còn g i là ép ki u là một kỹ thuật đ ợc dùng đ chuy n giá tr c a
một bi u th c sang một ki u dữ liệu khác.
Cú pháp chuy n đổi ki u dữ liệu: Tên_Ki u(bi u_thức);
V i bi u_th c là một hằng, thì ta có cách chuy n ki u theo giá tr (value typecasts),
còn v i bi u_th c là một biến, thì ta có cách chuy n ki u theo biến (variable typecasts).
Ví d 7: Chuy n ki u theo tr :
t := integer('A'); // chuy n ký tự A sang s , t = 65
v := char(65); // chuy n s sang ký tự, v = 'A'
b := boolean(0); // chuy n s sang ki u Booblean, b = False
Ví d 8: Chuy n ki u theo biến:
var MyChar: char;
Shortint(MyChar) := 122; // Gán ký tự 'z' vào biến MyChar

Ví d 9: Viết ch ơng trình minh hoạ 2 cách chuy n ki u theo tr và theo biến:
Từ File/New/Other, DClick vào Console Application đ m ra 1 dự án m i và nhập
các dòng lệnh đ hoàn chỉnh nh hình sau:
Hình 1: Ch ơng trình chuy n ki u Console mode
Nhấn tổ hợp phím Ctrl+F9 đ biên d ch lỗi.
Nhấn phím ch c năng F9 đ chạy ch ơng trình, và ta có kết quả chế độ Console
nh sau:
Hình 2: Kết quả chạy ch ơng trình.
IX. Lời chú thích vƠ các chỉ d n biên dịch
Trong Delphi có 3 cú pháp đ ghi chú thích nh sau:
{ chú thích ghi trong cặp dấu ngoặc móc }
(* chú thích đ ợc bao b i cặp dấu ngoặc và dấu sao*)
// chú thích trên một dòng
Hai ki u chú thích khác nhau có th thực hiện chú thích lồng nhau nh ng cùng ki u
thì không đ ợc phép lồng nhau.

X. C u trúc một d án ở ch độ Form (Form Application)
Cấu trúc c a một dự án (project) trong Delphi gồm 2 phần chính:
Ph n 1: Là tập tin dự án (Project file)
Hình 3: Project file.
Ph n 2: Là (các) tập tin đơn v ch ơng trình (Unit file)
Hình 4: Kết quả chạy ch ơng trình.

Ch ơng 4: Các ki u dữ liệu sơ cấp chuẩn, lệnh đơn
CH NG 4: CÁC KI U D LI U S C P CHU N, L NH Đ N
I. Các ki u d li u s c p (Simple type)
I.1. Ki u số nguyên (Integer)
Ki u s nguyên bi u diễn một tập hợp con các s . Delphi phân làm hai loại s
nguyên đ ợc đ nh nghĩa b i các từ khóa nh sau:
T khóa Ph m vi Kích th ớc
Integer -2147483648..2147483647 s nguyên có dấu 32 bit
Cardinal 0..4294967295 s nguyên d ơng 32 bit
B ng 1: Ki u nguyên
Trong đó, ki u Integer còn đ ợc chia ra thành một s tập con đ ợc đ nh nghĩa b i
các từ khóa sau:
Shortint -128..127 S nguyên có dấu 8 bit
Smallint -32768..32767 S nguyên có dấu 16 bit
Longint -2147483648..2147483647 S nguyên có dấu 32 bit
Int64 -2^63..2^63-1 S nguyên có dấu 64 bit
Byte 0..255 S nguyên d ơng 8 bit
Word 0..65535 S nguyên d ơng 16 bit
Longword 0..4294967295 S nguyên d ơng 32 bit
B ng 2: Các ki u nguyên
I.2. Ki u kỦ t (Char)
Ki u ký tự cơ bản bao gồm AnsiChar và WideChar. AnsiChar là ki u ký tự thông
th ng, chiếm kích th c một byte (t ơng tự bộ ký tự ASCII mà giáo trình sẽ đ cập
phần tiếp theo). WideChar là ki u ký tự hai byte, là ki u ký tự dùng đ bi u diễn bộ mư
Unicode cho tập hợp ký tự.
Tuy nhiên, các bạn vẫn có th khai báo sử dụng ki u ký tự v i từ khóa Char. Và trên
thực tế thì ki u Char t ơng đ ơng v i ki u AnsiChar. Ngoài Char và AnsiChar, Delphi còn
hỗ trợ tập ký tự một byte thông qua các ki u: PChar, PAnsiChar và AnsiString. T ơng tự
thì Delphi cũng hỗ trợ tập ký tự Unicode (ngoài ki u WideChar) thông qua các ki u:
PWideChar, WideString.
Một ký tự đ ợc viết trong cặp dấu nháy đơn (''). Ð tiện trao đổi thông tin cần phải
sắp xếp, đánh s các ký tự, mỗi cách sắp xếp nh vậy g i là bảng mư. Bảng mư thông dụng
hiện nay là bảng mư ASCII (American Standard Code for Information Interchange). Hệ mư
ASCII dùng nhóm 7 bit hoặc 8 bit đ bi u diễn t i đa 128 hoặc 256 ký tự khác nhau và mư
hóa theo ký tự liên tục theo cơ s 16.

Hệ mư ASCII 7 bit, mư hoá 128 ký tự liên tục nh sau:
0 : NUL (ký tự rỗng)
1 – 31 : 31 ký tự đi u khi n
32 – 47 : các ký tự khoảng trắng SP (space) ! “ # $ % & ‘ ( ) * + , - . /
48 - 57 : ký s từ 0 đến 9
58 - 64 : các dấu : ; < = > ? @
65 - 90 : các chữ in hoa từ A đến Z
91 – 96 : các dấu [ ] _ `
97 – 122 : các chữ th ng từ a đến z
123 – 127 : các dấu { | } ~ DEL (xóa)
Hệ mư ASCII 8 bit (ASCII m rộng) có thêm 128 ký tự khác ngoài các ký tự nêu
trên, gồm các chữ cái có dấu, các hình vẽ, các đ ng kẻ khung đơn và khung đôi và một s
ký hiệu đặc biệt.
Ð thực hiện các phép toán s h c và so sánh, ta dựa vào giá tr s th tự mư ASCII
c a từng ký tự, chẳng hạn: 'A' < 'a' vì s th tự mư ASCII t ơng ng là 65 và 97.
Hàm Chr(n): Trả v ký tự t ơng ng v i s th tự mư ASCII n.
Hàm Ord(ch): Trả v s th tự c a ký tự ch trong bảng mư ASCII.
Ví d 1: V i khai báo biến var ch: char; stt:byte; thì các câu lệnh sau sẽ
có giá tr nh sau:
ch := chr(65); //ch = 'A'
stt := ord('A'); //stt = 65

B NG Mẩ ASCII với 128 kỦ t chu n
Hex 0 1 2 3 4 5 6 7
0 NUL
0
DLE
16
SP
32
0
48
@
64
P
80
`
96
p
112
1 SOH
1
DC1
17
!
33
1
49
A
65
Q
81
a
97
q
113
2 STX
2
DC2
18
“
34
2
50
B
66
R
82
b
98
r
114
3 
3
DC3
19
#
35
3
51
C
67
S
83
c
99
s
115
4 
4
DC4
20
$
36
4
52
D
68
T
84
d
100
t
116
5 
5
NAK
21
%
37
5
53
E
69
U
85
e
101
u
117
6 
6
SYN
22
&
38
6
54
F
70
V
86
f
102
v
118
7 BEL
7
ETB
23
‘
39
7
55
G
71
W
87
g
103
w
119
8 BS
8
CAN
24
(
40
8
56
H
72
X
88
h
104
x
120
9 HT
9
EM
25
)
41
9
57
I
73
Y
89
I
105
y
121
A LF
10
SUB
26
*
42
:
58
J
74
Z
90
j
106
z
122
B VT
11
ESC
27
+
43
;
59
K
75
[
91
k
107
{
123
C FF
12
FS
28
,
44
<
60
L
76

92
l
108
|
124
D CR
13
GS
29
-
45
=
61
M
77
]
93
m
109
}
125
E SO
14
RS
30
.
46
>
62
N
78
^
94
n
110
~
126
F SI
15
US
31
/
47
?
63
O
79
_
95
o
111
DEL
127
Hình 1: Bảng mư ASCII chuẩn

B NG Mẩ ASCII với 128 mở rộng
Hex 8 9 A B C D E F
0 Ç
128
É
144
á
160
ƅ
176
└
192
Ż
208
α
224
≡
240
1 ü
129
æ
145
í
161
Ɔ
177
┴
193
ŷ
209
ß
225
±
241
2 é
130
Æ
146
ó
162
Ƈ
178
┬
194
Ÿ
210
Γ
226
≥
242
3 â
131
ô
147
ú
163
│
179
├
195
Ŭ
211
π
227
≤
243
4 ä
132
ö
148
ñ
164
┤
180
─
196
ū
212
Σ
228
Ŗ
244
5 à
133
ò
149
Ñ
165
Ŵ
181
┼
197
ť
213
Ń
229
ŗ
245
6 å
134
û
150
ª
166
ŵ
182
ű
198
Ŧ
214
µ
230
÷
246
7 ç
135
ù
151
º
167
ũ
183
Ų
199
ž
215
ń
231
≈
247
8 ê
136
ÿ
152
¿
168
Ũ
184
ŭ
200
Ž
216
Φ
232
°
248
9 ë
137
Ö
153
⌐
169
Ŷ
185
ŧ
201
┘
217
Θ
233
∙
249
A è
138
Ü
154
¬
170
Ť
186
ż
202
┌
218
Ω
234
·
250
B ï
139
¢
155
½
171
Ū
187
Ź
203
█
219
Ł
235
√
251
C î
140
£
156
¼
172
Ű
188
ų
204
▄
220
∞
236
ⁿ
252
D ì
141
¥
157
¡
173
ů
189
ţ
205
▌
221
φ
237
²
253
E Ä
142
₧
158
«
174
Ů
190
ſ
206
Ƅ
222
ł
238
■
254
F Å
143
ƒ
159
»
175
┐
191
ź
207
▀
223
∩
239 255
Hình 2: Bảng ASCII m rộng

Ví d 2: Viết ch ơng trình in ra 256 ký tự c a bảng mư ASCII:
Hình 3: Ch ơng trình in bảng mư ASCII
Nhấn tổ hợp phím Ctrl+F9 đ biên d ch lỗi.
nh sau:
Hình 4: Kết quả ch ơng trình chế độ Console
I.3. Ki u số th c (Real type)
I.3.1. Khái ni m
Delphi, ki u s thực bi u diễn một tập hợp các s mang dấu chấm động (float,
real). Kích th c c a nó tùy thuộc vào từ khóa mà chúng ta sử dụng trong khai báo.

(byte)
Real48 2.9 x 10^-39 .. 1.7 x 10^38 6
Single 1.5 x 10^-45 .. 3.4 x 10^38 4
Double 5.0 x 10^-324 .. 1.7 x 10^308 8
Extended 3.6 x 10^-4951 .. 1.1 x 10^4932 10
Comp -2^63+1 .. 2^63 -1 8
Currency -922337203685477.5808..
922337203685477.5807
8
B ng 3: Các từ khoá c a ki u thực
Tuy nhiên, ki u s thực chúng ta th ng dùng đ ợc khai báo bằng từ khóa Real,
trong Delphi ki u Real t ơng đ ơng v i ki u Double.
(byte)
Real 5.0 x 10^-324 .. 1.7 x 10^308 8
B ng 4: Ki u Real
I.3.2. Một số phép toán vƠ hƠm trên ki u số (số nguyên vƠ số th c)
Các phép toán s h c hai ngôi:
Phép toán Ý nghĩa Ki u toán h ng Ki u k t qu
+ Cộng integer, real integer, real
- Trừ integer, real integer, real
* Nhân integer, real integer, real
/ Chia thực integer, real real
div Chia nguyên integer integer
mod Lấy phần d integer integer
B ng 5: Các phép toán 2 ngôi
Ví d 3: V i các biến x, y, z ki u integer
x := 3*2; // x = 6
y := 15 div 6; // t = 2
z := 15.5 mod 5; // lỗi
Tuy nhiên, phép toán + và toán - còn có th là phép toán một ngôi:
Phép toán ụ nghĩa Ki u toán h ng Ki u k t qu Ví d
+ (unary) dấu d ơng integer, real integer, real +7
- (unary) dấu âm (lấy s đ i) integer, real integer, real -7
B ng 6: Các phép toán 1 ngôi

Khi thực hiện các phép toán chúng ta cần chú ý một s đi m đặc biệt sau:
- Kết quả c a phép chia thực (/) luôn luôn có ki u Extented, không quan tâm đến
ki u c a các toán hạng.
- Phép toán mod là phép toán lấy phần d .
- Khi thực hiện phép chia x/y (hay là x mod y hoặc x div y) thì y phải khác 0, nếu y
có giá tr 0 thì ch ơng trình sẽ phát sinh lỗi.
Một s hàm chuy n đổi ki u dữ liệu:
function IntToStr ( Number : Integer ) : string; //Unit: SysUtils
function IntToStr ( BigNumber : Int64 ) : string; //Unit: SysUtils
Hàm IntToStr là hàm thực hiện việc chuy n đổi một s nguyên (hoặc s int64) thành
một chuỗi s .
function FloatToStr(Value: Extended): string; //Unit: SysUtils
function FloatToStr(Value: Extended; const FormatSettings: TFormatSettings): string;
Hàm FloatToStr chuy n đổi một s thực hay s dấu chấm động (Value) thành một
chuỗi bi u diễn t ơng ng cho s đó.
Bảng d i đây là các hàm liên quan đến ki u s :
Hàm ụ nghĩa
abs(x); |x| : lấy giá tr tuyệt đ i c a s x
arctan(x:extended): extended; arctang(x)
cos(x: extended): extended; cos(x) : lấy cos c a x
exp(x: real): real; ex
frac(x:extended): extended; Trả v phần thập phân c a biến x
inc(var x [ ; n: longint ] ); tăng biến x lên 1 hoặc n giá tr
int(x: extended): extended; Trả v phần nguyên c a biến x
ln(x); ln x : lấy logarit nepe c a tr x (e  2.71828)
max(a,b:numbertype):numbertype; Trả v s l n hơn trong hai s a và b.
min(a,b:numbertype):numbertype; Trả v s nh thua trong hai s a và b.
odd(n:integer|int64):boolean;
Ki m tra n có phải là s lẻ hay không:
True: Nếu n lẻ
False: Nếu n chẵn.
pi: extended; Trả v giá tr pi=3.1415926535897932385.
random[( range: integer)];
Trả v một s ngẫu nhiên x và 0 <= x < range,
nếu range không chỉ ra thì 0 <= x < 1.
sqr(x); x2
: lấy bình ph ơng tr s x
sqrt(x); : lấy căn bậc 2 c a x
sin(x); sin (x) : lấy sin c a x
succ(x); Trả v giá tr sau c a x

trunc(x: extended): int64; Lấy phần nguyên c a x
round(x: extended): int64; Làm tròn giá tr c a x, lấy s nguyên gần x nhất
B ng 7: Các hàm xử lý s
Ví d 4: Viết ch ơng trình tính chu vi và diện tích c a hình chữ nhật:
Hình 5: Ch ơng trình tính chu vi diện tích hình chữ nhật
Nhấn tổ hợp phím Ctrl + F9 đ biên d ch lỗi.
nh sau:
Hình 6: Kết quả ch ơng trình chế độ Console

I.4. Ki u logic (Boolean)
I.4.1. Khái ni m
Một dữ liệu thuộc ki u boolean là một đại l ợng có th nhận đ ợc một trong hai giá
tr logic là true (đúng) và false (sai). Delphi cung cấp 4 ki u boolean sau:
T khóa Kích th ớc (byte)
Boolean 1
ByteBool 1
WordBool 2
LongBool 4
B ng 8: Ki u logic
Trong đó, ki u Boolean là ki u t ơng thích v i ki u Boolean c a Pascal và đ ợc a
thích hơn cả. Một giá tr ki u ByteBool, LongBool hoặc WordBool đ ợc xem là true nếu
nó có giá tr khác 0, ng ợc lại là false.
I.4.2. Phép toán Boolean
T khóa ụ nghĩa
Not Phép toán ph định
And Phép toán và
Or Phép toán hoặc
B ng 9: Các phép toán trên ki u logic
Cú pháp:
 Phép toán and: (x1) and (x2) and ... and (xn) trả v kết quả là true khi tất cả các
toán hạng là true, ng ợc lại trả v false.
 Phép or: (x1) or (x2) or ... or (xn) cho kết quả là false khi tất cả các toán hạng là
false, ng ợc lại trả v true.
Ví d 5: Ví dụ: v i x, y, z ki u boolean, ta có:
x := (2<3) and (5<5) and (0<>1); // x = False
y := (2>3) or (5>5) or (0<>1); // y = True
z := not (y); // z = False
Đ hi n th giá tr boolean lên màn hình, bạn sử dụng hàm có sẵn trong Delphi:
function BoolToStr(B: Boolean; UseBoolStrs: Boolean = False): string;
Nếu bạn mu n hi n th giá tr c a B là chuỗi ký tự True hoặc False thì cho
UseBoolStrs = True; còn nếu mu n hi n th giá tr c a B là '-1' hoặc '0' thì thì cho
UseBoolStrs = False.
II. Cơu l nh (statement)
Trong một ch ơng trình Delphi, sau phần mô tả dữ liệu là phần mô tả các câu lệnh.
Các câu lệnh có nhiệm vụ xác đ nh các công việc mà máy tính phải thực hiện đ xử lý các
dữ liệu đư đ ợc mô tả và khai báo. Câu lệnh đ ợc chia thành câu lệnh đơn giản và câu lệnh
có cấu trúc.

Các câu lệnh phải đ ợc ngăn cách v i nhau b i dấu ch m ph y (;) và các câu lệnh
có th viết trên một dòng hay nhi u dòng.
III. L nh đ n (Simple statement)
Lệnh đơn là lệnh không ch a bất kỳ câu lệnh nào khác. Các lệnh đơn bao gồm: lệnh
gán, lệnh g i hàm và th tục, lệnh nhảy (goto).
IV. L nh gán (Assignment statement)
Một trong các lệnh đơn giản và cơ bản nhất c a Delphi là lệnh gán. Mục đích c a
lệnh này là gán cho một biến đư khai báo một giá tr nào đó cùng ki u (hay t ơng thích)
v i biến.
Cú pháp c a lệnh gán là:
Bi n := bi u_thức;
Lệnh gán sẽ đặt lại giá tr hiện hành c a biến bằng giá tr m i nằm bên phải toán tử
gán (dấu hiệu :=).
Ví d 6: Khi đư khai báo
var
c: char; i: integer;
x: real; p, q: boolean;
thì ta có th có các phép gán sau:
c := 'A'; c := chr(90);
i := 35; i := i div 7;
x := 0.5; x := i + 1;
p:= (i >= 1) and (i < 100); q := not p;
ụ nghĩa:
Biến và các phát bi u gán là các khái niệm quan tr ng c a một h các ngôn ngữ lập
trình, chúng phản ánh cách th c hoạt động c a máy tính, đó là:
- L u trữ các giá tr khác nhau vào một ô nh tại những th i đi m khác nhau.
- Một quá trình tính toán có th coi nh là một quá trình làm thay đổi giá tr c a
một (hay một s ) ô nh nào đó, cho đến khi đạt đ ợc giá tr cần tìm.
V. L nh gọi th t c vƠ hƠm
Trong lập trình OOP, thuật ngữ hàm (Function), th tục (Procedure) và ph ơng th c
(Method) là khái niệm quen thuộc v i ng i lập trình. Đ các bạn có th nắm bắt đ ợc
kiến th c lập trình trong Delphi, Giáo trình đ a ra tr c khái niệm này một cách ngắn g n
nh sau:
Hàm và th tục đ ợc g i chung là ch ơng trình con. Hàm đ ợc xây dựng thông qua
tên hàm và danh sách các tham s hình th c nếu có, m i hƠm thì luôn tr v duy nh t 1
giá trị. Còn th tục thì có tên th tục và danh sách các tham s hình th c nếu có. Khác v i

hàm, th t c KHÔNG tr v một giá trị nƠo c , nó th ng bao gồm một dưy các câu
lệnh cần đ ợc thực hiện một cách tuần tự đ giải quyết một công việc nào đó.
Bạn cần phân ra 2 giai đoạn rõ ràng: Xây dựng ch ơng trình con, và sử dụng ch ơng
trình con.
Ví d 7: V hàm - Function
- Xây dựng hàm: Bạn viết hàm tính tổng 2 s a và b và kết quả trả v c a hàm chính
là kết quả a + b. Nó có hình dạng nh sau:
function Cong(a, b: single) : single;
begin
Cong := a + b;
end;
- Sử dụng hàm (L i g i hàm): bạn cần tính phép cộng c a 2 con s cụ th nào,
chẳng hạn bạn mu n 5 cộng v i 7, thì nh vậy bạn sẽ truy n s 5 vào cho a và 7
vào cho b. Cụ th bạn sẽ g i nh sau:
mTong := Cong(5,7); //v i biến mTong ki u Single và mTong = 12
Nh vậy b c xây dựng: a và b đ ợc g i là tham s hình th c. Còn b c g i hàm thì 5
và 7 đ ợc g i là các tham s thực.
Ví d 8: V th tục – Procedure
- Xây dựng th tục: Bạn viết th tục hi n th ra màn hình n câu chào “Welcome to
Delphi!…”, v i n có th là 1 lần, 3, 10, … 100 lần chẳng hạn:
procedure Welcome(n: integer);
var i: integer;
begin
for i:=1 to n do ╙╔i╖el═ (‘Welc║me ╖║ Del╒hi!…’);
end;
- Sử dụng th tục (L i g i th tục): đây mu n hi n th 5 câu chào, thì bạn ra câu
lệnh nh sau:
Welcome(5); //Hiể═ ╖hị 5 c╪╗ ch╩║
Khái niệm ph ơng th c trong một l p cũng đ ợc xem là th tục hoặc hàm (Member
method). Kiến th c này các bạn sẽ đ ợc h c ch ơng 5. đây, các bạn cần chú ý đi u
này: Ph ơng th c là ch ơng trình con mà Delphi đư xây dựng sẵn trong mỗi l p/thành
phần (Class/Component) cho bạn (Thật kh e làm sao!…), bạn chỉ cần lấy trong “túi khôn”
c a Delphi đ sử dụng viết ch ơng trình mà thôi.
Tóm lại: Khi sử dụng ph ơng th c hay các ch ơng trình con đư đ ợc xây dựng sẵn
b i Deplhi, bạn cần nắm rõ mỗi ph ơng th c, th tục hoặc hàm có bao nhiêu tham s hình
th c và ki u c a chúng là gì đ truy n vào cho chúng các tham s thực t ơng ng cho
đúng yêu cầu c a bạn.
Ví dụ v i cú pháp th tục có sẵn trong Delphi là:
procedure ShowMessage(const Msg: string);
thì bạn chỉ cần lấy ra sử dụng v i câu lệnh đơn giản nh sau:
Sh║╙εe╕╕⌠ge(‘T║i d⌠═g h║c Del╒hi d⌠╛ ═he!…’);
Các bạn sẽ đ ợc h c chi tiết các khái niệm này trong ch ơng “Lập Trình Xử Lý Sự
Kiện” và “Ch ơng Trình Con” các phần sau.

VI. L nh Goto
Từ thân ch ơng trình con, bạn có th sử dụng lệnh goto đ chuy n h ng thực hiện
ch ơng trình t i một v trí bất kỳ thông qua một nhưn đư đ ợc khai báo tr c.
Cú pháp lệnh goto: Goto nhãn;
V i nhưn đ ợc khai báo v i cú pháp sau: Label Tên_nhãn;
Lệnh goto là lệnh nhảy không đi u kiện, nó chuy n h ng thực thi c a ch ơng trình
đến v trí mà nhưn đang đ ng.
Trong phong cách lập trình OOP, lệnh goto t ra b lỗi th i và rất ít khi đ ợc dân lập
trình sử dụng.
Ví d 9: Minh h a lệnh goto đ tính bi u th c a/b.
Hình 7: Ví dụ minh h a lệnh goto và khai báo nhãn - label
nh sau:
Hình 8: Kết quả ch ơng trình.

Ch ơng 5: Lập trình xử lý sự kiện – Các thành phần c a Delphi
CH NG 5: L P TRÌNH X Lụ S KI N ậ CÁC THẨNH PH N
TRONG GIAO DI N DELPHI
I. L p trình x lỦ s ki n
I.1. Lớp (Class) vƠ đối t ng (Object)
Trong các ch ơng tr c, các bạn đư đ ợc biết đến cách lập trình tuần tự chế độ
Console Application và biết đ ợc một s khái niệm cơ s . ch ơng này, các bạn sẽ đ ợc
trình bày một ph ơng pháp lập trình chính c a giáo trình và rất phổ biến hiện nay đó là lập
trình sự kiện dựa trên n n tảng c a lập trình h ng đ i t ợng (OOP: Object-Oriented
Programming).
Trong cuộc s ng, bạn thấy có nhi u đ i t ợng đ ợc xếp chung vào một loại/l p,
chẳng hạn nh những ng i còn đi h c ta xếp chung v i một l p đó là l p SINHVIểN,
những ng i đi làm việc thì xếp vào l p CBCNV. Nh vậy ta có hình ảnh nh sau: tất cả
m i ng i đ u đ ợc xếp chung vào một l p trên cùng là l p NG I. Ta cũng có th phân
chia những ng i trong l p NG I này thành hai nhóm là SINHVIểN và CBCNV dựa
vào tính chất đ phân biệt là đang đi làm hay còn đi h c.
Hình 1: Mô hình các l p
Cụ th : Nếu xét một gia đình công ch c gồm 4 thực th ng i là ng i A – cha, B -
mẹ: đi làm; anh C, ch D: đang đi h c chẳng hạn, thì nh thế ta có 2 đ i t ợng A, B đ ợc
tạo ra từ l p CBCNV và 2 đ i t ợng C, D đ ợc sinh ra từ l p SINHVIểN và cả 4 đ i
t ợng này đ u có những tính chất chung đ ợc thừa h ng từ l p NG I, và nh vậy 2 l p
SINHVIểN và CBCNV là các l p dẫn xuất từ l p NG I.
I.1.1. Lớp (Class)
L p là một khái niệm đ ợc sử dụng rất nhi u trong cách lập trình OOP. Việc hi u rõ
các kiến th c v l p thì nằm ngoài phạm vi c a giáo trình này. Do vậy, giáo trình chỉ đ a
ra các khái niệm rất cơ bản v l p, mục đích đ các bạn dễ hi u hơn v đ i t ợng (Object),
là một thành phần rất phổ biến trong lập trình c a Delphi. Nh vậy, l p đ ợc dùng đ đ nh
nghĩa ra ki u dữ liệu cấu trúc mà nó bao gồm 3 thành phần cơ bản:
- Các tr ng (Fields): là các biến dữ liệu c a l p.
NG I
- H tên
- Ngày sinh
- Phái
- v.v...
- Mư cán bộ
- Bậc l ơng
- v.v...
- v.v...
- Mư s SV
- Ngành h c
- v.v...
SINHVIÊ
N
CBCNV

- Các ph ơng th c (Methods): là các hàm hay th tục đ thực hiện thao tác nào đó
trên đ i t ợng. Có 2 ph ơng th c đặc biệt trong l p mà bạn cần l u ý đó là
ph ơng th c tạo (Constructor) và ph ơng th c h y (Destructor) sẽ đ ợc dùng khi
một đ i t ợng (Object) đ ợc tạo nên hoặc b h y.
- Các thuộc tính (Attributes) cuả một l p bao gồm các biến, các hằng, hay tham s
nội tại c a l p đó. Tính chất quan tr ng nhất c a các thuộc tính khi chúng là biến
là có th b thay đổi trong quá trình hoạt động c a một đ i t ợng. Thông th ng
đ truy xuất các biến tr ng, ta dựa vào trạng thái c a thuộc tính là đ c (read)
hay ghi (write) đ nhận hay là thiết lập giá tr cho chúng.
L p đ ợc khai báo theo cú pháp nh sau:
type className = class (ancestorClass)
memberList
end;
Trong đó:
- ancestorClass là l p cha/tổ tiên c a l p dẫn xuất (descendant) là className, l p
className sẽ đ ợc thừa h ng (inheritance) từ l p cha. Trong Delphi l p th y tổ
là l p TObject.
- memberList là các thành phần c a l p là tr ng, ph ơng th c và thuộc tính c a
l p đư đ ợc trình bày trên.
Trong ví dụ giải ph ơng trình bậc nhất trên, ta có một l p TfrmPTB1 đ ợc dẫn
xuất từ l p cha là l p TForm, l p TForm lại đ ợc dẫn xuất từ l p TCustomForm,... và c
thế nó đ ợc dẫn xuất từ l p th y tổ trong Delphi là l p TObject nh hình sau:
Hình 2: L p TfrmPTB1 và các l p tổ tiên (Ancestor Classes) c a nó

Ví d 1: Khai báo l p TfrmPTB1 cho form unit untPtb1.Pas ví dụ trên nh sau:
type
TfrmPTB1 = class(TForm)
lbl_a: TLabel;
lbl_b: TLabel;
edt_a: TEdit;
edt_b: TEdit;
lbl_KQua: TLabel;
memKQua: TMemo;
pnlLine: TPanel;
btnXuLy: TButton;
btnKetThuc: TButton;
procedure btnXuLyClick(Sender: TObject);
procedure btnKetThucClick(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;
I.1.2. Đối t ng (Object)
Đ i t ợng là thực th (Instance) đ ợc sinh ra từ một l p (Class), hay nói cách khác
khi ta khai báo một biến thuộc một l p nào đó, thì biến đó chính là một đ i t ợng m i
đ ợc cấp phát. Đ i t ợng này đ ợc tạo ra b i ph ơng th c constructor và sẽ b giải phóng
b i ph ơng th c destructor.
* Quy cách đặt tên đối t ng:
Trong phong cách lập trình chuyên nghiệp, quy c đặt tên cho đ i t ợng th ng
đ ợc ghép 2 phần: ti n tố vƠ tên g i nhớ c a đ i t ợng đó. Ti n t th ng có 3 ký tự đ
xác đ nh đ i t ợng đó thuộc loại thành phần nào. Trong giáo trình này gợi ý cho các bạn
các ti n t (prefix) cho các đ i t ợng c a các thành phần nh sau:
Đối t ng Ti n tố Ví d
Form frm frmWelcome, frmMain
Label lbl lblHeSo, lblHoTen
Edit edt edt_a, edtHoTen
Button btn btnGiai, btnXuLy
SpinEdit: spe speNhietDo, speGia1TC
LabeledEdit lbe lbeDonGia, lbeThanhTien
ListBox lbx lbxBaiHat, lbxFont
CheckBox chk chkMatHang, chkDelphi
ComboBox cbo cboToanTu, cboPhai
GroupBox gbx gbxMonHoc, gbxMatHang

Đối t ng Ti n tố Ví d
CheckListBox clb clbTenMH, clbDMVT
ValueListEditor vle vleMatHang, vleBaoGia
Memo mem memDanhSach, memKQ
RadioButton rbt rbtNam, rbtNu
RadioGroup rgp rgpGioiTinh, rgpCourses
StringGird stg stgAlphabet, stgMaTranA
Panel pnl pnlDieuKhien, pnlDrives
PopupMenu pmu pmnMauSac, pmnGames
MainMenu mmu mmuMainForm, mmuQLSV
MenuItem mni mniCopy, mniPaste
B ng 1: Quy cách đặt tên các đ i t ợng
Ví d 2: Khai báo một thực th (đ i t ợng) frmPTB1 nh sau:
var
frmPTB1: TfrmPTB1; // đ i t ợng frmPTB1 c a l p TFrmPTB1
Lập trình h ng đ i t ợng là sự gắn kết giữa dữ liệu và các hàm xử lý dữ liệu tạo
thành đ i t ợng. Mỗi đ i t ợng bao gồm:
- Thuộc tính (Properties): là dữ liệu c a đ i t ợng.
- Ph ơng th c (Methods): là những hành động mà đ i t ợng có th thi hành.
- Sự kiện (Events): là những hành động c a đ i t ợng đó đáp ng lại thông qua th
tục sự kiện do ng i lập trình cài đặt, khi ng i dùng t ơng tác v i ch ơng trình.
Ví d 3: Trong ch ơng này, các bạn sẽ đ ợc h c cách sử dụng các thuộc tính và các
sự kiện c a các đ i t ợng thông qua một ch ơng trình đầu tiên là
“prjWelcome.dpr”
- B ớc 1: Bạn vào ch c năng: File/New/Application đ tạo ra dự án m i.
Hình 3: Hình ảnh c a New Form.
Từ cửa sổ thuộc tính và sự kiện c a đ i t ợng (Object Inspector), dựa vào thuộc tính
name, bạn đặt tên cho form là frmWelcome đ Delphi đ nh nghĩa ra 1 l p có tên là
TfrmWelcome đ ợc dẫn xuất từ l p cha là TForm nh sau:

type
TfrmWelcome = class(TForm)
// memberList
end;
Và khai báo một đ i t ợng có tên là frmWelcome thuộc ki u l p TfrmWelcome nh sau:
var
frmWelcome: TfrmWelcome;
Hình 4: Hình ảnh l p TfrmWelcome và đ i t ợng frmWelcome
- B ớc 2: Từ bảng các thành phần (Component Palette), click vào thẻ Standard rồi
lần l ợt đặt các thành phần TLabel, TEdit, và TButton lên Form:

Hình 5: Các đ i t ợng Label, Edit và Button đặt trên Form.
Trong môi tr ng lập trình IDE, các l p trong Delphi th ng đ ợc cài đặt thành các
thành phần (TComponent) đ ng i lập trình dễ dàng thừa h ng khi thiết kế và viết mư
lệnh. Nh vậy: Tên l p cũng chính là tên thành phần.
Từ đây v sau, thuật ngữ “đối t ng A c a một thƠnh ph n TA” đ ợc viết ngắn
g n là “đối t ng A”.
Ví d 4: Câu lệnh frmWelcome:TForm; đ c đầy đ là “đ i t ợng frmWelcome
thuộc l p (thành phần) TForm”. Tuy nhiên, ta có th đ c g n lại nh : “đối
t ng frmWelcome”, hoặc câu lệnh btnGiai:TButton; đ ợc đ c là “nút
l nh btnGiai” hay “đối t ng btnGiai”.
I.2. Thuộc tính
Mỗi thành phần đ u có những thuộc tính đ xác đ nh những đặc tính c a thành phần
đó chẳng hạn nh màu sắc (Color), v trí (Position), kích th c và trạng thái (State) c a
chúng. Trong các thuộc tính này, bạn cần quan tâm nhất đến thuộc tính tên (Name) c a đ i
t ợng.
- B ớc 3: Lần l ợt thiết lập các thuộc tính Name, Caption cho đ i t ợng Label và
các thuộc tính Name, Text cho đ i t ợng Edit:
Hình 6: Cửa sổ thuộc tính và sự kiện c a đ i t ợng lblHoTen và edtHoTen
T ơng tự, đ i t ợng thuộc thành phần TButton có thuộc tính Name là btnChao và
Caption là “&Chao”, đ i t ợng c a TForm có thuộc tính Name là frmWelcome và Caption
là “Welcome to Delphi 7.0”
Cách truy xuất thuộc tính c a đ i t ợng:
Tên_đối_t ng.Thuộc_tính
Tên l p
Tên đ i
t ợng

Ví d 5: Gán thuộc tính Enabled c a lblHoTen bằng True là:
lblHoten.Enabled := True;
I.3. Ph ng thức (Method)
Là th tục (Procedure) hoặc hàm (Function) đư đ ợc xây dựng sẵn cho công việc nào
đó c a đ i t ợng. Ta có th g i ph ơng th c này trong quá trình viết mư (Coding) đ
chúng thi hành khi ch ơng trình chạy.
Cách truy xuất ph ơng th c đ i t ợng:
Tên_đối_t ng.Ph ng_thức;
Ví d 6: G i ph ơng th c Hide và Show đ thực hiện việc ẩn và hiện c a đ i t ợng
frmWelcome là: frmWelcome.Hide;
và frmWelcome.Show;
I.4. S ki n (Event)
Đó chính là một thao tác c a ng i sử dụng tác động lên đ i t ợng và nó sẽ đáp ng
lại bằng việc thực hiện một công việc nào đó. Các sự kiện thông th ng là trên mouse và
keyboard nh : Click, RightClick, DoubleClick, KeyPress, Drag and drop,…
Hình 7: Sự kiện OnClick c a btnChao
Nh hình trên, đ i t ợng btnChao có nhi u sự kiện nh : OnClick, OnContextPopup,
OnDragDrop,... c a tab Event t ơng ng trên cột Action. Mỗi sự kiện này t ơng ng v i
một th tục sự kiện đ xử lý sự kiện đó (Event handers) nằm cột bên phải t ơng ng.
Tên sự kiện
Tên th tục
sự kiện sự
kiện.

I.5. X lỦ s ki n (Event Handlers)
Đó chính là th tục sự kiện, thân th tục sự kiện này bao gồm các câu lệnh mà ng i
lập trình viết trong nó đ thực hiện một công việc, ch c năng nào đó.
Cách hình thành th tục sự kiện:
procedure Tên_Thành_Phần_Form.Tên_đ i_t ợngSự_kiện([DanhSáchCácThamS ]);
Ví d 7: Th tục sự kiện OnClick cho nút lệnh btnChao c a frmWelcome (hay còn
g i là th tục sự kiện btnChaoClick c a l p TfrmWelcome) đ ợc hình
thành nh sau:
procedure TfrmWelcome.btnChaoClick(Sender: TObject);
- B ớc 4: hình 5, nhắp đúp lên nút lệnh Chao, hoặc hình 7 bạn nhắp đúp lên
cột bên phải c a sự kiện OnClick t ơng ng đ m ra một th tục sự kiện có tên
là TfrmWelcome.btnChaoClick (Sender: TObject) nh sau:
Hình 8: Th tục sự kiện btnChaoClick m i tạo c a sự kiện OnClick
Tiếp đến bạn gõ một s lệnh vào trong thân c a th tục sự kiện nh hình sau:
tên thành phần hay
tên l p form
tên nút lệnh
btnChao
sự kiện
OnClick

Hình 9: Viết code cho th tục sự kiện btnChaoClick
I.6. Trình h tr mư l nh (Code Completion /IntelliSense)
Trong cách lập trình h ng đ i t ợng (OOP) và nhất là khi ngôn ngữ lập trình có
hỗ trợ môi tr ng phát tri n IDE thì s thuộc tính, ph ơng th c, sự kiện và các th tục sự
kiện c a từng đ i t ợng là vô cùng phong phú (do tính thừa h ng). Việc nh chính xác cú
pháp c a chúng là một việc làm không t ng đ i v i bất kỳ một lập trình viên nào (vì
không chỉ có duy nhất một ngôn ngữ lập trình Delphi!). Đ giúp cho ng i lập trình "dễ
th " hơn, Delphi có đ a ra menu ngữ cảnh rất hữu ích đ hỗ trợ cho việc viết code này và
đ ợc g i là Trình h tr mư l nh (Code Completion).
Trong lúc bạn viết code, khi bạn gõ tên đ i t ợng rồi đến dấu chấm, thì Code
Completion sẽ xuất hiện nh hình sau:
Hình 10: Trình hỗ trợ mư lệnh
II. Sinh mư t động vƠ một số cách s a l i
II.1. Cách t động sinh mư (generate code) trong Delphi
- Khi mới tạo m i một dự án (Form Application) nh hình ảnh sau:

Hình 11: Mư lệnh sinh tự động trong dự án m i.
thì bạn thấy tên ki u (Type) l p TForm1 đ ợc xây dựng thông qua l p (Class) dẫn
xuất từ l p cha là l p TForm. Trong ki u TForm1 (không k sự thừa h ng từ l p TForm)
ch a có thuộc tính (Properties), Ph ơng th c (Methods) hoặc sự kiện (Events) nào c a
chính nó, nh bạn thấy trong đoạn code sau đây:
type
TForm1 = class(TForm)
private
public
end;
var
Form1: TForm1;
- Khi bạn đặt lên form (hoặc gỡ b ) một đ i t ợng (Object) c a đ i t ợng bất kỳ nh
Button, Edit,... thì tên (name) c a đ i t ợng đó sẽ đ ợc tự động thêm vào (hoặc xóa b đi)
trong phần thuộc tính (Property) c a Form phần đ nh nghĩa ki u l p Form. Chẳng hạn,
bạn thêm vào đ i t ợng Button1 thuộc thành phần TButton (ngắn g n là Button1: TButton)
lên Form nh hình sau:

Hình 12: Thêm nút lệnh Button1
thì đoạn code sẽ tự động thêm vào biến dữ liệu là Button1: TButton nh sau:
type
Button1: TButton; //mới ╖ự độ═g ╕i═h m╬ ╖h▐m
private
public
end;
var
Form1: TForm1;
- Khi bạn tạo ra 1 th tục sự kiện dựa trên sự kiện nào đó, thì Delphi sẽ tự động khai
báo (Declare) thêm phần nguyên mẫu (Prototype) c a th tục sự kiện trong phần dữ liệu
(thuộc tính – Properties) c a l p. Chẳng hạn, bạn tạo ra th tục (Procedure) c a sự kiện
(Event) nhắp chuột (OnClick) c a nút lệnh có tên Button1, thì Delphi sẽ tự động thêm vào
phần khai báo th tục sự kiện trong l p TForm1 nh đoạn code sau:
type
Button1: TButton;
procedure Button1Click(Sender: TObject); //mới thêm vào
private
public
end;
var
Form1: TForm1;
và sự cài đặt (Implementation) các câu lệnh cho th tục sự kiện mà ta m i tạo sau
từ khóa implementation, nh đoạn code sau:

type
Button1: TButton;
procedure Button1Click(Sender: TObject);
private
public
end;
var
Form1: TForm1;
implementation
{$R *.dfm}
//------------ phần cài đặt th tục m i đ ợc tự động thêm vào ----------------
procedure TForm1.Button1Click(Sender: TObject);
begin
end;
// ---------------------------------------------------------------------------------------
end. // Kết thúc Form Unit.
II.2. Cách s a l i sinh mư trong Delphi
Khi bạn m i h c sử dụng Delphi, nhất là khi m i làm quen v i lập trình, thì việc phát
sinh ra các lỗi (errors, bugs) do thao tác không đúng hoặc ch a hi u đầy đ kiến th c v
OOP là dễ gặp phải. đây, sẽ chỉ ra những sai sót th ng gặp và cách sửa chúng.
a. Sai trong thao tác t o th t c s ki n: Nếu bạn làm đúng h ng dẫn trong phần
"Xử lý sự kiện" (phần I.5) thì không b sai. Tuy nhiên do ch a quen, bạn th ng tự gõ vào
phần cài đặt th tục sự kiện (TTSK) mà không biết hoặc quên đ a vào phần khai báo
nguyên mẫu (Prototype), gồm từ khóa procedure Tên_TTSK([các_tham_s ]); c a th tục
sự kiện.
Ví dụ nh đoạn code sau:
type
Button1: TButton;
{--------- ╖hiế╗ kh⌠i ⌡╨║ ═g╗╛▐═ mẫ╗ ═╩╛ -----
------------------------------------------------}

private
public
end;
var
Form1: TForm1;
implementation
{$R *.dfm}
// ------------ phần bạn tự gõ vào --------------------------------------------------
begin
ShowMessage('Welcome to Delphi 7.0!...');
end;
// ---------------------------------------------------------------------------------------
end. // Kết thúc Form Unit.
thì khi bạn biện d ch, Delphi sẽ thông báo lỗi nh hình sau:
Hình 13: Báo lỗi do thiếu phần khai báo prototype
Khi xuất hiện hộp thông báo lỗi này, bạn có 3 ch n lựa:
- Ch n nút lệnh Yes, nếu mu n gỡ b tên th tục sự kiện trong sự kiện t ơng ng c a
đ i t ợng. Trong ví dụ này, bạn mu n gỡ b TTSK Button1Click trong sự kiện OnClick
c a nút lệnh Button1.

Ch a gỡ b TTSK Đư gỡ b TTSK
Hình 14: Minh h a tên TTSK Button1Click trong sự kiện OnClick
- Ch n nút lệnh No, nếu không gỡ b tên th tục sự kiện trong sự kiện t ơng ng c a
đ i t ợng. Trong ví dụ này, bạn vẫn mu n giữ lại TTSK Button1Click trong sự kiện
OnClick c a nút lệnh Button1.
- Ch n nút lệnh Cancel thì h y b bảng thông báo lỗi này. Đi u này cũng nh ch n
nút lệnh No.
Cả 3 ch n lựa trên vẫn không tự động sửa hết lỗi cho bạn. Nếu bạn nhấn phím
Ctrl+F9 hoặc F9, thì Delphi sẽ nhảy con tr (con nháy) đến đúng phần cài đặt TTSK và
thông báo lỗi trong cửa sổ Messages phía d i c a sổ soạn thảo mư lệnh nh hình sau:
Hình 15: Cửa sổ Messages
Hình ảnh phần cửa sổ soạn thảo mư lệnh cùng v i các cửa sổ khác.
Gỡ b TTSK

Hình 16: Thông báo lỗi và con nháy nhảy đến TTSK b lỗi.
Đ sửa lỗi này, bạn chuy n lên phần đ nh nghĩa l p TForm1, và thêm vào phần khai
báo (Prototype) c a th tục sự kiện này nh sau:
type
Button1: TButton;
procedure Button1Click(Sender: TObject); //gõ thêm vào
private
public
end;
Cần chú ý: Nếu b c trên bạn ch n Yes, thì sau khi hết lỗi bạn phải gắn tên TTSK
vào sự kiện t ơng ng cho đ i t ợng Button1; Còn nếu ch n No thì tên TTSK vẫn còn giữ
nguyên (đư gắn sẵn) cho bạn.
- Một lỗi khác là bạn m TTSK không đ ợc nh khi bạn DClick lên nút lệnh
Button1 thì có thông báo lỗi nh sau:

Hình 17: Lỗi không th tạo TTSK
trong t ng hợp này, bạn ch n OK, sau đó nhấn phím ch c năng F12 đ chuy n vào cửa
sổ soạn thảo mư lệnh đ sửa lỗi.
unit Unit1;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics,
Controls, Forms,Dialogs, StdCtrls;
type
Button1: TButton;
private
public
end;
var
Form1: TForm1;
implementation
{$R *.dfm}
end. //Nguyên nhân phát sinh lỗi, bạn xóa b lệnh này đi.
begin
ShowMessage('Welcome to Delphi 7.0!');
end;
end.

- Một lỗi khác th ng xảy ra là bạn xóa đi từ khóa end.trong tập tin unit thì sẽ nhận
đ ợc thông báo:
Hình 18: Lỗi thiếu từ khóa end. trong unit form
Đ sửa lỗi này, bạn nhấn phím ch c năng F12 đ chuy n sang c a sổ mư lệnh, rồi
thêm từ khóa end. vào cu i tập tin unit.
* Tóm l i: Có rất nhi u lỗi khác nhau phát sinh nếu bạn thao tác không chính xác. Cần
phải chú ý 2 đi m:
- Thao tác đúng theo sự h ng dẫn đư trình bày trong giáo trình.
- Một TTSK phải đầy đ 2 thành phần:
+ Phần khai báo tên th tục (Prototype) trong phần đ nh nghĩa l p c a Form.
+ Phần cài đặt đầy đ TTSK sau phần cài đặt (Implementation).
II.3. Thêm t p tin unit vƠo d án
Việc này giúp cho bạn, tr ng nhóm lập trình viên hay ch dự án (group leader,
leader team) có th ghép nhi u form khác nhau những project khác nhau c a những lập
trình viên khác nhau viết, thành một dự án (thành phẩm) cu i cùng.
Ví d : Bạn thử t ng t ợng sự phân công công việc c a 1 sản phẩm "Giải Ph ơng
Trình" có 2 ph ơng trình bậc nhất và bậc hai. Tr ng nhóm, anh A, phân công cho lập
trình viên B viết ch ơng trình giải ph ơng trình bậc nhất (tên form: frmPTB1, unit file:
untPTB1.pas, project file: prjPTB1.dpr) và lập trình viên C viết ch ơng trình bậc hai (tên
form: frmPTB2, unit file: untPTB2.pas, project file: prjPTB2.dpr). Công việc c a anh A là
viết giao diện (Interface) cho gói sản phẩm này (tên form: frmMain, unit file: untMain.pas,
project file: prjMain.dpr). Sau khi phần ch ơng trình viết riêng biệt c a mỗi anh A, B, C đư
xong, thì anh A sẽ ghép thêm frmPTB1, frmPTB2 vào dự án c a anh ta trong đó frmMain
là giao diện c a ch ơng trình.
Tổ ch c c a sản phẩm "Giải Ph ơng Trình" đ ợc đặt trong 3 th mục con c a th
mục S:GT Del-03.2007Add Form nh hình sau:

Hình 19: Cấu trúc th mục c a sản phẩm "Giải Ph ơng Trình"
Đ làm đ ợc đi u này, từ dự án đang m c a anh A, dùng lệnh Project/ Add To
Project... Shift+F11 đ thêm frmPTB1, untPTB1.pas vào dự án prjMain.dpr nh hình sau:
Hình 20: Thêm unit form untPTB1.pas vào dự án c a anh A
tiếp đến, bạn ch n tập tin unit form untPTB1.pas trong th mục PTB1 (dự án c a anh
B) và nhấn nút lệnh Open đ thêm vào.

Hình 21: Cửa sổ thêm untPTB1.pas vào dự án chính.
Hoàn toàn t ơng tự, bạn thêm vào unit form untPTB2.pas trong th mục PTB2 (dự
án c a anh C).
Và nh vậy trong sản phẩm c a anh A bây gi là 1 dự án có 3 form, nh hình sau:
Hình 22: Dự án anh A đư ch a đầy đ 3 form.
Trong tập tin dự án (Project file: prjMain.dpr) có sự tham chiếu (Reference/link) t i
các tập tin unit form trong các folder c a anh B và anh C nh hình sau:

Hình 23: Sự tham chiếu t i các unit form: untPTP1.pas và untPTP2.pas
T i đây, câu h i đ ợc đặt ra là trong th mục c a anh A đư ch a đầy đ các tập tin
c a sản phẩm ch a? Liệu bạn có th xóa b đi 2 th mục PTB1 và PTB2 không? Câu trả
l i là không. Một yêu cầu đ ợc đặt ra là anh A (tr ng nhóm) mu n tất cả các tập tin chỉ
nằm trong 1 folder c a anh ta (th mục S:GT Del-03.2007Add FormMain) thì làm nh
thế nào? Câu trả l i là anh A sẽ l u lại unit file: untPTB1.pas (t ơng tự cho untPTB2.pas)
vào th mục Main bằng lệnh File/Save As nh sau:
Hình 24: L u lại untPTB1.pas vào th mục c a anh A
Xem lại tập tin dự án, bạn thấy các tham chiếu t i các unit file đư nằm trong th mục
hiện hành (c a anh A):

Hình 25: Các tập tin unit form đư trong cùng 1 th mục anh A
II.4. Vi t l nh sau khi thêm unit form vƠo d án
Bây gi , từ main form (frmMain), anh A mu n hi n th (Show) form c a anh B hoặc
anh C thì sao? Chẳng hạn khi Click vào mục Bac 1 trong thực đơn Giai phuong trinh đ
hi n th form PTB1 lên nh hình sau:
Hình 26: Hi n th form "Phuong trinh bac nhat"
Đ làm đ ợc thì anh A sẽ gõ thêm câu lệnh frmPTB1.Show; đ hi n th frmPTB1:

Giao trinh Lap trinh can ban B – Delphi 7

Giao trinh Lap trinh can ban B – Delphi 7

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (20)

Similar to Giao trinh Lap trinh can ban B – Delphi 7

Similar to Giao trinh Lap trinh can ban B – Delphi 7 (20)

Giao trinh Lap trinh can ban B – Delphi 7