- Trang Chủ
- Kỹ thuật lập trình
- Giáo trình Lập trình hướng đối tượng (Nghề: Công nghệ thông tin - Cao đẳng) - Trường CĐ nghề Kỹ thuật Công nghệ
Xem mẫu
- BỘ LAO ĐỘNG - THƯƠNG BINH VÀ XÃ HỘI
TRƯỜNG CAO ĐẲNG NGHỀ KỸ THUẬT CÔNG NGHỆ
-----š›&š›-----
GIÁO TRÌNH
MÔ ĐUN : LẬP TRÌNH HƯỚNG ĐỐI TƯỢNG
NGHỀ: CÔNG NGHỆ THÔNG TIN
TRÌNH ĐỘ: CAO ĐẲNG
Ban hành kèm theo Quyết định số: 245/QĐ-CĐNKTCN ngày 23 tháng 10 năm 2020
của Hiệu trưởng Trường Cao đẳng nghề Kỹ thuật Công nghệ
Hà Nội, năm 2021
(Lưu hành nội bộ)
1
- TUYÊN BỐ BẢN QUYỀN:
Tài liệu này thuộc loại sách giáo trình nên các nguồn thông tin có thể được phép dùng
nguyên bản hoặc trích dùng cho các mục đích về đào tạo và tham khảo.
Mọi mục đích khác mang tính lệch lạc hoặc sử dụng với mục đích kinh doanh
thiếu lành mạnh sẽ bị nghiêm cấm.
MÃ TÀI LIỆU : MĐCNTT 10
2
- LỜI GIỚI THIỆU
C++ là ngôn ngữ lập trình hướng đối tượng được mở rộng từ ngôn ngữ C. Do vậy,
C++ có ưu điểm là kế thừa được các điểm mạnh truyền thống của ngôn ngữ C như uyển
chuyển, tương thích với các thiết bị phần cứng. Hiện nay, C++ là một ngôn ngữ lập trình
phổ biến, được giảng dạy tại các trường đại học trong nước và trên thế giới và đặc biệt
được sử dụng rộng rãi cho nhu cầu phát triển của công nghiệp phần mềm hiện nay. Tài
liệu này không những nhằm giới thiệu cho sinh viên ngôn ngữ lập trình C++, mà còn
mong muốn qua đó sinh viên có thể hiểu được tư tưởng của phương pháp lập trình hướng
đối tượng nói chung. Nội dung của tài liệu bao gồm hai phần chính:
• Phần thứ nhất là lập trình nâng cao với C++, bao gồm lập trình C++ với con trỏ
và mảng, các kiểu dữ liệu có cấu trúc cùng các thao tác vào ra trên tệp.
• Phần thứ hai là lập trình hướng đối tượng với C++, bao gồm các định nghĩa và các
thao tác trên lớp đối tượng, tính kế thừa và tương ứng bội trong C++, cách sử dụng một
số lớp cơ bản trong thư viện C++.
Mặc dù có rất nhiều cố gắng, nhưng không tránh khỏi những sai sót, rất mong nhận
được sự đóng góp ý kiến của độc giả để giáo trình được hoàn thiện hơn.
Xin chân thành cảm ơn!
Hà Nội, ngày 23 tháng 04 năm 2021
Tham gia biên soạn
1. Chủ biên Trần Thị Vinh
2. Tập thể Giảng viên Khoa CNTT
Mọi thông tin đóng góp chia sẻ xin gửi về hòm thư tranthivinhvnn@gmail.com hoặc liên
hệ số điện thoại 0978113529
3
- MỤC LỤC
LỜI GIỚI THIỆU ................................................................................................................. 3
MỤC LỤC ............................................................................................................................ 4
BÀI 1: TỔNG QUAN VỀ LẬP TRÌNH HƯỚNG ĐỐI TƯỢNG ......................................... 9
1. Lịch sử phát triển ........................................................................................................... 9
2. Khái niệm về lập trình hướng đối tượng và các đặc trưng .............................................. 9
3. Một số khái niệm cơ bản ................................................................................................ 9
3.1. Lớp, đối tượng ......................................................................................................... 9
3.2. Trừu tượng hóa ...................................................................................................... 10
3.3. Thông điệp, đóng gói, che dấu thông tin. ............................................................... 10
3.4. Kế thừa .................................................................................................................. 11
3.5. Đa hình .................................................................................................................. 11
4. Phân tích bài toán theo tiếp cận hướng đối tượng ......................................................... 11
5. Ngôn ngữ lập trình hướng đối tượng ............................................................................ 14
BÀI 2: LỚP VÀ ĐỐI TƯỢNG ........................................................................................... 17
1. Định danh .................................................................................................................... 17
1.1 Quy định với định danh .......................................................................................... 17
1.2.Quy ước với định danh ........................................................................................... 18
2.1. Kiểu dữ liệu nguyên thủy ....................................................................................... 19
2.2.Giá trị hằng............................................................................................................. 21
2.3.Chuyển đổi kiểu dữ liệu .......................................................................................... 21
2.4.Khai báo và khởi tạo biến, hằng.............................................................................. 22
3. Toán tử ........................................................................................................................ 23
3.1.Toán tử số học ........................................................................................................ 23
3.2. Toán tử bit ............................................................................................................. 23
3.3.Toán tử quan hệ ...................................................................................................... 24
3.4. Toán tử logic ......................................................................................................... 25
3.5. Toán tử gán ........................................................................................................... 25
4. Nhập và hiển thị dữ liệu lên màn hình .......................................................................... 27
4.1 Hiển thị dữ liệu lên màn hình.................................................................................. 27
4.2 Nhập dữ liệu từ bàn phím ....................................................................................... 27
5. Cấu trúc điều khiển ...................................................................................................... 27
4
- 5.1. Lệnh if-else............................................................................................................ 27
5.2. Lệnh switch-case ................................................................................................... 28
5.3. Vòng lặp while và do … while .............................................................................. 30
5.4.Vòng lặp for ........................................................................................................... 31
5.5.Các lệnh làm thay đổi cấu trúc lập trình .................................................................. 31
5.6.Phạm vi biến ........................................................................................................... 31
6.Mảng một chiều ............................................................................................................ 32
6.1.Khai báo và khởi tạo mảng ..................................................................................... 32
6.2.Một số thao tác với mảng một chiều ....................................................................... 32
7.Lập trình với cấu trúc lặp và các thao tác với mảng trong Java...................................... 33
BÀI 3: ĐÓNG GÓI VÀ XÂY DỰNG LỚP, TẠO VÀ SỬ DỤNG...................................... 35
1.Trừu tượng hóa dữ liệu ................................................................................................. 35
1.1.Trừu tượng hóa dữ liệu là gì?.................................................................................. 35
1.2.Trừu tượng hóa dữ liệu là gì?.................................................................................. 35
1.3.So sánh đối tượng và lớp ........................................................................................ 36
2. Đóng gói và xây dựng lớp ............................................................................................ 37
2.1. Đóng gói là gì? ...................................................................................................... 37
2.2. Xây dựng lớp ......................................................................................................... 37
2.3. Che giấu dữ liệu .................................................................................................... 38
2.4. Phương thức set/get ............................................................................................... 38
3. Tạo và sử dụng đối tượng ............................................................................................ 38
3.1. Khởi tạo dữ liệu ..................................................................................................... 38
3.2.Phương thức khởi tạo.............................................................................................. 38
3.3.Khai báo và khởi tạo đối tượng ............................................................................... 38
3.4.Sử dụng đối tượng .................................................................................................. 38
4. Từ khóa this ................................................................................................................. 40
5. Truyền tham số cho phương thức ................................................................................. 41
5.1. Truyền tham số kiểu dữ liệu tham trị ..................................................................... 41
5.2. Truyền tham số kiểu dữ liệu tham chiếu ................................................................ 41
6. Chồng phương thức ..................................................................................................... 42
7. Xây dựng lớp đơn giản, tạo và sử dụng các đối tượng .................................................. 43
8. Lớp String, StringBuilder, StringBuffer. ...................................................................... 52
BÀI 4: TỔNG QUAN VỀ JDBC ........................................................................................ 55
5
- 1. Tổng quan về JDBC..................................................................................................... 55
2. Cài đặt JDBC ............................................................................................................... 55
3. Kết nối cơ sở dữ liệu .................................................................................................... 56
4. Tạo ứng dụng JDBC .................................................................................................... 57
6
- GIÁO TRÌNHMÔ ĐUN
Tên mô đun: Lập trình hướng đối tượng
Mã mô đun: MĐCNTT 10
Vị trí, tính chất, ý nghĩa và vai trò của mô đun :
- Vị trí: Là mô đun chuyên ngành. Mô đun có thể được bố trí học khi đã học xong các
môn học cơ sở ngành như: Cơ sở dữ liệu, Ngôn ngữ lập trình C/C++, Cấu trúc dữ liệu và
giải thuật.
- Tính chất: Là mô đun cung cấp các khái niệm, đặc trưng cơ bản của lập trình hướng đối
tượng như: đối tượng, lớp đối tượng, phương thức, thuộc tính, nạp chồng, kế thừa, đóng gói,
trừu tượng, đa hình, …Ngoài ra, học phần còn cung cấp cách thức giải quyết bài toán theo tư
duy hướng đối tượng.
Mục tiêu của mô đun:
- Về kiến thức
+ Trình bày được các khái niệm và các thành phần cơ bản của lập trình hướng đối
tượng.
+ Phân tích được bài toán theo tư duy hướng đối tượng
+ Xác định được các đối tượng và lớp đối tượng trong các bài toán cụ thể
- Về kỹ năng
+ Thiết kế và xây dựng được lớp đối tượng bằng ngôn ngữ lập trình cụ thể
+ Lập trình giải quyết được bài toán thực tế ở mức đơn giản bằng ngôn ngữ lập trình
hướng đối tượng. Tích cực ứng dụng lập trình trực quan cho các ứng dụng trong
thực tế.
- Về năng lực tự chủ và trách nhiệm:
+ Khả năng tìm tài liệu, đọc hiểu tài liệu
+ Khả năng làm việc nhóm
Nội dung của mô đun:
Thời gian
Số
Tên các bài trong mô đun Tổng Lý Thực Kiểm
TT
số thuyết hành tra*
1 Bài 1: Tổng quan về lập trình hướng đối
tượng
1. Lịch sử phát triển
2. Khái niệm về lập trình hướng đối tượng
và các đặc trưng 10 3 7
3. Một số khái niệm cơ bản
4. Phân tích bài toán theo tiếp cận hướng
đối tượng
5. Ngôn ngữ lập trình hướng đối tượng
2 Bài 2: Lớp- Đối tượng
1. Định nghĩa Lớp đối tượng
2. Phạm vi Private, Public, Protected
20 5 14 1
3. Mảng đối tượng
4. Phương thức khởi tạo và phương thức
hủy bỏ
7
- 5. Con trỏ this
3 Bài 3: Đóng gói và xây dựng lớp; tạo và
sử dụng đối tượng
1. Trừu tượng hóa dữ liệu
2. Đóng gói và xây dựng lớp
3. Tạo và sử dụng đối tượng
4. Từ khóa this 20 5 14 1
5. Truyền tham số cho phương thức
6. Chồng phương thức
7. Xây dựng lớp đơn giản, tạo và sử dụng
các đối tượng
8. Lớp String, StringBuilder, StringBuffer.
4 Bài 4: Tổng quan về JDBC 10 2 7 1
1. Tổng quan về JDBC
2. Cài đặt JDBC
3. Kết nối Cơ sở dữ liệu
4. Tạo ứng dụng JDBC cơ bản
Thi kết thúc môn
Cộng 60 15 42 3
* Ghi chú: Thời gian kiểm tra lý thuyết được tính vào gìơ lý thuyết, Thời gian kiểm tra
thực hành được tính vào giờ thực hành.
2. Nội dung chi tiết:
8
- BÀI1: TỔNG QUAN VỀ LẬP TRÌNH HƯỚNG ĐỐI TƯỢNG
Mã bài: MĐCNTT 10.01
Giới thiệu:
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.
Mục tiêu:
- Trình bày được khái niệm và các đặc trưng của lập trình hướng đối tượng.
- Thực hiện được các thao tác cơ bản trên môi trường lập trình cụ thể. - So sánh được đặc
trưng của lập trình hướng đối tượng với một số phương pháp lập trình đã học.
- Nhận dạng được các khái niệm đối tượng tron lập trình hướng đối tượng
- Sử dụng được các lệnh cơ bản trong ngôn ngữ lập trình hướng đối tượng cụ thể.
Nội dung chính:
1. Lịch sử phát triển
Trong lập trình hướng đối tượng:
• Người ta coi các thực thể trong chương trình là các đối tượng và sau đó trừu tượng hoá
đối tượng thành lớp đối tượng.
• Dữ liệu được tổ chức thành các thuộc tính của lớp. Nguời ta ngăn chặn việc thay đổi tuỳ
tiện dữ liệu trong chương trình bằng các cách giới hạn truy nhập như chỉ cho phép truy
nhập dữ liệu thông qua đối tượng, thông qua các phương thức mà đối tượng được cung
cấp...
• Quan hệ giữa các đối tượng là quan hệ ngang hàng hoặc quan hệ kế thừa: Nếu lớp B kế
thừa từ lớp A thì A được gọi là lớp cơ sở và B được gọi là lớp dẫn xuất.
2. Khái niệm về lập trình hướng đối tượng và các đặ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 = Cấu trúc dữ liệu + Giải thuật
Trong đó:
• Cấu trúc dữ liệu là cách tổ chức dữ liệu cho việc xử lý bởi một hay nhiều chương trình
nào đó.
• 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 cấu trúc dữ liệu:
• Một cấu trúc dữ liệu chỉ phù hợp với một số hạn chế các giải thuật.
• Nếu thay đổi cấu trúc dữ liệu 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 cấu trúc dữ liệu nhất định.
3. Một số khái niệm cơ bản
3.1. Lớp, đối tượng
Đối tượng (Object)
Trong lập trình hướng đối tượng, đối tượng được coi là đơn vị cơ bản nhỏ nhất. Các dữ
diệu và
9
- cách xử lí chỉ là thành phần của đối tượng mà không được coi là thực thể. Một đối tượng
chứa các
dữ liệu của riêng nó, đồng thời có các phương thức (hành động) thao tác trên các dữ liệu
đó:
Đối tượng = dữ liệu + phương thức
Lớp (Class)
Khi có nhiều đối tượng giống nhau về mặt dữ liệu và phương thức, chúng được nhóm lại
với nhau
và gọi chung là lớp:
• Lớp là sự trừu tượng hoá của đối tượng
• Đối tượng là một thể hiện của lớp.
3.2. Trừu tượng hóa
Trừu tượng hóa dữ liệu (Data abstraction) liên quan tới việc chỉ cung cấp thông tin
cần thiết tới bên ngoài và ẩn chi tiết cơ sở của chúng, ví dụ: để biểu diễn thông tin cần
thiết trong chương trình mà không hiển thị chi tiết về chúng.
Trừu tượng hóa dữ liệu (Data abstraction) là một kỹ thuật lập trình mà dựa trên sự phân
biệt của Interface và Implementation (trình triển khai).
Xem xét ví dụ về một chiếc TV, bạn có thể bật/tắt, thay đổi kênh, chỉnh âm lượng, và
thêm các thiết bị ngoại vi như loa, VCR và DVD. Nhưng bạn không biết các chi tiết nội
vi của nó, đó là, bạn không biết cách nó nhận tín hiệu qua không khí hoặc qua dây cáp,
cách phiên dịch chúng và cuối cùng là hiển thị chúng trên màn hình.
Vì thế, có thể nói rằng một chiếc TV phân biệt rõ ràng trình triển khai nội vi của nó với
giao diện ngoại vi và bạn có thể thao tác với interface với các nút nguồn, điều khiển âm
lượng mà không cần có bất kỳ hiểu biết về những gì diễn ra bên trong nó.
Bây giờ, về mặt ngôn ngữ lập trình C++, thì các lớp C++ cung cấp Trừu tượng hóa dữ
liệu (Data abstraction) ở mức thật tuyệt vời. Chúng cung cấp đủ các phương thức public
tới bên ngoài để thao tác với tính năng của đối tượng và để thao tác dữ liệu đối tượng, ví
dụ: trạng thái mà không cần thực sự biết về cách lớp đó đã được triển khai nội tại.
Ví dụ, chương trình của bạn có thể tạo một lời gọi tới hàm sort() mà không cần biết về
hàm đó thực sự sử dụng thuật toán gì để sắp xếp các giá trị đã cho. Thực ra, trình triển
khai cơ sở (underlying implementation) của tính năng sắp xếp có thể thay đổi tùy vào thư
viện, và miễn là Interface vẫn như cũ thì lời gọi hàm của bạn vẫn tiếp tục làm việc.
3.3. Thông điệp, đóng gói, che dấu thông tin.
Đóng gói dữ liệu (Encapsulation)
• Các dữ liệu được đóng gói vào trong đối tượng. Mỗi dữ liệu có một phạm vi truy nhập
riêng.
• Không thể truy nhập đến dữ liệu một cách tự do như lập trình cấu trúc
• Muốn truy nhập đến các dữ liệu đã được bảo vệ, phải thông qua các đối tượng, nghĩa là
phải sử dụng các phương thức mà đối tượng cung cấp mới có thể truy nhập đến dữ liệu
của đối tượng đó.
Tuy nhiên, vì C++ chỉ là ngôn ngữ lập trình nửa đối tượng, cho nên C++ vẫn cho phép
định nghĩa
các biến dữ liệu và các hàm tự do, đây là kết quả kế thừa từ ngôn ngữ C, một ngôn ngữ
lập trình
thuần cấu trúc.
10
- 3.4. Kế thừa
Kế thừa (Inheritance)
Tính kế thừa của lập trình hướng đối tượng cho phép một lớp có thể kế thừa từ một số
lớp đã tồn
tại. Khi đó, lớp mới có thể sử dụng dữ liệu và phương thức của các lớp cơ sở như là của
mình.
Ngoài ra, lớp dẫn xuất còn có thể bổ sung thêm một số dữ liệu và phương thức. Ưu điểm
của kế
thừa là khi thay đổi dữ liệu của một lớp, chỉ cần thay đổi các phương thức trong phạm vi
lớp cơ sở
mà không cần thay đổi trong các lớp dẫn xuất.
3.5. Đa hình
Đa hình (Polymorphsim)
Đa hình là khái niệm luôn đi kèm với kế thừa. Do tính kế thừa, một lớp có thể sử dụng lại
các
phương thức của lớp khác. Tuy nhiên, nếu cần thiết, lớp dẫn xuất cũng có thể định nghĩa
lại một
số phương thức của lớp cơ sở. Đó là sự nạp chồng phương thức trong kế thừa. Nhờ sự
nạp chồng
phương thức này, ta chỉ cần gọi tên phương thức bị nạp chồng từ đối tượng mà không cần
quan
tâm đó là đối tượng của lớp nào. Chương trình sẽ tự động kiểm tra xem đối tượng là
thuộc kiểu
lớp cơ sở hay thuộc lớp dẫn xuất, sau đó sẽ gọi phương thức tương ứng với lớp đó. Đó là
tính đahình.
4. Phân tích bài toán theo tiếp cận hướng đối tượng
Phương pháp 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 cấu trúc dữ liệu, nếu
thay đổi cấu trúc dữ liệu, sẽ phải thay đổi giải thuật, và do đó, phải viết lại mã chương
trình từ đầu.
Để 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.
Việc đóng gói dữ liệu được thực hiện theo phương pháp trừu tượng hoá đối tượng thành
lớp từ thấp lên cao như sau:
• Thu thập các thuộc tính của mỗi đối tượng, gắn các thuộc tính vào đối tượng tương ứng.
• Nhóm các đối tượng có các thuộc tính tương tự nhau thành nhóm, loại bỏ bớt các thuộc
tính cá biệt, chỉ giữ lại các thuộc tính chung nhất. Đây được gọi là quá trình trừu tượng
hoá đối tượng thành lớp.
11
- • Đóng gói dữ liệu của các đối tượng vào lớp tương ứng. Mỗi thuộc tính của đối tượng trở
thành một thuộc tính của lớp tương ứng.
• Việc truy nhập dữ liệu được thực hiện thông qua các phương thức được trang bị cho
lớp. Không được truy nhập tự do trực tiếp đến dữ liệu.
• Khi có thay đổi trong dữ liệu của đối tượng, ta chỉ cần thay đổi các phương thức truy
nhập thuộc tính của lớp, mà không cần phải thay đổi mã nguồn của các chương trình sử
dụng lớp tương ứ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 được 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.
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.
Đặc trưng
Lập trình hướng đối tượng có hai đặc trưng cơ bản:
• Đó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.
• Sử dụng lại mã nguồn: việc sử dụng lại mã nguồn được thể hiện thông qua cơ chế kế
thừa. Cơ chế này cho phép các lớp đối tượng có thể kế thừa 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 (mã nguồn) của các lớp bị
kế thừa, mà không cần phải định nghĩa lại.
Ưu điểm
Lập trình hướng đối tượng có một số ưu điểm nổi bật:
• Không còn nguy cơ dữ liệu bị thay đổi tự do trong chương trình. Vì dữ liệu đã được
đóng gói vào các đối tượng. Nếu muốn truy nhập vào dữ liệu phải thông qua các phương
thức cho phép của đối tượng.
• Khi thay đổi cấu trúc dữ liệu của một đối tượng, không cần thay đổi các đổi mã nguồn
của các đối tượng khác, mà chỉ cần thay đổi một số hàm thành phần của đối tượng bị thay
đổi.
Điều này hạn chế sự ảnh hưởng xấu của việc thay đổi dữ liệu đến các đối tượng khác
trong chương trình.
• Có thể sử dụng lại mã nguồn, tiết kiệm tài nguyên. Vì nguyên tắc kế thừa cho phép các
lớp kế thừa sử dụng các phương thức được kế thừa từ lớp khác như những phương thức
của chính nó, mà không cần thiết phải định nghĩa lại.
• Phù hợp với các dự án phần mềm lớn, phức tạp.
Phương pháp phân tích và thiết kế hướng đối tượng:
Một vấn đề cơ bản đặt ra cho phương pháp hướng đối tượng là từ một bài toán ban đầu,
làm sao để thu được một tập các đối tượng, với các chức năng được phối hợp với nhau,
đáp ứng được yêu cầu của bài toán đặt ra?
12
- Phương pháp phân tích thiết kế hướng đối tượng ra đời nhằm trả lời cho câu hỏi này.
Mục đích là xây dựng một tập các lớp đối tượng tương ứng với mỗi bài toán, phương
pháp này tiến hành theo hai pha chính:
Pha phân tích: Chuyển đổi yêu cầu bài toán từ ngôn ngữ tự nhiên sang ngôn ngữ mô hình.
Pha thiết kế: Chuyển đổi đặc tả bài toán dưới dạng ngôn ngữ mô hình sang một mô hình
cụ thể có thể cài đặt được.
Hai pha phân tích và thiết kế này bao gồm nhiều bước khác nhau(gồm 6 bước):
• Mô tả bài toán
• Đặc tả yêu cầu
• Trích chọn đối tượng
• Mô hình hoá lớp đối tượng
• Thiết kế tổng quan
• Thiết kế chi tiết.
Bước 1: Mô tả bài toán
Bài toán ban đầu được phát biểu dưới dạng ngôn ngữ tự nhiên, bao gồm:
• Mục đích, chức năng chung
• Các yêu cầu về thông tin dữ liệu
• Các yêu cầu về chức năng thực hiện
Bước 2: Đặc tả yêu cầu
Các yêu cầu được hình thức hoá lên một mức cao hơn bằng cách sử dụng ngôn ngữ kiểu
kịch bản(scenario) để mô tả. Trong một kịch bản, mỗi chức năng, mỗi hoạt động được
mô tả bằng một kịch bản, bao gồm:
• Các tác nhân tham gia vào kịch bản.
• Vai trò của mỗi tác nhân trong kịch bản.
• Thứ tự các hành động mà mỗi tác nhân thực hiện: khi nào thực hiện, tác động vào tác
nhân nào, thông tin nào được trao đổi.
Quá trình trên được tiến hành với tất cả các chức năng yêu cầu của hệ thống.
Bước 3: Trích chọn đối tượng
Bước này sẽ tiến hành đề xuất các đối tượng có thể có mặt trong hệ thống:
• Dựa vào các kịch bản được mô tả trong bước hai, chọn ra các tác nhân có xuất hiện để
đề xuất thành các đối tượng.
• Lựa chọn các đối tượng bằng cách loại bỏ các tác nhân bên ngoài hệ thống, các tác nhân
trùng lặp.
• Cuối cùng, ta thu được tập các đối tượng của hệ thống.
Bước 4: Mô hình hoá lớp đối tượng
Bước này tiến hành trừu tượng hoá đối tượng thành các lớp:
• Thu thập tất cả các thuộc tính của mỗi đối tương vừa thu thập được, dựa vào yêu cầu về
thông tin trong yêu cầu hệ thống (từ bước 1).
• Thu thập các hành động mà mỗi đối tượng cần thực hiện, dựa vào các kịch bản mà đối
tượng tương ứng có tham gia (trong bước 2).
• Nhóm các đối tượng tương tự nhau, hoặc có nhiều thuộc tính gần giống nhau.
• Loại bỏ một số thuộc tính cá biệt, riêng tư của một số đối tượng trong nhóm.
• Mô hình mỗi nhóm đối tượng còn lại thành lớp: Các thuộc tính chung của các đối tượng
thành thuộc tính của lớp, các hành động của các đối tượng thành phương thức của lớp.
Kết quả thu được một tập các lớp đối tượng ban đầu của hệ thống.
Bước 5: Thiết kế tổng quát
13
- Bước này sẽ tiến hành thiết kế vĩ mô, nghĩa là thiết kế mối quan hệ giữa các lớp trong hệ
thống:
• Xác định sơ đồ thừa kế, nếu có, giữa các lớp: Nếu hai lớp có một số thuộc tính chung,
thì tách các thuộc tính chung làm thành một lớp cơ sở, và hai lớp ban đầu đều dẫn xuất từ
lớp cơ sở đó. Thông thường, lớp các trừu tượng (chung nhất) sẽ làm lớp cơ sở, lớp càng
cụ thể, càng chi tiết thì làm lớp dẫn xuất (lớp con, cháu).
• Xác định tương tác, nếu có, giữa các lớp: Dựa vào các kịch bản được mô tả trong bước
2, hai tác nhân có tương tác với nhau thì hai lớp tương ứng ở bước này cũng có tương tác
với nhau.
Kết quả thu được của bước này là một sơ đồ quan hệ bên ngoài giữa các lớp trong hệ
thống.
Bước 6: Thiết kế chi tiết
Bước này sẽ thực hiện thiết kế ở mức vi mô, nghĩa là thiết kế kiến trúc bên trong của mỗi
lớp đối tượng:
• Tổ chức dữ liệu của lớp theo các thuộc tính. Qui định phạm vi truy nhập cho từng thuộc
tính.
• Thiết kế chi tiết cách cư xử của lớp đối tượng thông qua các phương thức của lớp: Xác
định kiểu dữ liệu trả về, kiểu tham số của phương thức, mô tả thuật toán chi tiết cho từng
phương thức, nếu cần.
Kết quả thu được của bước này là một tập các lớp với thiết kế chi tiết kiến trúc bên trong.
Sau các bước phân tích thiết kế hướng đối tượng từ một yêu cầu của bài toán ban đầu, ta
thu được một mô hình hệ thống hướng đối tượng chi tiết:
• Có cái nhìn tổng quan, vĩ mô về hệ thống bằng mô hình thiết kế tổng quan, chỉ rõ số
lượng các lớp đối tượng, mối quan hệ kế thừa và quan hệ tương tác giữa các lớp đối
tượng trong hệ thống.
• Có cái nhìn chi tiết, vi mô về hệ thống bằng mô hình thiết kế chi tiết. Mô hình này chỉ
rõ bên trong mỗi lớp đối tương: các thuộc tính, các phương thức với kiểu trả về và kiểu
tham số, thuật toán chi tiết cho mỗi phương thức.
Sau pha phân tích và thiết kế hướng đối tượng, ta thu được đặc tả hệ thống dưới dạng mô
hình các lớp: quan hệ giữa các lớp và kiến trúc bên trong của mỗi lớp. Đây sẽ là đầu vào
cho pha tiếp theo, pha lập trình hướng đối tượng, như chúng ta đã biết.
5. Ngôn ngữ lập trình hướng đối tượng
Đặc trưng
Lập trình hướng đối tượng có hai đặc trưng cơ bản:
• Đó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.
• Sử dụng lại mã nguồn: việc sử dụng lại mã nguồn được thể hiện thông qua cơ chế kế
thừa. Cơ chế này cho phép các lớp đối tượng có thể kế thừa từ các lớp đối tượng khác.
Khi
đó, trong các lớp dẫn xuất, có thể sử dụng các phương thức (mã nguồn) của các lớp cơ sở
mà không cần phải định nghĩa lại.
Ưu điểm
Lập trình hướng đối tượng có một số ưu điểm nổi bật:
• Không còn nguy cơ dữ liệu bị thay đổi tự do trong chương trình. Vì dữ liệu đã được
đóng
14
- gói vào các đối tượng. Nếu muốn truy nhập vào dữ liệu phải thông qua các phương thức
được cho phép của đối tượng.
• Khi thay đổi cấu trúc dữ liệu của một đối tượng, không cần thay đổi mã nguồn của các
đối
tượng khác, mà chỉ cần thay đổi một số thành phần của đối tượng dẫn xuất. Điều này hạn
chế sự ảnh hưởng xấu của việc thay đổi dữ liệu đến các đối tượng khác trong chương
trình.
• Có thể sử dụng lại mã nguồn, tiết kiệm tài nguyên, chi phí thời gian. Vì nguyên tắc kế
thừa cho phép các lớp dẫn xuất sử dụng các phương thức từ lớp cơ sở như những phương
thức của chính nó, mà không cần thiết phải định nghĩa lại.
• Phù hợp với các dự án phần mềm lớn, phức tạp.
15
- Bài tập thực hành
Hãy phân tích bài toán sau theo hướng tiếp cận đối tượng
Xây dựng lớp Color gồm:
Thuộc tính: TenMau, MaMau
Phương thức:
· Cấu tử không tham số
· Cấu tử có tham số
· Hủy
· Nạp chồng toán tử nhập
· Nạp chồng toán tử xuất
· getTenMau() : hàm trả về TenMau
Xây dựng lớp Point gồm:
Thuộc tính: int x, y
Phương thức:
· Cấu tử không tham số
· Cấu tử có tham số
· Hủy
· Nạp chồng toán tử nhập
· Nạp chồng toán tử xuất
· CheoChinh : hàm kiểm tra Point có thuộc đường chéo chính hay không (1 điểm
thuộc đường chéo chính khi và chỉ khi tung độ bằng hoành độ).
Xây dựng lớp Pixel kế thừa từ lớp Color và Point bao gồm thêm:
Phương thức:
· Cấu tử không tham số
· Cấu tử có tham số
· Nạp chồng toán tử nhập
· Nạp chồng toán tử xuất
· KiemTra: hàm kiểm tra Pixel thuộc đường chéo chính và có màu “Xanh” hay
không?
Chương trình chính: Nhập vào từ bàn phím n Pixel (n nhập từ bàn phím). Hiển
thị thông
tin các Pixel thuộc đường chéo chính và có màu xanh.
16
- BÀI 2: LỚP VÀ ĐỐI TƯỢNG
MÃ BÀI MĐCNTT 10.02
Giới thiệu
Ngôn ngữ C++ được phát triển từ C lên, nó được bổ sung thêm tính hướng đối tượng.
Các lớp (class) là tính năng trung tâm của C++ mà hỗ trợ lập trình hướng đối tượng và
thường được gọi là các kiểu người dùng tự định nghĩa (user-defined).
Một lớp được sử dụng để xác định form của một đối tượng và nó kết nối sự biểu diễn dữ
liệu và các phương thức để thao tác các dữ liệu đó vào trong một package gọn gàng. Dữ
liệu và hàm bên trong một lớp được gọi là các thành viên của lớp đó.
Mục tiêu
- Trình bày được các khái niệm Lớp, lớp đối tượng, thuộc tính, phương thức.
- Trình bày được khái niệm về phạm vi thông tin trong lớp.
- Trình bày được khái niệm và tác dục của hàm tạo, hàm hủy- Phân tích và xác định được
các thành phần thuộc tính và phương thức của lớp.
- Trình bày được cú pháp định nghĩa lớp, định nghĩa các thành phần của lớp với ngôn
ngữ lập trình cụ thể.
- Trình bày được cú pháp và xác định được nội dung hàm hủy, hàm tạo trong ngôn ngữ
lập trình cụ thể.
- Sử dụng được ngôn ngữ lập trình hướng đối tượng định nghĩa được lớp với các thành
phần.
- Phân tích và xác định được các lớp đối tượng trong bài toán thực tế.
- Xây dựng được chương trình, sử dụng lớp đối tượng đã định nghĩa được.
Nội dung
1. Định danh
1.1 Quy định với định danh
Một khi phương thức được khai báo là trừu tượng thì khi một con trỏ gọi đến phương
thức đó, chương trình sẽ thực hiện phương thức tương ứng với đối tượng mà con trỏ đang
trỏ tới, thay vìthực hiện phương thức của lớp cùng kiểu với con trỏ. Đây được gọi là hiện
tượng đa hình (tươngứng bội) trong C++.
Chương trình 6.9 minh hoạ việc sử dụng phương thức trừu tượng: lớp Bus kế thừa từ lớp
Car, hai lớp này cùng định nghĩa phương thức trừu tượng show().
· Khi ta dùng một con trỏ có kiểu lớp Car trỏ vào địa chỉ của một đối tượng kiểu Car,
nó sẽ gọi phương thức show() của lớpCar.
· Khi ta dùng cũng con trỏ đó, trỏ vào địa chỉ của một đối tượng kiểu Bus, nó sẽ gọi
phương thức show() của lớpBus.
Chương trình 6.9 hiển thị kết quả thông báo như sau:
This is a Ford having a speed of 100km/h and its price is $3000
This is a bus of type Mercedes, on the line 27, having a speed of 150km/h
and its price is $5000
Dòng thứ nhất là kết quả khi con trỏ ptrCar trỏ đến địa chỉ của đối tượng myCar,
thuộc lớp Car nên sẽ gọi phương thức show() của lớp Car với các dữ liệu của đối
tượng myCar: (100, Ford, 1463000). Dòng thứ hai tương ứng là kết quả khi con
trỏ ptrCar trỏ đến địa chỉ của đối tượng myBus, thuộc lớp Bus nên sẽ gọi phương
thức show() của lớp Bus, cùng với các tham số của đối tượng myBus: (150,
Mercedes, 5000, 27).
17
- Lưu ý:
Trong trường hợp ở lớp dẫn xuất không định nghĩa lại phương thức trừu tượng, thì
chương trình sẽ gọi phương thức của lớp cơ sở, nhưng với dữ liệu của lớp dẫnxuất.
Ví dụ, nếu trong chương trình 6.9, lớp Bus không định nghĩa chồng phương thức trừu
tượng show() thì kết quả hiển thị sẽ là hai dòng thông báo giống nhau, chỉ khác nhau ở
dữ liệu của hai đối tượng khác nhau:
This is a Ford having a speed of 100km/h and its price is $3000 This is a Mercedes
having a speed of 150km/h and its price is$5000
1.2.Quy ước với định danh
Thông thường khi mới học lập trình c++ sẽ chỉ viết những chương trình đơn giản nên
không quan tâm đến việc đặt tên trong c++. Nhưng sau này, khi làm những dự án lớn nếu
không có cách đặt tên cụ thể thì sẽ rất khó hiểu cho cả mình với người khác. Nên trong
bài này mình sẽ nói về một số quy ước đặt tên trong c++.
Quy tắc chung
· Tên phải bắt đầu bằng chữ cái hoặc dấu gạch dưới _. Ví dụ: Laptrinh1, _Laptrinh...
· Không được dùng những từ khóa như: const, char, int …
· Tên không được có các toán tử.
· Hai biến trong cùng một hàm không được trùng tên.
· Tên biến không có dấu cách.
Biến là một giá trị không thay đổi
Các biến khai báo là const thì phải viết hoa toàn bộ tên biến hoặc đặt tên có chữ "k" đứng
trước tên biến.
Tên tệp.
Tất cả các tên tệp phải là chữ thường và có thể bao gồm dấu gạch dưới ( _) hoặc dấu gạch
ngang ( -). Tuân theo quy ước mà dự án của bạn sử dụng và đặt tên thật cụ thể.
Ví dụ :
· my_useful_class.cc
· my-useful-class.cc
Tên hàm
Tên hàm trong c++ thường sẽ viết hoa chữ cái đầu của mỗi từ mới
Class
Tên class nên là một danh từ và sẽ viết hoa chữ cái đầu của tất cả các từ.
Tên biến
Tên biến trong c++ các bạn nên đặt là từ có ý nghĩa, ngắn gọn, dễ hiểu có thể viêt thường,
dung dấu gạch ngang "_" hoặc viết hoa khi có viết từ mới nhưng thông thường mình sẽ
dùng dấu gạch ngang, miễn sao bạn tuân theo cách đặt tên chung mà mình đã nêu ở trên.
18
- 2. Các kiểu dữ liệu
2.1. Kiểu dữ liệu nguyên thủy
Số nguyên, số thực, ký tự, boolean
Kiểu dữ liệu trong C++ xác định loại dữ liệu mà một biến có thể lưu trữ như số
nguyên, số thực, ký tự vv.Bạn có thể lưu thông tin của các kiểu dữ liệu (Data Type) đa
dạng như Character, Wide Character, integer, floating-point, double floating point,
Boolean, …. Dựa trên kiểu dữ liệu của một biến, hệ thống sẽ cấp phát bộ nhớ và quyết
định những gì có thể được lưu giữ trong bộ nhớ dành riêng đó.Tên tiếng Anh là
Primitive Type, còn có thể gọi là kiểu dữ liệu gốc, kiểu dữ liệu cơ bản, hay kiểu dữ liệu
có sẵn trong C++. Bên cạnh các kiểu dữ liệu gốc này, C++ cũng cung cấp các kiểu dữ
liệu do người dùng tự định nghĩa (user-defined). Bảng dưới đây liệt kê danh sách 7 kiểu
dữ liệu cơ bản trong C++:
Kiểu dữ liệu Từ khóa
Boolean bool
Ký tự char
Số nguyên int
Số thực float
Số thực dạng Double double
Kiểu không có giá trị void
Kiểu Wide character wchar_t
Một số kiểu cơ bản có thể được sửa đổi bởi sử dụng một hoặc nhiều modifier sau:
· signed (kiểu có dấu)
· unsigned (kiểu không có dấu)
· short
· long
Các loại dữ liệu nguyên thủy
Các kiểu dữ liệu cơ bản dựa trên số nguyên và số thực. Ngôn ngữ C hỗ trợ cả signed và
unsigned.
Kích thước bộ nhớ của các loại dữ liệu cơ bản có thể thay đổi theo hệ điều hành 32 hoặc
64 bit.
Hãy xem các kiểu dữ liệu cơ bản. Kích thước của nó được cho theo kiến trúc 32 bit.
Bảng sau hiển thị kiểu biến, lượng bộ nhớ nó dùng để lưu giá trị trong bộ nhớ, và giá trị
lớn nhất và nhỏ nhất có thể được lưu giữ với các kiểu biến đó:
Kiểu Kích thước Vùng giá trị
bộ nhớ
19
- char 1 byte -127 tới 127 hoặc 0 tới 255
unsigned char 1 byte 0 tới 255
signed char 1 byte -127 tới 127
int 4 byte -2147483648 tới 2147483647
unsigned int 4 byte 0 tới 4294967295
signed int 4 byte -2147483648 tới 2147483647
short int 2 byte -32768 tới 32767
unsigned short int Range 0 tới 65,535
signed short int Range -32768 tới 32767
long int 4 byte -2,147,483,647 tới 2,147,483,647
signed long int 4 byte Tương tự như long int
unsigned long int 4 byte 0 tới 4,294,967,295
float 4 byte +/- 3.4e +/- 38 (~7 chữ số)
double 8 byte +/- 1.7e +/- 308 (~15 chữ số)
long double 8 byte +/- 1.7e +/- 308 (~15 chữ số)
wchar_t 2 hoặc 4 1 wide character
byte
Ví dụ sử dụng toán tử để lấy gia kích cỡ kiểu dữ liệu
#include
using namespace std;
intmain() {
cout
nguon tai.lieu . vn
