Bài giảng Lập Trình Hướng Đối Tượng

UBND TỈNH THANH HÓA
TRƯỜNG ĐẠI HỌC HỒNG ĐỨC

TRỊNH THỊ PHÚ

BÀI GIẢNG
LẬP TRÌNH HƯỚNG ĐỐI TƯỢNG

Thanh Hóa, năm 2020


MỤC LỤC
MỤC LỤC .............................................................................................................................................. 2
Chương 1: MỞ ĐẦU .............................................................................................................................. 4
1.1. Những khái niệm cơ bản của lập trình hướng đối tượng ................................................................. 4
1.1.1. Phương pháp tiếp cận của lập trình truyền thống.......................................................................... 4
1.1.2. Phương pháp tiếp cận của lập trình hướng đối tượng ................................................................... 5
1.1.3. Các khái niệm cơ bản của lập trình hướng đối tượng ................................................................... 6
1.1.4. Xu hướng phát triển của lập trình hướng đối tượng ...................................................................... 7
1.2. Ngơn ngữ lập trình hướng đối tượng JAVA .................................................................................... 7
1.2.1. Các ngơn ngữ lập trình hướng đối tượng ...................................................................................... 7
1.2.2. Giới thiệu về JAVA ...................................................................................................................... 8
1.2.3. Các thành phần cơ bản của ngơn ngữ lập trình Java ..................................................................... 9
1.2.4. Các cấu trúc điều khiển ............................................................................................................... 16
1.2.5. Nhập xuất trong JAVA ............................................................................................................... 23
Chương 2: LỚP VÀ ĐỐI TƯỢNG ....................................................................................................... 26
2.1. LỚP VÀ ĐỐI TƯỢNG .................................................................................................................. 26
2.1.1. Khái niệm lớp và đối tượng ........................................................................................................ 26
2.1.2. Khai báo/định nghĩa lớp .............................................................................................................. 26
2.1.3. Tạo đối tượng của lớp ................................................................................................................. 27
2.1.4. Thuộc tính của lớp ...................................................................................................................... 27

2.1.5. Hàm – phương thức class ............................................................................................................ 28
2.1.6. Từ khóa this ................................................................................................................................ 30
2.1.7. Phương thức setter và getter........................................................................................................ 35
2.1.8. Constructor.................................................................................................................................. 37
2.2. GĨI (PACKAGES) ........................................................................................................................ 38
2.2.1. Tính đóng gói trong Java ............................................................................................................ 38
2.2.2. Khái niệm gói (package) ............................................................................................................. 39
2.2.3. Tạo một package trong Java........................................................................................................ 39
2.2.4. Cách biên dịch Java package ...................................................................................................... 39
2.2.5. Từ khóa import trong Java .......................................................................................................... 40
2.2.6. Sử dụng class .............................................................................................................................. 42
CHƯƠNG 3: THỪA KẾ VÀ ĐA HÌNH .............................................................................................. 45
3.1. THỪA KẾ ...................................................................................................................................... 45
3.1.1. Quan hệ thừa kế .......................................................................................................................... 45
3.1.2. Cài đặt quan hệ thừa kế ............................................................................................................... 45
3.1.3. Các kiểu kế thừa trong Java ........................................................................................................ 47
3.1.4. Thành viên final .......................................................................................................................... 49
3.2. ĐA HÌNH ....................................................................................................................................... 50
3.2.1. Upcast và downcast ..................................................................................................................... 50
3.2.2. Static Binding và Dynamic Binding ........................................................................................... 51
3.2.3. Overriding ................................................................................................................................... 52
3.2.4. Overloading................................................................................................................................. 55
3.2.5. Tốn tử móc xích giữa các lớp kế thừa this() và super()............................................................. 56
3.3. INTERFACE VÀ INNER CLASS ................................................................................................ 58
3.3.1. Interface ...................................................................................................................................... 58
3.3.2. Inner Class .................................................................................................................................. 60
3.4. LỚP TRỪU TƯỢNG ..................................................................................................................... 61
3.4.1. Lớp trừu tượng (abstract) ............................................................................................................ 61
3.4.3. So sánh abstract class và interface .............................................................................................. 62
3.4.4. Lớp final ...................................................................................................................................... 63

3.6. MỘT SỐ LỚP CƠ BẢN TRONG JAVA ...................................................................................... 63
3.6.1 Các lớp Wapper (Integer, Double, Float,...) và Array.................................................................. 63
3.6.2 Các lớp Collection (Collection, Set, List, Map, ArrayList, Vector, Hashtable, Hashset, HashMap)
.............................................................................................................................................................. 64
3.6.3 Nhóm lớp về String (String, StringBuffer, StringBuilder)........................................................... 65
3.6.4 Các lớp tiện ích khác (StringTokenizer, Date, Calendar, SimpleDateFormat, Arrays) ............... 66
3.6.5 RegularExpression ....................................................................................................................... 67
Chương 4: Các luồng vào ra dữ liệu với file – Xử lý ngoại lệ .............................................................. 69
4.1. CÁC LUỒNG VÀO/RA TRONG JAVA ...................................................................................... 69
4.1.1. Khái niệm luồng.......................................................................................................................... 69
2


4.1.2. Luồng vào/ra là tệp ..................................................................................................................... 69
4.2. Vào ra trên thiết bị chuẩn ............................................................................................................... 73
4.2.1. Xuất dữ liệu ra màn hình............................................................................................................. 74
4.2.2. Đọc dữ liệu từ bàn phím vào chương trình ................................................................................. 74
4.3. Xử lý ngoại lệ................................................................................................................................. 75
4.3.1. Khái niệm .................................................................................................................................... 75
4.3.2. Sử dụng khối try … catch để xử lý ngoại lệ................................................................................ 75
4.3.3. Dùng try có nhiều catch .............................................................................................................. 76
4.3.4. Xử lý ngoại lệ trong java – Sử dụng từ khóa throws .................................................................. 77
4.3.5. Xử lý ngoại lệ trong java – Tự tạo exception.............................................................................. 78
Chương 5: LẬP TRÌNH CƠ SỞ DỮ LIỆU .......................................................................................... 79
5.1. Giới thiệu JDBC – ODBC.............................................................................................................. 79
5.2. Kiến trúc JDBC .............................................................................................................................. 79
5.3. Kết nối đến CSDL .......................................................................................................................... 79
5.4. Các thao tác cơ bản trên CSDL ...................................................................................................... 80

3

Chương 1: MỞ ĐẦU
1.1. Những khái niệm cơ bản của lập trình hướng đối tượng
1.1.1. Phương pháp tiếp cận của lập trình truyền thống
Để hiểu rõ tại sao lại phải học lập trình hướng đối tượng thì chúng ta sẽ xem xét các phương
pháp lập trình truyền thống, từ đó sẽ thấy được các ưu và nhược điểm của từng phương pháp.
Nội dung chúng ta sẽ tìm hiểu các phương pháp sau:
Lập trình truyền thống đã trải qua hai giai đoạn:
- Giai đoạn sơ khai, khi khái niệm lập trình mới ra đời, là lập trình tuyến tính.
- Giai đoạn tiếp theo, là lập trình hướng cấu trúc.

1. Lập trình tuyến tính
Đặc trưng cơ bản của lập trình tuyến tính là tư duy theo lối tuần tự. Chương trình sẽ được thực
hiện tuần tự từ đầu đến cuối, lệnh này kế tiếp lệnh kia cho đến khi kết thúc chương trình.
Đặc trưng:
Lập trình tuyến tính có hai đặc trưng:
- Đơn giản: chương trình được tiến hành đơn giản theo lối tuần tự, khơng phức tạp.
- Đơn luồng: chỉ có một luồng (thread) công việc duy nhất, và các công việc được thực hiện tuần
tự trong luồng đó.
Tính chất:
- Ưu điểm: Do tính đơn giản, lập trình tuyến tính có ưu điểm là chương trình đơn giản, dễ hiểu.
Lập trình tuyến tính được ứng dụng cho các chương trình đơn giản.
- Nhược điểm: Với các ứng dụng phức tạp, người ta khơng thể dùng lập trình tuyến tính để giải
quyết.
Ngày nay, lập trình tuyến tính chỉ tồn tại trong phạm vi các mơ đun nhỏ nhất của các phương
pháp lập trình khác. Ví dụ trong một chương trình con của lập trình cấu trúc, các lệnh cũng được thực
hiện theo tuần tự từ đầu đến cuối chương trình con.

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

Trong lập trình hướng cấu trúc, chương trình chính được chia nhỏ thành các chương trình con và
mỗi chương trình con thực hiện một cơng việc xác định. Chương trình chính sẽ gọi đến chương trình con
theo một giải thuật, hoặc một cấu trúc được xác định trong chương trình chính.
Các ngơn ngữ lập trình cấu trúc phổ biến là Pascal, C và C++. Riêng C++ ngồi việc có đặc trưng
của lập trình cấu trúc do kế thừa từ C, cịn có đặc trưng của lập trình hướng đối tượng. Cho nên C++ cịn
được gọi là ngơn ngữ lập trình nửa cấu trúc, nửa hướng đối tượng.
Đặc trưng:
Đặc trưng cơ bản nhất của lập trình cấu trúc thể hiện ở mối quan hệ:
Chương trình = Cấu trúc dữ liệu + Giải thuật
Trong đó:
- Cấu trúc dữ liệu (CTDL) là cách tổ chức dữ liệu, cách mơ tả bài tốn dưới dạng ngơn ngữ lập
trình,
- Giải thuật là một quy trình để thực hiện một cơng việc xác định.
Trong chương trình, giải thuật có quan hệ phụ thuộc vào CTDL:
- Một CTDL chỉ phù hợp với một số hạn chế các giải thuật.
- Nếu thay đổi CTDL thì phải thay đổi giải thuật cho phù hợp.
- Một giải thuật thường phải đi kèm với một CTDL nhất định.
Tính chất:
- Mỗi chương trình con có thể được gọi thực hiện nhiều lần trong một chương trình chính.
- Các chương trình con có thể được gọi đến để thực hiện theo một thứ tự bất kỳ, tuỳ thuộc vào giải
thuật trong chương trình chính mà khơng phụ thuộc vào thứ tự khai báo của các chương trình con.
- Các ngơn ngữ lập trình cấu trúc cung cấp một số cấu trúc lệnh điều khiển chương trình.
Ưu điểm:
- Chương trình sáng sủa, dễ hiểu, dễ theo dõi.
- Tư duy giải thuật rõ ràng.
Nhược điểm:
- Lập trình cấu trúc khơng hỗ trợ việc sử dụng lại mã nguồn: Giải thuật luôn phụ thuộc chặt chẽ
vào CTDL, do đó, khi thay đổi CTDL, phải thay đổi giải thuật, nghĩa là phải viết lại chương trình.
- Không phù hợp với các phần mềm lớn: tư duy cấu trúc với các giải thuật chỉ phù hợp với các bài
tốn nhỏ, nằm trong phạm vi một mơ đun của chương trình. Với dự án phần mềm lớn, lập trình cấu trúc

tỏ ra khơng hiệu quả trong việc giải quyết mối quan hệ vĩ mô giữa các mô đun của phần mềm.
Vấn đề
4


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

1.1.2. Phương pháp tiếp cận của 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 số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 hố đối tượng thành lớp.
• Đó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 ln đượ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.

5


1.1.3. Các khái niệm cơ bản của lập trình hướng đối tượng
1. Class:
Một class là một tập hợp các đối tượng (objects) và mơ tả của các đối tượng có chung các thuộc
tính và hành động. Nó chứa các đặc tính của đối tượng như các thuộc tính (attributes), các hành động
hoặc các hành vi (behaviors).
2. Đối tượng (Object):
Một đối tượng là một thực thể trong thế giới thực có các thuộc tính trạng thái và các hành vi.
Trong thuật ngữ OOP, những tính chất này được gọi là thuộc tính của Class (Class Properties) hoặc
Attributes của đối tượng Bike.
3. Phương thức (Method):
Phương thức là một hành vi của đối tượng. Ví dụ, nếu bạn coi “Bike” là một class và hành vi của
nó là lấy ra thơng tin màu sắc, động cơ, vận tốc…
4. Tính đóng gói (Encapsulation):
Tính đóng gói là quy trình giữ và che giấu một hoặc nhiều thành phần với một gói vật lý hoặc
logic. Trong phương pháp lập trình hướng đối tượng, nó ngăn truy cập vào chi tiết triển khai bên trong
của đối tượng hay một thư viện.
Tính đóng gói được triển khai bằng cách sử dụng các từ khóa chỉ định truy cập (access
specifiers). Một chỉ định truy cập định nghĩa phạm vi và sự ẩn hiện của các thành phần trong class. Các
từ khóa bao gồm public, private, protected, internal…
5. Tính trừu tượng (Abstraction):
Tính trừu tượng là xử lý đưa ra chỉ những thông tin cơ bản của đối tượng trong thế giới thực và
ẩn đi toàn bộ chi tiết của một đối tượng. Nó được dựa trên sự chia tách của interface và các triển khai của
interface.
Ví dụ chúng ta tiếp tục với “Bike” như một ví dụ, chúng ta khơng truy cập trực tiếp vào pit-tơng,
chúng ta có thể sử dụng một nút START để khởi động pit-tông. Hãy tưởng tượng nếu có một nhà máy

sản xuất xe máy cho phép truy xuất trực tiếp vào pit-tơng, nó sẽ rất khó để điều khiển các hành động trên
pit-tơng đó. Đó là lý do tại sao một nhà sản xuất xe máy chia tách những chi tiết máy nội bộ ra khỏi giao
diện đối với người dùng.
6. Che giấu thông tin (Information Hiding):
Che giấu thông tin là khái niệm giới hạn trực tiếp phơi bày dữ liệu. Dữ liệu được truy cập gián
tiếp sử dụng các cơ chế an toàn, các phương thức trong lập trình hướng đối tượng. Hãy xem lại các ví dụ
của phần trừu tượng.
7. Tính kế thừa (Inheritance):
Tính kế thừa trong OOP cho phép chúng ta tạo mới các class sử dụng một class có sẵn và có thể
mở rộng chúng ra.
Khái niệm này cũng có thể liên quan đến ví dụ thực tế. Hãy tạo một ví dụ Bike. Một nhà sản xuất
xe máy sử dụng cùng một cơ chế của một phiên bản xe đã có sẵn trong lúc chuẩn bị ra mắt một phiên bản
xe mới. Ví dụ dùng máy 110 của Wave nhưng thêm một số các tính năng tiện ích đồng thời thay vỏ để
tạo ra một dòng xe mới WaveS. Điều này cho phép nhà sản xuất tiết kiệm thời gian và cơng sức.
Lợi ích chính của việc mở rộng các class là cung cấp một cách thức tiện lợi để sử dụng lập các
đoạn code đã được kiểm thử trong lần trước giúp tiết kiệm nhiều thời gian và công sức.
8. Tính đa hình (Polymorphism):
Từ đa hình(Polymorphism) nghĩa là có nhiều khn mẫu. Tổng quan, đa hình xuất hiện khi có
một danh sách class chúng có liên quan đến nhau thơng qua kế thừa.
Hãy lấy ví dụ Bike, một Bike có thể có 2 khn mẫu như xe đề và xe đạp nổi. Chúng ta có thể
quyết định phương thức vận hành nào muốn sử dụng để khởi động (nghĩa là lúc chạy).
Có 2 kiểu đa hình:

Đa hình ở thời điểm biên dịch (Compile time polymorphism): Đây là kiểu đa hình mà trình
biên dịch sẽ nhận dạng khn mẫu nào có thể thực hiện ở thời điểm biên dịch gọi là compile time
polymorphism hay cịn gọi là early binding. Ví dụ chúng ta gọi là Nạp chống phương thức (Method
Overloading) và Nạp chồng toán tử (Operator Overloading). Method Overloading nghĩa là có nhiều hơn
một phương thức có cùng tên nhưng khác số lượng về tham số trong cùng 1 class hoặc khác class.
– Lợi ích: Thực thi nhanh bởi vì tất cả các phương thức được nhận dạng ở thời điểm biên dịch.
– Điểu yếu: Không mềm dẻo.

Chú ý: Khi nạp chống phương thức, một quy tắc tuân theo là nạp chống phương thức phải so sánh số
lượng đối số hoặc kiểu dữ liệu của ít nhất một đối số. Chúng ta có thể xem Method Overriding như là một
ví dụ của việc đa hình ở thời điểm biên dịch được gọi trực tiếp bởi đối tượng được khởi tạo.

Đa hình ở thời điểm thực thi (Runtime polymorphism): Trong kiểu đa hình này, trình biên
dịch sẽ nhận dạng khn mẫu đa hình nào sẽ được thực thi ở thời điểm chạy nhưng không phải ở thời
diểm biên dịch được gọi là đa hình ở thời điểm thực thi hoặc late binding. Ví dụ early binding là Method
Overriding. Method Overriding nghĩa là có hai phương thức với cùng tên cùng signature, một phương
6


thức trong class Base, phương thức kia ở class Child. Nó được yêu cầu thay đổi hành vi của phương thức
trong class Base khi class con sử dụng.
– Lợi ích: Nó có thể mềm dẻo đề điều chỉnh các kiểu đối tượng ở thời điểm thực thi.
– Hạn chế: Thực thi sẽ chậm hơn vì phải mất thời gian lấy thông tin về phương thức ở thời điểm chạy.

1.1.4. Xu hướng phát triển của lập trình hướng đối tượng
1. Lập trình hướng thành phần (Component-oriented programming-COP)
Xuất phát từ lập trình hướng đối tượng, tư duy lập trình hướng thành phần theo ý tưởng:
Giải quyết bài toán bằng cách xây dựng một tập các thành phần (component) có tính độc lập
tương đối với nhau. Mỗi thành phần đảm nhiệm một phần cơng việc nhất định.
Sau đó, người ta ghép các thành phần với nhau để thu được một phần mềm thoả mãn một tập các
yêu cầu xác định.
Với lập trình hướng thành phần, người ta có thể tiến hành lập trình theo phương pháp sau:
Xây dựng một thư viện các thành phần, mỗi thành phần thực hiện một công việc xác định.
Khi cần phát triển một phần mềm cụ thể, người ta chỉ cần chọn những thành phần có sẵn trong
thư viện để ghép lại với nhau. Người lập trình chỉ phải phát triển thêm các thành phần mình cần mà chưa
có trong thư viện.
Phương pháp này có những ưu điểm rất lớn:
Lập trình viên có thể chia sẻ với nhau những thành phần mình đã xây dựng cho nhiều người khác

dùng chung.
Khi cần, lập trình viên có thể lắp ghép các thành phần có sẵn khác nhau để tạo thành các chương
trình có chức năng khác nhau. Tất cả chỉ cần dựa trên công nghệ lắp ghép thành phần, tiết kiệm được rất
nhiều cơng sức lập trình.
Trong xu hướng lập trình hướng thành phần, một số phương pháp lập trình khác đã nảy sinh và đang
phát triển mạnh mẽ:
Lập trình hướng tác nhân (Agent-Oriented Programming)
Lập trình hướng khía cạnh (Aspect-Oriented Programming-AOP)

2. Lập trình hướng tác nhân (Agent-Oriented Programming)
Lập trình hướng agent có thể xem là một mức trừu tượng cao hơn của lập trình hướng thành
phần.
Trong đó, các agent là các thành phần có khả năng họat động độc lập, tự chủ để hồn thành cơng
việc của mình. Hơn nữa, các agent có khả năng chủ động liên lạc với các agent khác để có thể phối hợp,
cộng tác hay cạnh tranh nhau để hồn thành nhiệm vụ.
Lập trình hướng agent có hai đặc trưng cơ bản:
Thứ nhất là khả năng tự chủ của mỗi agent để hoàn thành nhiệm vụ riêng của nó.
Thứ hai là tính tổ chức xã hội giữa các agent, cho phép các agent phối hợp, cộng tác, cạnh
tranh nhau để hoàn thành nhiệm vụ chung của tồn hệ thống.

3. Lập trình hướng khía cạnh (Aspect-Oriented Programming-AOP)
Phương pháp lập trình hướng khía cạnh là phương pháp lập trình phát triển tư duy tách biệt các
mối quan tâm khác nhau thành các mô đun khác nhau. Ở đây, một mối quan tâm thường không phải một
chức năng nghiệp vụ cụ thể và có thể đóng gói mà là một khía cạnh (thuộc tính) chung mà nhiều mơ đun
phần mềm trong cùng hệ thống nên có, ví dụ lưu vết thao tác và lỗi (error logging).
Với AOP, chúng ta có thể cài đặt các mối quan tâm chung cắt ngang hệ thống bằng các mô đun
đặc biệt gọi là aspect thay vì dàn trải chúng trên các mơ đun nghiệp vụ liên quan. Các aspect sau đó được
tự kết hợp với các mô đun nghiệp vụ khác bằng quá trình gọi là đan (weaving) bằng bộ biên dịch đặc biệt.
AspectJ là một công cụ AOP cho ngôn ngữ lập trình Java. Trình biên dịch AspectJ sẽ đan xen
chương trình Java chính với các aspect thành các tập tin bytecode chạy trên máy ảo Java.

1.2. Ngơn ngữ lập trình hướng đối tượng JAVA
1.2.1. Các ngơn ngữ lập trình hướng đối tượng
Nội dung phần này sẽ trình bày một số ngơn ngữ lập trình hướng đối tượng thơng dụng hiện nay:
• Ngơn ngữ lập trình C++
• Ngơn ngữ lập trình ASP.NET và C#.NET
• Ngơn ngữ lập trình Java
C++
C++, ra đời vào giữa những năm 1980, là một ngôn ngữ lập trình hướng đối tượng được mở rộng
từ ngơn ngữ lập trình cấu trúc C. Cho nên, C++ là ngơn ngữ lập trình nửa hướng đối tượng, nửa hướng
cấu trúc.
Những đặc trưng hướng đối tượng của C++
• Cho phép định nghĩa lớp đối tượng.
7


• Cho phép đóng gói dữ liệu vào các lớp đối tượng. Cho phép định nghĩa phạm vi truy nhập dữ
liệu của lớp bằng các từ khố phạm vi.
• Cho phép kế thừa lớp với các kiểu kế thừa khác nhau tuỳ vào từ khố dẫn xuất.
• Cho phép lớp kế thừa sử dụng các phương thức của lớp bị kế thừa (trong phạm vi quy định).
• Cho phép định nghĩa chồng phương thức trong lớp kế thừa.
Những vi phạm hướng đối tượng của C++
Những vi phạm này là do 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.
• Cho phép định nghĩa và sử dụng các biến dữ liệu tự do.
• Cho phép định nghĩa và sử dụng các hàm tự do.
• Ngay cả khi dữ liệu được đóng gói vào lớp, dữ liệu vẫn có thể truy nhập trực tiếp như dữ liệu tự
do bởi các hàm bạn, lớp bạn (friend) trong C++.
ASP.NET và C#.NET
Các ngơn ngữ lập trình .NET (cịn được gọi là .NET Frameworks) của MicroSoft ra đời vào cuối
những năm 1990 để cạnh tranh với ngôn ngữ lập trình Java. .NET là một ngơn ngữ hồn tồn hướng đối

tượng, hơn nữa, nó cịn cung cấp một giao diện lập trình đồ họa thân thiện và đẹp mắt với truyền thống
lập trình kéo thả của MicroSoft.
Một số đặc điểm của ngơn ngữ .NET:
• Là một ngơn ngữ hồn tồn hướng đối tượng: Tất cả các thành phần, các thực thể trong chương
trình đều được mơ hình dưới dạng một lớp nhất định. Khơng có dữ liệu tự do và hàm tự do trong chương
trình.
• Cung cấp giao diện lập trình đồ họa: lập trình viên chỉ cần kéo và thả các đối tượng đồ họa cho
ứng dụng của mình.
• Cho phép lập trình viên tự tạo ra các thư viện UserControl của mình. Đây là một thư viện bao
gồm các thành phần được người dùng tự thiết kế giao diện, viết mã nguồn, đóng gói và có thể sử dụng lại
trong nhiều ứng dụng khác nhau, tuỳ theo chức năng của các thành phần.
Java
Java là một ngôn ngữ lập trình được Sun Microsystems giới thiệu vào tháng 6 năm 1995. Java
được xây dựng trên nền tảng của C và C++: Java sử dụng cú pháp của C và đặc trưng hướng đối tượng
của C++.
Một số đặc điểm của Java:
• Java là một ngơn ngữ lập trình hồn tồn hướng đối tượng: Tất cả các thực thể đều được coi là
một đối tượng, là một thể hiện cụ thể của một lớp xác định. Khơng có dữ liệu tự do và hàm tự do trong
Java, tất cả đều được đóng gói vào các lớp xác định.
• Java là ngơn ngữ vừa biên dịch vừa thông dịch. Đầu tiên mã nguồn được biên dịch thành dạng
bytecode; sau đó được thực thi trên từng loại máy nhờ trình thơng dịch. Điều này tạo ra khả năng họat
động độc lập với nền tảng phần cứng của các ứng dụng Java.
• Java cho phép người dùng tự tạo các đối tượng thư viện JavaBeans của mình (tương tự như các
thành phần UserControl của .NET). Các đối tượng Bean sẽ được sử dụng lại như các thành phần có sẵn
trong các ứng dụng khác. Điều này mở ra khả năng to lớn để tiết kiệm công sức viết mã nguồn và khả
năng xây dựng các kỹ thuật cho một nền công nghiệp lắp ráp phần mềm.

1.2.2. Giới thiệu về JAVA
Java là ngơn ngữ lập trình máy tính có tính chất hướng đối tượng, dựa trên các lớp, thường được
sử dụng cho các hệ thống có tính độc lập cao. Nó được sử dụng để hướng tới các lập trình viên viết ứng

dụng "write one, run everywhere" (viết một lần, chạy mọi nơi, nghĩa là đoạn code Java sau khi được biên
dịch có thể chạy được trên tất cả các nền tảng hỗ trợ Java mà không cần phải được biên dịch lại. Các ứng
dụng Java sau khi đã được biên dịch thành bytecode có thể chạy trên bất kỳ máy ảo Java nào (Java virtual
machine)
Java được viết bởi James Gosling tại Sun MicroSystems và được phát hành năm 1995. Cú pháp
ban đầu của Java được dựa nhiều vào cú pháp của ngôn ngữ C và C++
Cho đến năm 2015, Java là một trong những ngôn ngữ được dùng phổ biến nhất trên thế giới, đặc
biệt cho các úng dựng web client- server. Theo thống kê trên thế giới có khoảng 9 triệu lập trình viên
Java
Các quy tắc chính khi viết Java:
1. Đơn giản, hướng đối tượng, thân thiện
2. Mạnh mẽ và có tính bảo mật
3. Có kiến trình hài hịa và có tính chất di động
4. Là ngơn ngữ có hiệu năng cao
5. Thơng dịch, đa tiến trình, linh động
Java là gì?
Java là một Ngơn ngữ lập trình và là một Platform.
8


Ngơn ngữ lập trình: Java là một ngơn ngữ lập trình có tính bảo mật cao, hướng đối tượng, bậc
cao và mạnh mẽ.
Platform: Bất cứ môi trường phần cứng hoặc phần mền nào mà trong đó một chương trình chạy,
thì được biết đến như là một Platform. Với môi trường runtime riêng cho mình là JRE và API, Java được
gọi là Platform.
Ví dụ về Java
Bạn theo dõi ví dụ đơn giản sau để in Hello World, phần giải thích chi tiết sẽ được trình bày trong
chương tiếp theo.
class Simple{
public static void main(String args[]){

System.out.println("Hello World");
}
}

Nơi Java được sử dụng?
Có rất nhiều thiết bị hiện tại đang sử dụng Java. Bao gồm:

Desktop App như media player, antivirus, reader, …

Web App như irctc.co.in, javatpoint.com, …

Enterprise App như các ứng dụng về xử lý nghiệp vụ ngân hàng, …

Trên các thiết bị Mobile.
Các loại Java App
Có 4 loại ứng dụng chính mà có thể được tạo bởi sử dụng ngơn ngữ lập trình Java:
Standalone App
Nó cịn được biết đến với tên gọi khác là Destop App hoặc Windows-based App. Một ứng dụng
mà chúng ta cần cài đặt trên mỗi thiết bị như media player, antivirus, … AWT và Swing được sử dụng
trong Java để tạo các Standalone App.
Web App
Một ứng dụng mà chạy trên Server Side và tạo Dynamic Page, được gọi là Web App. Hiện tại,
các công nghệ Servlet, JSP, Struts, JSF, … được sử dụng để tạo Web App trong Java.
Enterprise App
Một ứng dụng dạng như Banking App, có lợi thế là tính bảo mật cao, cân bằng tải (load
balancing) và clustering. Trong java, EJB được sử dụng để tạo các Enterprise App.
Mobile App
Đây là loại ứng dụng được tạo cho thiết bị mobile. Hiện tại thì Android và Java ME được sử
dụng để tạo loại ứng dụng này.

1.2.3. Các thành phần cơ bản của ngơn ngữ lập trình Java
a) Bảng chữ:
JAVA phân biệt chữ hoa, chữ thường.
b) Định danh (Identifier) trong Java:
Tất cả các thành phần của Java đều yêu cầu tên. Tên được sử với các class, biến cũng như phương thức
được gọi là Định danh (Identifier).
Trong Java, có vài điểm quan trọng dưới đây bạn phải ghi nhớ với Định danh (Identifier):
 Tất cả các idenfier nên bắt đầu với một chữ cái (A tới Z hoặc a tới z), ký tự ($) hoặc ký tự gạch
dưới (_).
 Sau kí tự đầu tiên có thể là bất kỳ ký tự nào.
 Những key word trong Java không thể được sử dụng như một identifier.
 Các identifier phân biệt chữ hoa thường.
 Các trường hợp hợp lệ: tuoi, $ten, giatri, __1_giatri
 Các trường hợp không hợp lệ: 123abc, -hocphi
c) Biến trong Java
- Biến là vùng nhớ dùng để lưu trữ các giá trị của chương trình.
- Mỗi biến gắn liền với một kiểu dữ liệu và một định danh duy nhất gọi là tên biến.
- Tên biến thông thường là một chuỗi các ký tự (Unicode), ký số.
- Tên biến phải bắt đầu bằng một chữ cái hoặc một dấu gạch dưới hay dấu dollar.
- Tên biến khơng có khoảng trắng ở giữa tên.
- Trong java, biến có thể được khai báo ở bất kỳ nơi đâu trong chương trình.
- Tên biến khơng được trùng với các từ khóa trong Java. (Ví dụ từ khóa : abstract, assert,
boolean, break, byte, case, catch, char, class, const, continue, default, do, double, else, enum, extends
final, finally, float, for,goto, if , implements , import, instanceof, int, interface, long, native, new,
package, private, protected, public, return, short , static, strictfp, super, switch, synchronized, this throw,
throws, transient, try, void, volatile, while.)
- Ví dụ:
9



Tên biến đúng: a , _a, A, _b, _B, $d, hoTen, _giaTri, sinhVien1, sinhVien2
Tên biến sai: 5a , hoc sinh, 1gia tri, if, try
- Lưu ý: Trong Java phân biệt chữ hoa chữ thường, vì vậy chúng ta cần lưu ý khi đặt tên cho các biễn, các
đối tương dữ liệu cũng như các xử lý trong chương trình.
Khai báo biến trong Java
Cấu trúc câu lệnh khai báo biến trong java như sau: [Kiểu dữ liệu] [tên biến];
Ví dụ:
int giaTri; // Khái báo biến có tên là “giaTri”, kiểu dữ liệu là int – kiểu số nguyên.
String hoTen; //Khai báo biến có tên là “hoTen”, kiểu dữ liệu là String – Là một chuỗi ký tự.
- Ngồi ra cịn có thêm từ khóa (public, private, ….) trước dịng khai báo biến (vd: private String
hoTen), phần này chúng ta sẽ nói khi chúng ta sang phần hướng đối tượng trong Java.
- Để gán giá trị cho biến ta chỉ việc dùng cú pháp Tên biến = giá trị, hoặc gán ngay trong q
trình khai báo. Ví dụ:
int giaTri;
giaTri = 5;
Hoặc
int giaTri = 5;
Để in một chuỗi văn bản hoặc giá trị ra màn hình Console ta dùng lệnh dạng như sau:
System.out.print(“Giá trị của biến là: ”+ giaTri1 + giaTri2);
// giaTri1 và giaTri2 là 2 biến đã khai báo và gán giá trị.
d) Kiểu dữ liệu trong Java
Trong Java có 2 nhóm kiểu dữ liệu, thứ nhất là kiểu dữ liệu nguyên thủy (dữ liệu cơ sở) và thứ 2 là nhóm
kiểu dữ liệu mở rộng:

Trước khi đi vào giới thiệu chi tiết về từng kiểu dữ liệu, bạn có thể theo dõi bảng tóm tắt sau:
Kiểu dữ liệu

Giá trị mặc định

Kích cỡ mặc định

boolean

false

1 bit

char

'\u0000'

2 byte

byte

0

1 byte

short

0

2 byte

int

0

4 byte

long

0L

8 byte

float

0.0f

4 byte

10


double

0.0d

8 byte

Câu hỏi: Tại sao char sử dụng 2 byte trong Java và \u0000 là gì?
Bởi vì Java sử dụng Unicode chứ không phải ASCII. \u0000 là dãy thấp nhất trong Unicode.
Các kiểu dữ liệu gốc trong Java
Có 8 kiểu dữ liệu gốc được hỗ trợ bởi Java. Các kiểu dữ liệu gốc này được tiền định nghĩa bởi
ngôn ngữ và được định danh bởi một từ khóa. Dưới đây là chi tiết về 8 kiểu dữ liệu gốc này:
char:


Dùng để lưu dữ liệu kiểu kí tự hoặc số nguyên khơng âm có kích thước 2 byte (16 bit)

Giá trị nhỏ nhất là '\u0000' (hoặc 0) và giá trị lớn nhất là '\uffff' (hoặc 65,535)..

Ví dụ: char nam ='IT'
Tại sao Java sử dụng Unicode?
Trước Unicode, có nhiều chuẩn ngơn ngữ như ASCII, ISO 8859-1, KOI-8, GB18030, … Điều
này gây là hai vấn đề sau:

Một giá trị code cụ thể tương ứng với các chữ cái khác nhau trong các chuẩn ngơn ngữ đa dạng.

Mã hóa cho các ngơn ngữ với các tập ký tự lớn có độ dài biến đổi. Một số ký tự chung được mã
hóa thành các byte đơn, một số khác cần hai hoặc nhiều byte.
Để xử lý các vấn đề này, một chuẩn ngôn ngữ mới được phát triển, đó là Unicode. Trong
Unicode, ký tự giữ 2 byte, vì thế Java cũng sử dụng 2 byte cho các ký tự.
Kiểu dữ liệu byte:
 Dùng để lưu dữ liệu kiểu số ngun có kích thước một byte (8 bit)
 Giá trị nhỏ nhất là -128 (-2^7) và giá trị lớn nhất là 127. (2^7 -1)
 Giá trị mặc định là 0
 Kiểu dữ liệu byte được sử dụng để lưu giữ khoảng trống trong các mảng lớn, chủ yếu là các số
nguyên.
 Ví dụ: byte x = 20 , byte y = -10
Kiểu dữ liệu short:
 Dùng để lưu dữ liệu có kiểu số ngun, kích cỡ 2 byte (16 bit).
 Giá trị nhỏ nhất là -32,768 (-2^15) và giá trị lớn nhất là 32,767 (2^15 -1).
 Kiểu dữ liệu short cũng có thể được sử dụng để lưu bộ nhớ như kiểu dữ liệu byte.
 Giá trị mặc định là 0.
 Ví dụ: short t = 50, short z = -10
int:

 Dùng để lưu dữ liệu có kiểu số ngun, kích cỡ 4 byte (32 bit).
 Giá trị nhỏ nhất là - 2,147,483,648.(-2^31) và giá trị lớn nhất là 2,147,483,647 (2^31 -1)
 Nói chung, int được sử dụng như là kiểu dữ liệu mặc định cho các giá trị nguyên.
 Giá trị mặc định là 0.
 Ví dụ: int a = 5, int b = -50
long:
 Dùng để lưu dữ liệu có kiểu số nguyên có kích thước lên đến 8 byte.
 Giá trị nhỏ nhất là -9,223,372,036,854,775,808.(-2^63) và lớn nhất là:
9,223,372,036,854,775,807. (2^63 -1)
 Kiểu này được sử dụng khi cần một dải giá trị rộng hơn int.
 Giá trị mặc định là 0L.
 Ví dụ: long a = 100000L, int b = -200000L
float:
 Dùng để lưu dữ liệu có kiểu số thực, kích cỡ 4 byte (32 bit)
 Kiểu Float được sử dụng chủ yếu để lưu bộ nhớ trong các mảng rộng hơn các số thực dấu chấm
động.
 Giá trị mặc định là 0.0f.
 Kiểu Float không bao giờ được sử dụng cho các giá trị chính xác như currency.
 Ví dụ: float usd = 22.5f
double:
 Kiểu dữ liệu double được sử dụng để lưu dữ liệu có kiểu số thực có kích thước lên đến 8 byte
 Nói chung, kiểu dữ liệu này được sử dụng như là kiểu mặc định cho các giá trị decimal.
 Kiểu double không bao giờ được sử dụng cho các giá trị chính xác như currency.
 Giá trị mặc định là 0.0d.
 Ví dụ: double ct = 676.7
boolean:
 Độ lớn chỉ có 1 bit
 Dùng để lưu dữ liệu chỉ có hai trạng thái true hoặc false
 Giá trị mặc định là false.
11

 Ví dụ: boolean switch1 = true
e) Hằng
- Hằng là một giá trị bất biến trong chương trình
- Tên hằng được đặt theo qui ước giống như tên biến.
- Hằng số nguyên: trường hợp giá trị hằng ở dạng long ta thêm vào cuối chuỗi số chữ “l” hay
“L”. (ví dụ: 1L, 5L, 3L)
- Hằng số thực: truờng hợp giá trị hằng có kiểu float ta thêm tiếp vĩ ngữ “f” hay “F”, cịn kiểu số
double thì ta thêm tiếp vĩ ngữ “d” hay “D”.
- Hằng Boolean: java có 2 hằng boolean là true, false.
- Hằng ký tự: là một ký tự đơn nằm giữa nằm giữa 2 dấu ngoặc đơn.
Ví dụ: ‘a’: hằng ký tự a
Ngơn ngữ Java hỗ trợ một số dãy ký tự đặc biệt cho hằng chuỗi và hằng ký tự như sau:

Ký hiệu

Biểu diễn ký tự

\n

Newline (0x0a)

\r

Carriage return (0x0d)

\f

Formfeed (0x0c)

\b

Backspace (0x08)

\s

Space (0x20)

\t

tab

\"

Trích dẫn kép

\'

Trích dẫn đơn

\\

backslash

\ddd
\uxxxx

Octal character (ddd)
Hexadecimal UNICODE character (xxxx)

- Hằng chuỗi: là tập hợp các ký tự được đặt giữa hai dấu nháy kép “ ”. Một hằng chuỗi khơng có
ký tự nào là một hằng chuỗi rỗng.
Ví dụ: “Ban dang tham gia hoc Java tai ĐHHĐ”
Lưu ý: Hằng chuỗi không phải là một kiểu dữ liệu cơ sở nhưng vẫn được khai báo và sử dụng trong các
chương trình.
Cú pháp khai báo hằng: final + kiểu dữ liệu + tên hằng = giá trị cần gán,
ví dụ: final int NAM_SINH = 1992;
Bài 1: Trong những tên biến sau, tên biến nào khai báo sai: a , c, _a, 3a, %s, *d, _e, class, _else, super,
$super, ^void, $goTo, Public, Return, If, _case, New, $new;
Bài 2: Khai báo 2 biến nguyên (int), gán giá trị bất kỳ cho 2 biến, tính tổng 2 số, gán tổng vào biến t, in
giá trị biến t ra ngồi màn hình.
Bài 3: Khai báo hằng PI = 3.14 kiểu số thực, với biến r là bán kính đường tròn – kiểu số thực, được gán
vào trong thân chương trình, hãy viết chương trình tính diện tích và chu vi hình trịn, in kết quả ra màn
hình.
f) Tốn tử trong Java
Java cung cấp rất nhiều toán tử đa dạng để thao tác với các biến. Chúng ta có thể chia tất cả các tốn
tử trong Java thành các nhóm sau:
 Toán tử số học
 Toán tử quan hệ
 Toán tử thao tác bit
 Toán tử logic
 Toán tử gán
 Và các toán tử hỗn hợp
Toán tử số học trong Java
Các toán tử số học được sử dụng trong các biểu thức toán học theo cách tương tự như chúng
được sử dụng trong đại số học. Bảng sau liệt kê các toán tử số học trong Java.
Giả sử biến A giữ giá trị 10, biến B giữ giá trị 20, thì:
Ví dụ
12

Tốn tử

Miêu tả

Ví dụ

+

Phép cộng

A + B sẽ cho kết quả 30

-

Phép trừ: trừ toán hạng trái cho toán hạng phải

A - B sẽ cho kết quả -10

*

Phép nhân

A * B sẽ cho kết quả 200

/

Phép chia: chia toán hạng trái cho toán hạng phải

B / A sẽ cho kết quả 2

%

Phép chia lấy phần dư: Lấy phần dư của phép chia toán hạng
trái cho toán hạng phải

B % A sẽ cho kết quả 0

++

Phép lượng gia: lượng gia giá trị toán hạng thêm 1

B++ sẽ cho kết quả 21

--

Phép lượng giảm: lượng giảm giá trị toán hạng đi 1

B-- sẽ cho kết quả 19

Toán tử quan hệ trong Java
Bảng dưới liệt kê các toán tử quan hệ được hỗ trợ bởi Java.
Giả sử biến A giữ giá trị 10, biến B giữ giá trị 20, thì:
Ví dụ
Tốn tử

Miêu tả

Ví dụ

==

Kiểm tra nếu giá trị của hai tốn hạng có cân bằng hay khơng, nếu
có thì điều kiện là true.

(A == B) là khơng
true.

!=

Kiểm tra nếu giá trị hai tốn hạng là cân bằng hay không, nếu không (A != B) là true.
cân bằng, thì điều kiện là true

>

Kiểm tra nếu tốn hạng trái có lớn hơn tốn hạng phải hay khơng,
nếu có thì điều kiện là true

(A > B) là khơng true.

<

Kiểm tra nếu tốn hạng phải có lớn hơn tốn hạng trái hay khơng,
nếu có thì điều kiện là true

(A < B) là true.

>=

Kiểm tra nếu toán hạng trái có lớn hơn hoặc bằng tốn hạng phải
hay khơng, nếu có thì điều kiện là true

(A >= B) là khơng
true.

<=

Kiểm tra nếu tốn hạng phải có lớn hơn hoặc bằng tốn hạng trái
hay khơng, nếu có thì điều kiện là true

(A <= B) là true.

Toán tử thao tác bit trong Java
Java định nghĩa một số toán tử thao tác bit có thể được áp dụng cho các kiểu giá trị integer, long,
int, short, char, và byte.
Toán tử thao tác bit làm việc trên các bit. Giả sử nếu a = 60 và b = 13, thì trong định dạng nhị
phân chúng sẽ như sau:
a = 0011 1100
b = 0000 1101
----------------a&b = 0000 1100
a|b = 0011 1101
a^b = 0011 0001
~a = 1100 0011
Bảng dưới đây liệt kê các toán tử bit được hỗ trợ trong Java:
Giả sử biến A giữ giá trị 60 và biến B giữ 13 thì khi đó:
Ví dụ
Tốn tử Miêu tả

Ví dụ

&

Tốn tử Và nhị phân sao chép một bit tới kết
quả nếu nó tồn tại trong cả hai toán hạng

|

Toán tử Hoặc nhị phân sao chép một bit tới kết (A | B) sẽ cho kết quả 61, hay là 0011 1101
quả nếu nó tồn tại trong một hoặc hai toán hạng

^

Toán tử Hoặc loại trừ nhị phân sao chép bit nếu (A ^ B) sẽ cho kết quả 49, hay là 0011 0001
nó được thiết lập trong một toán hạng nhưng
13

(A & B) sẽ cho kết quả 12, hay là 0000 1100


khơng phải trong cả hai
~

Tốn tử đảo bit là tốn tử một ngơi. Đảo bít 1
thành 0 và ngược lại

(~A ) sẽ cho kết quả -61, hay là 1100 0011

<<

Toán tử dịch trái. Giá trị toán hạng trái được
dịch chuyển sang trái bởi số các bit được xác
định bởi toán hạng bên phải.

A << 2 sẽ cho kết quả 240, hay là 1111 0000

>>

Toán tử dịch phải. Giá trị toán hạng trái được
dịch chuyển sang phải bởi số các bit được xác
định bởi toán hạng bên phải

A >> 2 sẽ cho kết quả 15, hay là 1111

>>>

Toán tử dịch phải và điền 0 vào chỗ trống

A >>>2 sẽ cho kết quả 15, hay là 0000 1111

Toán tử logic trong Java
Bảng dưới liệt kê đầy đủ các toán tử logic trong Java:
Giả sử biến A giữ true và biến B giữ false thì khi đó:
Ví dụ
Tốn
tử
&&

Miêu tả

Ví dụ

Tốn tử Và logic. Nếu cả hai tốn hạng là khác khơng, thì khi đó điều kiện là (A && B) là false.
true

||

Tốn tử Hoặc logic. Nếu một trong hai toán tử khác 0, thì điều kiện là true

(A || B) là true.

!

Tốn tử Phủ định logic. Sử dụng để đảo ngược lại trạng thái logic của tốn
hạng đó. Nếu điều kiện tốn hạng là true thì phủ định nó sẽ là false

!(A && B) là true.

Các toán tử gán trong Java
Dưới đây liệt kê các tốn tử gán được hỗ trợ bởi Java:
Ví dụ
Tốn tử

Miêu tả

Ví dụ

=

Tốn tử gán đơn giản. Gán giá trị toán hạng bên C = A + B sẽ gán giá trị của A + B vào cho C

phải cho toán hạng trái.

+=

Thêm giá trị toán hạng phải tới tốn hạng trái
và gán giá trị đó cho tốn hạng trái.

C += A là tương đương với C = C + A

-=

Trừ đi giá trị toán hạng phải từ toán hạng trái
và gán giá trị này cho toán hạng trái.

C -= A là tương đương với C = C - A

*=

Nhân giá trị toán hạng phải với toán hạng trái
và gán giá trị này cho toán hạng trái.

C *= A là tương đương với C = C * A

/=

Chia toán hạng trái cho toán hạng phải và gán
giá trị này cho toán hạng trái.

C /= A là tương đương với C = C / A

%=

Lấy phần dư của phép chia toán hạng trái cho
toán hạng phải và gán cho toán hạng trái.

C %= A là tương đương với C = C % A

<<=

Dịch trái toán hạng trái sang số vị trí là giá trị
tốn hạng phải.

C <<= 2 là giống như C = C << 2

>>=

Dịch phải toán hạng trái sang số vị trí là giá trị
tốn hạng phải.

C >>= 2 là giống như C = C >> 2

&=

Phép AND bit

C &= 2 là giống như C = C & 2

^=

Phép OR loại trừ bit

C ^= 2 là giống như C = C ^ 2

|=

Phép OR bit.

C |= 2 là giống như C = C | 2

Toán tử hỗn hợp trong Java
Ngơn ngữ Java cũng hỗ trợ một số tốn tử hỗn hợp khác.
14


Toán tử điều kiện (? :)
Toán tử này gồm ba toán hạng và được sử dụng để ước lượng các biểu thức quan hệ. Mục tiêu của toán tử
là quyết định giá trị nào sẽ được gán cho biến. Toán tử này được viết như sau:
bien x = (bieu_thuc) ? (giatri1 neu true) : (giatri2 neu false);
//hoac ban cung co the su dung trong cac lenh RETURN
return (bieu_thuc) ? (giatri1 neu true) : (giatri2 neu false);
Tất nhiên, không cần thiết phải sử dụng các dấu ngoặc đơn như trên. Viết như vậy để giúp dễ
nhìn hơn.
Sau đây là ví dụ minh họa toán tử điều kiện (? :) trong Java:
public class Test {
public static void main(String args[]){
int a , b;
a = 10;
b = (a == 1) ? 20: 30; //Day la vi du ve toan tu dieu kien.
System.out.println( "Gia tri cua b la : " + b );
b = (a == 10) ? 20: 30; //Day la vi du ve toan tu dieu kien.

System.out.println( "Gia tri cua b la : " + b );
}
}

Nó sẽ cho kết quả sau:
Gia tri cua b la : 30
Gia tri cua b la : 20
Toán tử instanceof trong Java
Toán tử này chỉ được sử dụng cho các biến tham chiếu đối tượng. Toán tử kiểm tra có hay khơng đối
tượng là một kiểu cụ thể (kiểu class hoặc kiểu interface). Toán tử instanceof được viết như sau:
( Object reference variable ) instanceof (class/interface type)
Toán tử trả về true nếu toán hạng trái là biến thể hiện của tốn hạng phải. Ví dụ:
public class Test {
public static void main(String args[]){
String name = "Doan";
// Duoi day se tra ve true neu name la mot kieu String
boolean result = name instanceof String;
System.out.println( result );
}
}

Nó sẽ cho kết quả:
true
Toán tử này sẽ cũng trả về true nếu đối tượng đang được so sánh là tham số tương thích với kiểu tốn
hạng phải. Dưới đây là một ví dụ khác:
class Animal {}
public class Dog extends Animal {
public static void main(String args[]){
Animal a = new Dog();
boolean result = a instanceof Dog;

System.out.println( result );
}
}

Nó sẽ cho kết quả:
true
Thứ tự ưu tiên của các toán tử trong Java:
Thứ tự ưu tiên của các tốn tử xác định cách biểu thức được tính tốn. Ví dụ: tốn tử nhân có
quyền ưu tiên hơn tốn tử cộng.
Ví dụ, x = 7 + 3 * 2; ở đây, x được gán giá trị 13, chứ khơng phải 20 bởi vì tốn tử * có quyền ưu tiên cao
hơn tốn tử +, vì thế đầu tiên nó thực hiện phép nhân 3 * 2 và sau đó thêm với 7.
Bảng dưới đây liệt kê thứ tự ưu tiên của các toán tử. Các toán tử với quyền ưu tiên cao nhất xuất
hiện trên cùng của bảng, và các tốn tử có quyền ưu tiên thấp nhất thì ở bên dưới cùng của bảng. Trong
một biểu thức, các tốn tử có quyền ưu tiên cao nhất được tính tốn đầu tiên.

15


Loại

Toán tử

Thứ tự ưu
tiên

Postfix

() [] . (toán tử dot)

Trái sang phải

Unary

++ - - ! ~

Phải sang trái

Tính nhân

*/%

Trái sang phải

Tính cộng

+-

Trái sang phải

Dịch chuyển

>> >>> <<

Trái sang phải

Quan hệ

> >= < <=

Trái sang phải

Cân bằng

== !=

Trái sang phải

Phép AND bit

&

Trái sang phải

Phép XOR bit

^

Trái sang phải

sPhép OR bit

|

Trái sang phải

Phép AND logic

&&

Trái sang phải

Phép OR logic

||

Trái sang phải

Điều kiện

?:

Phải sang trái

Gán

= += -= *= /= %= >>= <<= &= ^= |=

Phải sang trái

Dấu phảy

,

Trái sang phải

1.2.4. Các cấu trúc điều khiển
a) Cấu trúc tuần tự
b) Cấu trúc rẽ nhánh
Như các ngơn ngữ lập trình khác, ngơn ngữ Java cũng hỗ trợ cấu trúc điều khiển luồng. Với cấu
trúc này, chương trình sẽ kiểm tra một hoặc nhiều điều kiện và nếu các điều kiện này làtrue, thì lệnh hoặc

các lệnh tương ứng với điều kiện true này sẽ được thực hiện, nếu khơng thì các lệnh tương ứng với điều
kiện false sẽ được thực thi.
Bảng dưới đây liệt kê các lệnh giúp bạn điều khiển luồng trong Java. Các lệnh đó là:
Lệnh

Miêu tả

Lệnh if

Một lệnh if trong Java bao gồm một Bieu_thuc_Boolean được theo sau bởi một hoặc
nhiều lệnh. Nếu Bieu_thuc_Boolean được ước lượng là true thì các lệnh trong phần
thân lệnh if sẽ được thực thi.

Lệnh if...else

Một lệnh if có thể được theo sau bởi một lệnh else tùy ý, mà thực thi khi
Bieu_thuc_Boolean là false.

Lồng lệnh if

Nó là hợp lệ để lồng các lệnh if-else, nghĩa là bạn có thể sử dụng một lệnh if hoặc
else if bên trong lệnh if hoặc else if khác.

Lệnh switch

Lệnh switch cho phép bạn kiểm tra một biến bình đẳng với một danh sách các giá
trị. Mỗi giá trị được gọi là một case – trường hợp. Nếu giá trị này trùng với case nào
thì các lệnh tương ứng với case đó sẽ được thực thi.

Lệnh if trong Java

Một lệnh if trong Java bao gồm một Bieu_thuc_Boolean được theo sau bởi một hoặc nhiều lệnh.
Nếu Bieu_thuc_Boolean được ước lượng là true thì các lệnh trong phần thân lệnh if sẽ được thực thi.
Cú pháp:
Cú pháp của lệnh if như sau:
if(Bieu_thuc_Boolean)
{
16


//Cac lenh se thuc thi neu Bieu_thuc_Boolean la true
}
Nếu Bieu_thuc_Boolean ước lượng là true thì khi đó khối code bên trong lệnh if sẽ được thực thi. Nếu
không, code ở sau phần cuối của lệnh if (sau dấu ngoặc móc đóng) sẽ được thực thi.
Ví dụ minh họa lệnh if trong Java
public class Test {
public static void main(String args[]){
int x = 10;
if( x < 20 ){
System.out.print("Day la lenh if");
}

}
}

Chương trình Java trên sẽ cho kết quả:
Day la lenh if
Lệnh if…else trong Java
Một lệnh if có thể được theo sau bởi một lệnh else tùy ý, mà thực thi khi Bieu_thuc_Boolean là false.
Cú pháp:
Cú pháp của một lệnh if…else trong Java là:

if(Bieu_thuc_Boolean){
//Thuc thi khi bieu thuc Boolean la true
}else{
//Thuc thi khi bieu thuc Boolean la false
}

Ví dụ minh họa lệnh if...else trong Java
public class Test {
public static void main(String args[]){
int x = 30;
if( x < 20 ){
System.out.print("Day la lenh if");
}else{
System.out.print("Day la lenh else");
}
}
}

Chương trình Java trên sẽ cho kết quả:
Day la lenh else

Lồng các lệnh if…else trong Java
Nó là hợp lệ để lồng các lệnh if-else, nghĩa là bạn có thể sử dụng một lệnh if hoặc else if bên trong lệnh if
hoặc else if khác.
Cú pháp:
Cú pháp cho một lệnh if…else được lồng vào nhau như sau:
if(Bieu_thuc_Boolean 1){
//Thuc thi khi bieu thuc Boolean 1 la true
if(Bieu_thuc_Boolean 2){
//Thuc thi khi bieu thuc Boolean 2 la true

}
}

Bạn có thể lồng else if…else theo cách tương tự như chúng ta đã lồng lệnh if.
Ví dụ minh họa lồng lệnh if trong Java
public class Test {
public static void main(String args[]){
int x = 30;
int y = 10;
if( x == 30 ){
if( y == 10 ){
System.out.print("X = 30 va Y = 10");
}
}
}
}

17


Chương trình Java trên sẽ cho kết quả sau:
X = 30 va Y = 10
Lệnh if…else if…else trong Java
Một lệnh if có thể được theo sau bởi một lệnh else if...else tùy ý, mà rất hữu ích để kiểm tra các điều kiện
đa dạng bởi sử dụng lệnh if…else if đơn.
Khi sử dụng các lệnh if, else if, else, có một số điểm chính cần ghi nhớ:
 Một lệnh if có 0 hoặc một lệnh else và nó phải theo sau bởi bất kỳ lệnh else if nào.
 Một lệnh if có từ 0 tới nhiều lệnh else if và chúng phải ở trước lệnh else.
 Một khi lệnh else if thành cơng, các phần else if hoặc else cịn lại sẽ không được kiểm tra.
Cú pháp:

Cú pháp của một if…else là:
if(Bieu_thuc_Boolean 1){
//Thuc thi khi bieu thuc Boolean 1 la
}else if(Bieu_thuc_Boolean 2){
//Thuc thi khi bieu thuc Boolean 2 la
}else if(Bieu_thuc_Boolean 3){
//Thuc thi khi bieu thuc Boolean 3 la
}else {
//Thuc thi khi khong co dieu kien nao
}

true
true
true
la true.

Ví dụ:
public class Test {
public static void main(String args[]){
int x = 30;
if( x == 10 ){
System.out.print("Gia
}else if( x == 20 ){
System.out.print("Gia
}else if( x == 30 ){
System.out.print("Gia
}else{
System.out.print("Day
}

tri cua X la 10");
tri cua X la 20");
tri cua X la 30");
la lenh else");

}
}

Chương trình Java trên sẽ cho kết quả sau:
Gia tri cua X la 30
Lệnh switch trong Java
Lệnh switch cho phép bạn kiểm tra một biến bình đẳng với một danh sách các giá trị. Mỗi giá trị được gọi
là một case – trường hợp. Nếu giá trị này trùng với case nào thì các lệnh tương ứng với case đó sẽ được
thực thi.
Cú pháp:
Cú pháp cho lệnh switch trong Java là:
switch(bieu_thuc){
gia_tri case :
//Cac lenh
break; //tuy y
case value :
//Cac lenh
break; //tuy y
//Ban co the co so luong lenh case bat ky nao.
default : //tuy y
//Cac lenh
}
Các qui tắc sau áp dụng cho một lệnh switch:
 Biến được sử dụng trong một lệnh switch chỉ có thể là byte, short, int hoặc char.
 Bạn có thể có nhiều lệnh case bên trong một lệnh switch. Mỗi case được theo sau bởi giá trị để

được so sánh và một dấu hai chấm.
 Giá trị cho một case phải giống kiểu dữ liệu của biến trong switch và nó phải là hằng số hoặc
literal.
18


 Khi biến đang được switch là tương đương với một case, các lệnh theo sau case đó sẽ thực thi tới
khi gặp lệnh break.
 Khi gặp một lệnh break thì switch kết thúc, và luồng điều khiển nhảy tới dịng tiếp theo lệnh
switch.
 Khơng phải mọi case đều cần một break. Nếu khơng có lệnh break xuất hiện, luồng điều khiển sẽ
đi qua các case sau đó tới khi gặp một lệnh break.
 Một lệnh switch có thể có một case mặc định, mà phải xuất hiện ở cuối lệnh switch. Case mặc
định này có thể được sử dụng để thực thi một tác vụ trong trường hợp không có case nào là true. Trong
trường hợp này, chúng ta khơng cần lệnh break.
Ví dụ:
public class Test {
public static void main(String args[]){
//char grade = args[0].charAt(0);
char grade = 'C';
switch(grade)
{
case 'A' :
System.out.println("Xuat sac!");
break;
case 'B' :
case 'C' :
System.out.println("Tot");
break;
case 'D' :

System.out.println("Thong qua");
case 'F' :
System.out.println("Hay thu lai");
break;
default :
System.out.println("Kem");
}
System.out.println("Cap do cua ban la " + grade);
}
}

Biên dịch và chạy chương trình Java trên sẽ cho kết quả sau:
$ java Test
Tot
Cap do cua ban la C

$

c) Cấu trúc lặp
Có thể có một tình huống khi chúng ta cần thực hiện một khối code một vài lần, điều này có thể
được xem như một vịng lặp.
Java có 3 kỹ thuật lặp linh động. Bạn có thể sử dụng một trong ba vòng lặp sau:
 Vòng lặp while
 Vòng lặp do…while
 Vòng lặp for
Trong Java 5, vòng lặp foreach (hay enhanced for) đã được giới thiệu. Vòng lặp này được sử dụng
chủ yếu cho các mảng.
Loại vòng lặp

Miêu tả

Vòng lặp while

Một vòng lặp while là một cấu trúc điều khiển cho phép bạn lặp đi lặp lại một tác
vụ một số lần nào đó. Với kiểu vịng lặp này, chương trình sẽ kiểm tra điều kiện
trước khi thực thi phần thân vòng lặp.

Vòng lặp for

Một vòng lặp for cho phép bạn viết một vòng lặp một cách hiệu quả để cần thực thi
một số lần lặp cụ thể nào đó.

Vịng lặp do...while

Một vịng lặp do … while là tương tự như vòng lặp while, ngoại trừ rằng phần thân
của vịng lặp do…while được bảo đảm thực thi ít nhất một lần. Nói cách khác,
vịng lặp do ... while thực hiện phần thân vòng lặp trước khi kiểm tra điều kiện.

Vòng lặp foreach

Trong Java 5, vòng lặp foreach (một tên gọi khác là enhanced for) đã được giới
thiệu. Nó được sử dụng chủ yếu với các mảng, các ArrayList, ...
19


Vòng lặp while trong JAVA
Một vòng lặp while là một cấu trúc điều khiển cho phép bạn lặp đi lặp lại một tác vụ một số lần
nào đó.
Cú pháp vịng lặp while trong Java
Cú pháp của một vòng lặp while trong Java như sau:

while(Bieu_thuc_boolean)
{
//phan than vong lap
}
Khi thực thi, nếu kết quả của boolean_expression là true, thì các họat động bên trong vịng lặp
được thực thi. Nó sẽ tiếp tục khi nào mà kết quả expression này vẫn là true.
Ở đây, điểm chính của vịng lặp while là vịng lặp có thể chưa từng chạy lần nào. Đó là khi
expression được kiểm tra và kết quả là false, thân vòng lặp sẽ bị bỏ qua và lệnh đầu tiên sau vịng lặp
while sẽ được thực thi.
Ví dụ minh họa vịng lặp while trong Java
public class Test {
public static void main(String args[]) {
int x = 10;

}

while( x < 20 ) {
System.out.print("Gia tri cua x : " + x );
x++;
System.out.print("\n");
}

}

Chương trình Java trên sẽ cho kết quả:
Gia
Gia
Gia
Gia
Gia

Gia
Gia
Gia
Gia
Gia

tri
tri
tri
tri
tri
tri
tri
tri
tri
tri

cua
cua
cua
cua
cua
cua
cua
cua
cua
cua

x
x

x
x
x
x
x
x
x
x

:
:
:
:
:
:
:
:
:
:

10
11
12
13
14
15
16
17
18
19

Vòng lặp for
Một vòng lặp for cho phép bạn viết một vòng lặp một cách hiệu quả để cần thực thi một số lần lặp
cụ thể nào đó.
Một vịng lặp for là hữu ích khi bạn biết số lần một tác vụ được lặp lại.
Cú pháp:
Cú pháp của vòng lặp for trong Java như sau:
for(khoi_tao_bien; bieu_thuc_boolean; update)
{
//phan than vong lap
}

Dưới đây là luồng điều khiển trong một vòng lặp for:
 Bước khoi_tao_bien được thực thi đầu tiên, và chỉ một lần. Bước này cho phép bạn khai báo và
khởi tạo bất kỳ biến điều khiển vòng lặp. Bạn không được yêu cầu đặt một lệnh ở đây, miễn là một dấu
chấm phảy xuất hiện.
 Sau đó, bieu_thuc_boolean được ước lượng. Nếu nó là true, phần thân vịng lặp được thực thi.
Nếu nó là false, phần thân vịng lặp khơng thực thi và luồng điều khiển nhảy tới lệnh tiếp theo sau vòng
lặp for.
 Sau khi thân vòng lặp thực thi, luồng điều khiển nhảy trở lại lệnh update. Lệnh này cho phép bạn
cập nhật bất kỳ biến điều khiển vịng lặp nào. Lệnh này có thể để trống, miễn là một dấu chấm phảy xuất
hiện sau bieu_thuc_boolean.
 bieu_thuc_boolean bây giờ được ước lượng lần nữa. Nếu là true, vịng lặp thực thi và tiến trình
lặp lại như trên. Sau khi bieu_thuc_boolean là false, vòng lặp kết thúc.
Ví dụ minh họa vịng lặp for trong Java
public class Test {
public static void main(String args[]) {

20

for(int x = 10; x < 20; x = x+1) {
System.out.print("Gia tri cua x : " + x );
System.out.print("\n");
}
}
}

Chương trình Java trên sẽ cho kết quả sau:
Gia
Gia
Gia
Gia
Gia
Gia
Gia
Gia
Gia
Gia

tri
tri
tri
tri
tri
tri
tri
tri
tri
tri

cua
cua
cua
cua
cua
cua
cua
cua
cua
cua

x
x
x
x
x
x
x
x
x
x

:
:
:
:
:
:
:

:
:
:

10
11
12
13
14
15
16
17
18
19

Vòng lặp do … while
Một vòng lặp do … while là tương tự như Vòng lặp do...while, ngoại trừ rằng phần thân của vòng
lặp do…while được bảo đảm thực thi ít nhất một lần. Nói cách khác, vịng lặp do ... while thực hiện phần
thân vòng lặp trước khi kiểm tra điều kiện.
Cú pháp:
Cú pháp của vòng lặp do…while trong Java là:
do
{
// phan than vong lap
}while(Bieu_thuc_boolean);
Ghi chú rằng, Bieu_thuc_boolean xuất hiện tại phần cuối của vịng lặp, vì thế các lệnh trong vịng lặp
thực thi một lần trước khi expression được kiểm tra.
Nếu bieu_thuc_boolean là true, nó quay trở lại và các lệnh được thực thi lần nữa. Tiến trình này lặp đi lặp
lại tới khi bieu_thuc_boolean là false.
Ví dụ:

public class Test {
public static void main(String args[]){
int x = 10;
do{
System.out.print("Gia tri cua x : " + x );

x++;
}

System.out.print("\n");
}while( x < 20 );

}

Chương trình Java trên sẽ cho kết quả sau:
Gia
Gia
Gia
Gia
Gia
Gia
Gia
Gia
Gia
Gia

tri
tri
tri
tri

tri
tri
tri
tri
tri
tri

cua
cua
cua
cua
cua
cua
cua
cua
cua
cua

x
x
x
x
x
x
x
x
x
x

:

:
:
:
:
:
:
:
:
:

10
11
12
13
14
15
16
17
18
19

Vòng lặp foreach
Trong Java 5, vòng lặp foreach (một tên gọi khác là enhanced for) đã được giới thiệu. Nó được sử
dụng chủ yếu với các mảng, các ArrayList, ...
Cú pháp:
Cú pháp của vòng lặp foreach như sau:
for(Khai_bao : Bieu_thuc)
{
//phan than vong lap
}

21


 Khai_bao: Biến khối được khai báo mới, mà là một kiểu tương thích với các phần tử của mảng
bạn đang truy cập. Biến này sẽ là có sẵn trong khối for và giá trị của nó sẽ là giống như phần tử mảng
hiện tại.
 Bieu_thuc: Nó ước lượng mảng bạn cần lặp. Bieu_thuc này có thể là một biến mảng hoặc gọi
phương thức mà trả về một mảng.
Ví dụ minh họa vòng lặp foreach trong Java
public class Test {
public static void main(String args[]){
int [] numbers = {10, 20, 30, 40, 50};
for(int x : numbers ){
System.out.print( x );
System.out.print(",");
}
System.out.print("\n");
String [] names ={"James", "Larry", "Tom", "Lacy"};
for( String name : names ) {
System.out.print( name );
System.out.print(",");
}
}
}

Chương trình Java trên sẽ cho kết quả sau:
10,20,30,40,50,
James,Larry,Tom,Lacy,

Các lệnh điều khiển vòng lặp trong Java

Câu hỏi đặt ra là nếu giả sử trong một vòng lặp tại một điều kiện cụ thể nào đó, bạn muốn dừng
thực thi hoặc tiếp tục thực thi vịng lặp đó, bạn sử dụng cách nào. Cũng như các ngơn ngữ lập trình khác,
Java hỗ trợ các lệnh giúp bạn điều khiển và kiểm sốt vịng lặp.
Bảng dưới liệt kê các lệnh được sử dụng để điều khiển vịng lặp mà Ngơn ngữ lập trình Java hỗ
trợ:
Lệnh

Miêu tả

Lệnh break

Từ khóa break được sử dụng để dừng tồn bộ vịng lặp. Từ khóa break phải được sử
dụng bên trong bất kỳ vòng lặp nào hoặc một lệnh switch.

Lệnh continue

Từ khóa continue có thể được sử dụng trong bất kỳ cấu trúc điều khiển vòng lặp nào.
Nó làm cho vịng lặp ngay lập tức tiếp tục tiến trình lặp tiếp theo của vịng lặp.

Lệnh break trong Java
Từ khóa break được sử dụng để dừng tồn bộ vịng lặp. Từ khóa break phải được sử dụng bên
trong bất kỳ vòng lặp nào hoặc một lệnh switch.
Từ khóa break sẽ dừng sự thực thi của vịng lặp trong cùng và bắt đầu thực thi dòng code tiếp
theo sau khối đó.
Cú pháp:
Cú pháp của lệnh break trong Java như sau:
break;
Ví dụ:
public class Test {
public static void main(String args[]) {

int [] numbers = {10, 20, 30, 40, 50};
for(int x : numbers ) {
if( x == 30 ) {
break;
}
System.out.print( x );
System.out.print("\n");
}
}
}

Chương trình Java trên sẽ cho kết quả sau:
10
20

22


Lệnh continue trong Java
Từ khóa continue có thể được sử dụng trong bất kỳ cấu trúc điều khiển vòng lặp nào. Nó làm cho
vịng lặp ngay lập tức tiếp tục tiến trình lặp tiếp theo của vịng lặp.
 Trong một vịng lặp for, từ khóa continue làm luồng điểu khiển ngay lập tức nhảy tới lệnh
update.
 Trong vòng lặp while hoặc do…while, luồng điều khiển ngay lập tức nhảy tới Booleanexpression.
Cú pháp:
Cú pháp của lệnh continue trong Java như sau:
continue;
Ví dụ minh họa lệnh continue trong Java
public class Test {
public static void main(String args[]) {

int [] numbers = {10, 20, 30, 40, 50};
for(int x : numbers ) {
if( x == 30 ) {
continue;
}
System.out.print( x );
System.out.print("\n");
}
}
}

Chương trình Java trên sẽ cho kết quả sau:
10
20
40
50

d) Toán tử điều kiện (? :) trong Java
Ngồi các lệnh kể trên, ngơn ngữ Java cịn có một loại toán tử điều kiện giúp bạn kiểm tra nhanh
các điều kiện và thực hiện phép gán giá trị cho một biến một cách rất nhanh chóng.
Tốn tử này gồm ba toán hạng và được sử dụng để ước lượng các biểu thức quan hệ. Mục tiêu của
toán tử là quyết định giá trị nào sẽ được gán cho biến. Toán tử này được viết như sau:
bien x = (bieu_thuc) ? (giatri1 neu true) : (giatri2 neu false);
//hoac ban cung co the su dung trong cac lenh RETURN
return (bieu_thuc) ? (giatri1 neu true) : (giatri2 neu false);
Tất nhiên, chúng ta không cần thiết phải sử dụng các dấu ngoặc đơn như trên. Chúng ta viết như
vậy để giúp các bạn dễ nhìn hơn. Sau đây là ví dụ minh họa toán tử điều kiện (? :) trong Java:
public class Test {
public static void main(String args[]){
int a , b;

a = 10;
b = (a == 1) ? 20: 30; //Day la vi du ve toan tu dieu kien.
System.out.println( "Gia tri cua b la : " + b );
b = (a == 10) ? 20: 30; //Day la vi du ve toan tu dieu kien.
System.out.println( "Gia tri cua b la : " + b );
}
}

Nó sẽ cho kết quả sau:
Gia tri cua b la : 30
Gia tri cua b la : 20

1.2.5. Nhập xuất trong JAVA
a) Xử lý nhập với Scanner
 Lớp Scanner được sử dụng để tạo ra đối tượng cho phép xử lý nhập dữ liệu từ bàn phím trong các
ứng dụng giao tiếp bằng dòng lệnh (console)
 Bên dưới là một ví dụ về xử lý nhập với Scanner
public class InputOutputSample {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
//Nhap chuoi
23


String str = s.nextLine();
//Nhap so nguyen
int n = s.nextInt();
//Nhap so thuc
float m = s.nextFloat();
}

}
 Xem cú pháp khai báo biến
Các bước thực hiện xử lý nhập
Bước 1: Tạo đối tượng Scanner
Scanner s = new Scanner(System.in);
Bước 2: Sử dụng đối tượng s để xử lý nhập với phương thức s.nextABC();
 Nếu là chuỗi thì ABC sẽ là Line => s.nextLine();
 Nếu là số nguyên thì ABC sẽ là Int hoặc Long => s.nextInt(); hoặc s.nextLong();
 Nếu là số thực thì ABC sẽ là Float hoặc Double => s.nextFloat(); hoặc s.nextDouble();
b) Xử lý xuất với System.out.print() hoặc System.out.println()
Xử lý xuất là nhằm mục đích hiển thị giá trị của các biến hoặc biểu thức hoặc hằng lên màn hình
console.
public class InputOutputSample {
public static void main(String[] args) {
//Xử lý nhập
Scanner s = new Scanner(System.in);
//Nhap chuoi
String str = s.nextLine();
//Nhap so nguyen
int n = s.nextInt();
//Nhap so thuc
float m = s.nextFloat();
//Xử lý xuất
System.out.println("Chuoi vua nhap la: "+str);
System.out.println("So nguyen vua nhap la: "+n);
System.out.println("So thuc vua nhap la: "+m);
}
}

Kết quả sau khi chạy chương trình (Trong NetBeans để chạy chương trình, chúng ta chuột phải

vào màn hình soạn thảo -> Chọn Run File (Hoặc nhấn tổ hợp phím Shift + F6)

Sự khác nhau giữa System.out.println() và System.out.print()
 Đối với System.out.println() sau khi hiển thị giá trị lên màn hình console sẽ đặt con trỏ ở dịng
mới

24


25