1. 1
MỤC LỤC
MỤC LỤC.................................................................................................................................. 1
Đề tài 0. Giới thiệu về Java ......................................................................................................... 6
I. Lịch sử hình thành và phát triển ngôn ngữ lập trình Java ...................................................... 6
I.1. Giới thiệu về Java.......................................................................................................... 6
I.2 Tóm tắt lịch sử hình thành của Java................................................................................ 6
II. Các đặc trưng của Java ....................................................................................................... 7
II.1. Tính đơn giản............................................................................................................... 7
II.2. Tính hướng đối tượng .................................................................................................. 7
II.3. Tính phân tán............................................................................................................... 7
II.4. Tính mạnh mẽ.............................................................................................................. 7
II.5. Tính an toàn................................................................................................................. 7
II.6. Tính trung lập .............................................................................................................. 7
II.7. Tính di động ................................................................................................................ 8
II.8. Tính thông dịch............................................................................................................ 9
II.9. Tính thực thi cao.......................................................................................................... 9
II.10. Tính đa luồng............................................................................................................. 9
II.11. Tính động .................................................................................................................. 9
III. Các loại ứng dụng của Java ............................................................................................... 9
IV. Công cụ và môi trường lập trình Java ................................................................................ 9
V. Cài đặt Java........................................................................................................................ 9
Đề tài 1. Ngôn ngữ mô hình hóa UML ...................................................................................... 12
I. Xây dựng hệ thống phần mềm theo hướng đối tượng ......................................................... 12
I.1 Các khái niệm căn bản của công nghệ hướng đối tượng................................................ 12
I.2 Quy trình chung phát triển hệ thống phần mềm ............................................................ 13
I.3 Những thách thức của ngành công nghiệp phần mềm hiện nay ..................................... 13
II. Lịch sử phát triển ngôn ngữ mô hình hóa UML................................................................. 13
II.1. Tóm tắt lịch sử UML ................................................................................................. 13
II.2. Khái niệm về UML.................................................................................................... 14
II.3 Đặc trưng của UML.................................................................................................... 14
III. Ngôn ngữ UML............................................................................................................... 15
III.1. Các thành phần của UML ......................................................................................... 15
III.2. Các hướng nhìn (view) ............................................................................................. 15
III.3 Ứng dụng UML trong quy trình làm phần mềm ......................................................... 22
IV. Quy trình Rational Unified Process (RUP) phát triển phần mềm dựa trên UML .............. 23
IV.1. Giới thiệu về RUP .................................................................................................... 23
IV.2. Các nguyên tắc chính của RUP:................................................................................ 23
IV.3. Vòng đời của phần mềm theo quy trình RUP............................................................ 24
IV.4. Các công cụ của RUP............................................................................................... 25
Bài tập .................................................................................................................................. 26
Đề tài 2. Nhập môn Java ........................................................................................................... 27
I. Viết và thực hiện một chương trình Java ............................................................................ 27
I.1 Tìm hiểu mã nguồn một chương trình đơn giản ............................................................ 27
I.2. Thực hiện chương trình Java. ...................................................................................... 27
I.3. Một số chú ý khi lập trình Java.................................................................................... 28
2. 2
I.4. Cấu trúc một chương trình Java................................................................................... 28
II. Các kiểu dữ liệu trong Java............................................................................................... 29
II.1 Các kiểu dữ liệu số nguyên ......................................................................................... 29
II.2 Các kiểu số thực.......................................................................................................... 30
II.3 Kiểu ký tự (character) ................................................................................................. 30
II.4 Kiểu logic (boolean) ................................................................................................... 30
II.5 Kiểu chuỗi .................................................................................................................. 30
II.6 Chuyển đổi giữa các kiểu số........................................................................................ 30
III. Khai báo biến và hằng trong Java .................................................................................... 31
III.1 Quy tắc đặt tên biến................................................................................................... 31
III.2 Khai báo biến ............................................................................................................ 31
III.3 Biến kiểu mảng.......................................................................................................... 32
III.4 Hằng số (literal)......................................................................................................... 33
III.5 Phạm vi hoạt động của hằng và biến: ......................................................................... 34
IV. Các toán tử và biểu thức.................................................................................................. 34
IV.1 Các toán tử và thứ tự ưu tiên...................................................................................... 34
IV.2 Biểu thức................................................................................................................... 35
V. Các lệnh điều khiển rẽ nhánh............................................................................................ 35
V.1 Lệnh if........................................................................................................................ 35
V.2. Lệnh switch …case.................................................................................................... 36
VI. Các lệnh lặp .................................................................................................................... 37
VI.1. Vòng lặp for ............................................................................................................. 37
VI.2. Vòng lặp while ......................................................................................................... 38
VI.3. Vòng lặp do... while ................................................................................................. 38
VI.4. Phép nhảy................................................................................................................. 39
VII. Vào dữ liệu từ bàn phím và xuất dữ liệu ra màn hình ..................................................... 40
VII.1. Lấy giá trị nhập vào từ bàn phím............................................................................. 40
VII.2 Kết xuất dữ liệu ra màn hình .................................................................................... 41
Bài tập .................................................................................................................................. 42
Đề tài 3. Lập trình hướng đối tượng trong Java ......................................................................... 44
I. Khái niệm lập trình hướng đối tượng (Object-Oriented Programming - OOP).................... 44
I.1. Khái niệm OOP........................................................................................................... 44
I.2 Cơ sở lý luận của OOP................................................................................................. 44
I.3 Trừu tượng hóa ............................................................................................................ 44
II. Tính đóng gói trong Java .................................................................................................. 46
II.1 Khái niệm tính đóng gói.............................................................................................. 46
II.2 Mối quan hệ giữa các class.......................................................................................... 46
II.3 Một số gợi ý khi thiết kế class..................................................................................... 46
IV. Sử dụng các Class xây dựng sẵn trong thư viện ............................................................... 47
V. Xây dựng Class trong Java ............................................................................................... 48
V.1 Cấu trúc của class ....................................................................................................... 48
V.2 Các thuộc tính thành phần:.......................................................................................... 49
V.3 Các phương thức thành phần....................................................................................... 50
V.4 Gọi và truyền tham số cho phương thức...................................................................... 51
V.6 Các hàm và phương thức đặc biệt ............................................................................... 51
V.7 Khai báo chồng các phương thức ................................................................................ 52
V.8 Lớp lồng nhau – lớp nội.............................................................................................. 53
3. 3
VI. Tính kế thừa trong Java................................................................................................... 54
VI.1 Sự kế thừa các thuộc tính và phương thức.................................................................. 54
VI.2 Sự kế thừa đối với các constructor............................................................................. 57
VII. Tính đa hình trong Java.................................................................................................. 58
VII.1 Sự ép kiểu và gán tham chiếu đối tượng ................................................................... 58
VII.2 Sự ràng buộc động –Dynamic Binding..................................................................... 58
VIII. Lớp Object ................................................................................................................... 59
IX. Giao diện ........................................................................................................................ 60
IX.1 Cấu trúc của giao diện ............................................................................................... 60
IX.2 Các tính chất của giao diện........................................................................................ 62
X. Package............................................................................................................................ 62
X.1 Sử dụng các package trong thư viện Java .................................................................... 62
X.2 Đặt lớp vào package ................................................................................................... 63
Bài tập .................................................................................................................................. 63
Đề tài 4. Lớp và phương thức trừu tượng .................................................................................. 64
I. Khái niệm lớp trừu tượng................................................................................................... 64
II. Cài đặt lớp và phương thức trừu tượng trong Java............................................................. 64
Bài tập .................................................................................................................................. 65
Đề tài 5. Lưu trữ và xử lý đối tượng .......................................................................................... 66
I. Lớp Vector và giao diện Enumeration................................................................................ 66
I.1 Lớp Vector................................................................................................................... 66
I.2 Giao diện Enumeration................................................................................................. 67
II. Mảng trong Java và lớp ArrayList..................................................................................... 69
II.1 Mảng trong Java ......................................................................................................... 69
II.2. Các thuật toán cơ bản trên mảng ................................................................................ 70
II.3 Class Arrays ............................................................................................................... 71
III Danh sách trong java và giao diện Lists............................................................................ 73
Bài tập .................................................................................................................................. 74
Đề tài 6. Các luồng vào ra dữ liệu với file ................................................................................. 75
I. Khái niệm luồng vào ra (I/O stream) .................................................................................. 75
II. Lớp InputStream:.............................................................................................................. 76
III. Lớp OutputStream........................................................................................................... 77
IV. Lớp FileInputStream ....................................................................................................... 77
V. Lớp FileOutputStream...................................................................................................... 77
VI. Lớp File .......................................................................................................................... 77
VII. Nhập xuất lọc................................................................................................................. 78
VII.1 Lớp FilterInputStream:............................................................................................. 79
VII.2 Lớp FilterOutputStream ........................................................................................... 79
VIII. Vào/ra có sử dụng bộ đệm ............................................................................................ 79
VIII.1 Lớp BufferedInputStream: ...................................................................................... 79
VIII.2 Lớp BufferedOutputStream..................................................................................... 79
IX. Lớp RandomAccessFile .................................................................................................. 81
X. Đối tượng System.in......................................................................................................... 82
XI. Truy cập file ở chế độ tuần tự.......................................................................................... 82
XII. Truy cập file nhị phân.................................................................................................... 86
Bài tập .................................................................................................................................. 86
Đề tài 7. Xử lý ngoại lệ ............................................................................................................. 88
4. 4
I. Các tình huống sử dụng ngoại lệ ........................................................................................ 88
II. Cơ sở quản lý ngoại lệ trong Java ..................................................................................... 88
III. Cấu trúc cây kế thừa các xử lý ngoại lệ............................................................................ 89
IV. Sử dụng ngoại lệ được kiểm soát..................................................................................... 90
V. Xây dựng một ngoại lệ ..................................................................................................... 91
VI. Bài tập ............................................................................................................................ 92
Đề tài 8. Xử lý các sự kiện trong Java ....................................................................................... 93
I. Khái niệm và cơ sở xử lý sự kiện ....................................................................................... 93
II. Truy cập thông tin sự kiện ................................................................................................ 98
III. Xử lý các sự kiện trên window ........................................................................................ 99
IV. Các lớp thích nghi ..........................................................................................................100
V. Xử lý các sự kiện chuột ...............................................................................................102
Bài tập .................................................................................................................................103
Đề tài 9. Applet........................................................................................................................104
I. Xây dựng một Applet đơn giản .........................................................................................104
II. Cấu trúc cơ bản và vòng đời của một Applet....................................................................104
III. An ninh và khả năng của Applet.....................................................................................106
IV. Ứng dụng Applet với của sổ Popup ................................................................................106
V. Các thẻ HTML của Applet...............................................................................................107
VI. Các phương thức, lập trình đồ họa và bắt sự kiện của applet...........................................108
Đề tài 10. Lập trình giao diện đồ họa GUI................................................................................110
I. Giới thiệu AWT................................................................................................................110
II. Vật chứa (Container) .......................................................................................................111
II.1 JFrame.......................................................................................................................111
II.2 JPanel ........................................................................................................................111
II.3 JDialog ......................................................................................................................112
II.4 JScrollPane ................................................................................................................113
III. Giới thiệu về các thành phần GUI cơ bản .......................................................................113
III.1 Nút nhấn...................................................................................................................113
III.2 Nhãn (Label) ............................................................................................................114
III.3 Nút đánh dấu (checkbox)..........................................................................................115
III.4 Nút chọn (radio button).............................................................................................117
III.5 Hộp thoại Combo .....................................................................................................118
III.6 Danh sách (Lists)......................................................................................................119
III.7 Ô văn bản (text field) và vùng văn bản (text areas) ...................................................121
III.8 Thanh trượt (Scrollbar).............................................................................................123
IV. Thành phần Menu ..........................................................................................................124
V. Bộ quản lý cách trình bày (Layout Manager) ...................................................................127
V.1 Cách trình bày FlowLayout:.......................................................................................128
V.2 Cách trình bày GridLayout: .......................................................................................128
V.3 Cách trình bày BorderLayout.....................................................................................128
VI. Các hộp thoại .................................................................................................................128
VI.1 Hộp thoại thông báo .................................................................................................128
VI.2 Hộp thoại chọn File ..................................................................................................129
VI.3 Hộp thoại chọn màu .................................................................................................130
Bài tập .................................................................................................................................130
Đề tài 11. Threading ................................................................................................................132
5. 5
I. Khái niệm thread...............................................................................................................132
I.1 Khái niệm: ..................................................................................................................132
I.2. Lớp Thread ................................................................................................................132
I.3 Các bước để tạo một thread.........................................................................................132
II. Các trạng thái của thread..................................................................................................133
III. Các thuộc tính của thread ...............................................................................................134
III.1 Độ ưu tiên của thread................................................................................................134
III.2 Nhóm thread.............................................................................................................135
III.3 Quản lý các ngoại lệ của thread ................................................................................135
IV. Điều khiển các thread.....................................................................................................136
IV.1 Interrupt một thread..................................................................................................136
IV.2 Dừng một thread ......................................................................................................137
IV.3 Tạm dừng và phục hồi một thread ............................................................................138
IV.4 Giải phóng thời gian cho CPU..................................................................................138
IV.5 Đợi một thread kết thúc công việc ............................................................................138
V. Đồng bộ thread................................................................................................................139
V.1 Tình trạng “đua tranh” ...............................................................................................139
V.2 Khóa đối tượng..........................................................................................................140
V.3 Đối tượng điều kiện ...................................................................................................141
Bài tập .................................................................................................................................143
Phụ lục A. Các từ khóa của Java ..............................................................................................144
Phụ lục B Một số hàm hay sử dụng ..........................................................................................145
Tài liệu tham khảo ...................................................................................................................146
6. 6
Đề tài 0. Giới thiệu về Java
I. Lịch sử hình thành và phát triển ngôn ngữ lập trình Java
I.1. Giới thiệu về Java
Java là một ngôn ngữ lập trình mạnh đang được sử dụng rất rộng rãi hiện nay trên toàn thế
giới. Trên thực tế, Java được biết đến không chỉ là một ngôn ngữ lập trình mà là một platform –
một môi trường và công nghệ phát triển – riêng biệt. Khi làm việc với Java, người lập trình được
sở hữu một thư viện lớn, có tính mở với một lượng mã nguồn tái sử dụng khổng lồ luôn có trên
internet. Ngoài ra, các chương trình viết bằng Java có môi trường thực thi riêng với các tính năng
bảo mật, khả năng triển khai trên nhiều hệ điều hành khác nhau và nhiều tính năng ưu việt khác
chúng ta sẽ xem xét trong phần sau.
I.2 Tóm tắt lịch sử hình thành của Java
Năm 1991, một nhóm kỹ sư của hãng SUN bao gồm Patrick Naughton, Sun Fellow và
James Gosling có ý tưởng phát minh ra một ngôn ngữ lập trình nhỏ gọn có thể thực thi được trên
các thiết bị dạng như bộ chuyển kênh của truyền hình cáp vì các thiết bị kiểu này có bộ nhớ nhỏ.
Bên cạnh đó, do các hãng khác nhau sử dụng các chíp xử lý (CPUs) khác nhau nên một đặc tính
quan trọng mà ngôn ngữ này phải có là độc lập với các dòng CPUs khác nhau – gọi là đặc tính di
động. Nhóm đã mở một dự án có tên là Green để hiện thực hóa ý tưởng này.
Để giải quyết vấn đề di động, nhóm đã sử dụng ý tưởng của kỹ sư Niklaus Wirth – người
sáng lập ngôn ngữ Pascal – về việc sử dụng cơ chế thông dịch và máy ảo (virtual machine).
Về nền tảng ngôn ngữ, do hãng SUN phát triển trên nền UNIX nên họ sử dụng ngôn ngữ
lập trình C++ là chủ yếu. Do đó, ngôn ngữ mới thiên về hướng đối tượng (Object Oriented) của
C++ hơn là hướng thủ tục như Pascal.
Ban đầu nhóm đặt tên cho ngôn ngữ mới là “Oak” nhưng sau đó được chuyển thành Java
do Oak cũng đã là tên một ngôn ngữ lập trình khác.
Năm 1992, dự án Green cho ra đời sản phẩm đầu tiên có tên là “*7” nhưng đã không được
chào đón như mong đợi. Sau đó nhóm đã phải mất cả năm 1993 và nửa đầu 1994 để đi tiếp thị
công nghệ của mình. Từ năm 1994, sự phát triển của Internet đã tạo cơ hội để Java phát triển
nhanh chóng. Nhóm đã phát triển một trình duyệt có tên là HotJava cho phép các chương trình
Java nhúng được trong đó (applet). Đây chính là minh chứng rõ ràng về sức mạnh của Java đã
nhanh chóng được cộng đồng người sử dụng internet biết đến và là tiền đề để Java phát triển rực
rỡ như ngày hôm nay.
Phiên bản đầu tiên 1.0 của Java ra đời vào năm 1996, sau đó là phiên bản 1.1 mặc dù khá
mạnh nhưng cũng còn nhiều hạn chế.
Năm 1998 đánh đấu bước chuyển mình mạnh mẽ của Java với sự ra đời của phiên bản 1.2
làm cho Java tiến gần tới mục tiêu “viết một lần, chạy khắp nơi” (Write once, Run Anywhere).
Các nhân viên tiếp thị của Java gọi đây là phiên bản “Java 2 Standard Edition Software
Development Kit Version 1.2” ý nói tới sự có mặt đồng thời của 2 phiên bản “Standard Edition”
là Micro Edition và Enterprise Edition trong Java.
Các phiên bản 1.3, 1.4 là sự phát triển mở rộng tiếp theo của phiên bản 1.2. Phiên bản 1.5
(chuyển sang gọi là phiên bản 5.0) đánh dấu sự tích hợp đầy đủ nhất các công nghệ Java.
Bảng sau cho thấy sự phát triển thư viện Java qua các phiên bản:
Phiên bản Số các Class và Interface
7. 7
1.0 211
1.1 477
1.2 1524
1.3 1840
1.4 2723
5.0 3270
Hiện tại, Java đã phát triển tới phiên bản 1.6.
II. Các đặc trưng của Java
Java được biết đến với các đặc trưng sau:
II.1. Tính đơn giản
Java được phát triển dựa trên C++ nhưng lược bớt đi hoặc thay thế các khái niệm khó
hiểu như header file, con trỏ, structures, union, operator overloading, virtual base class. Trong
Java chỉ có thừa kế đơn mà không có tính đa thừa kế như của C++. Tuy nhiên tính đa thừa kế
được biểu hiện thông qua việc sử dụng các Interface.
II.2. Tính hướng đối tượng
Như đã trình bày ở trên, Java được phát triển từ C++ nên nó là ngôn ngữ lập trình hướng
đối tượng.
II.3. Tính phân tán
Java cho phép lập trình truy cập các đối tượng từ xa thông qua các giao thức HTTP, FTP
bằng các phương thức như RMI hay Socket.
Java hoàn toàn thích hợp cho các ứng dụng Internet. Các công nghệ JSP, Servlet cho phép
xây dựng các website tương tác với các tính năng thực thi tối ưu
II.4. Tính mạnh mẽ
Việc loại bỏ con trỏ làm tăng độ tin cậy của chương trình. Lập trình viên không cần quan
tâm đến thao tác cấp phát và giải phóng bộ nhớ. Với Java, bộ nhớ được giải phóng tự động.
II.5. Tính an toàn
Ngôn ngữ Java được thiết kế để tránh các sự cố:
Nạp chồng stack lúc runtime.
Ảnh hưởng tới bộ nhớ nằm ngoài phạm vi được cấp phát.
Đọc và ghi file tự do
II.6. Tính trung lập
Các chương trình viết bằng Java không bị phụ thuộc vào hệ điều hành. Điều này có được
là do mã nguồn chương trình không được biên dịch thành mã máy ngay mà thành mã Bytecode.
8. 8
Khi đem mã Bytecode này chạy trên hệ máy tính nào thì một trình thông dịch virtual machine
(Java Vitual Machine-JVM) sẽ thông dịch chúng sang mã máy tương ứng để thực thi.
Mã nguồn -> ByteCodes -> machine code.
Từ mã nguồn -> Bytecodes: Trình biên dịch Java.
Từ Bytecodes -> machine code: Trình thông dịch Virtual machine.
Java Virtual Machine – JVM
Máy ảo là một phần mềm dựa trên cơ sở máy tính ảo. Nó có tập hợp các lệnh logic để xác
định các hoạt động của máy tính. Người ta có thể xem nó như một hệ điều hành thu nhỏ. JVM
thiết lập các lớp trừu tượng cho phần cứng bên dưới, hệ điều hành, mã đã biên dịch.
Trình biên dịch chuyển mã nguồn thành tập các lệnh của máy ảo mà không phụ thuộc vào
phần cứng cụ thể. Trình thông dịch trên mỗi máy sẽ chuyển tập lệnh này thành chương trình thực
thi. Máy ảo tạo ra một môi trường bên trong để thực thi các lệnh bằng cách:
Nạp các file .class
Quản lý bộ nhớ
Dọn “rác”, thu hồi bộ nhớ cấp cho các biến không còn được sử dụng.
Việc không nhất quán của phần cứng làm cho máy ảo phải sử dụng ngăn xếp để lưu trữ
các thông tin sau:
Các “Frame” chứa các trạng thái của các phương thức.
Các toán hạng của mã bytecode.
Các tham số truyền cho phương thức.
Các biến cục bộ.
II.7. Tính di động
Không giống C++ và C, các kiểu dữ liệu nguyên thủy của Java được cấp phát một lượng
bộ nhớ cố định. Chẳng hạn kiểu dữ liệu int của Java luôn là 4 byte (32 bit) trong khi kiểu int của
C++ có thể hiểu là 2 byte hoặc 4 byte. Thiết kế này giúp cho trình biên dịch luôn có số bytecode
như nhau trên mọi hệ máy và sau đó phát sinh mã máy theo khuôn dạng cố định.
Trong các phiên bản đầu của Java, vấn đề giao diện đồ họa cho người sử dụng (GUI) chưa
được xử lý triệt để và phụ thuộc vào hệ máy. Ngày nay, thư viện GUI của Java đã được viết lại
hoàn toàn và có tính độc lập cao giúp cho chương trình Java có giao diện giống nhau trên mọi hệ
máy.
Macintosh
Trình
biên dịch
Bytecode
Trình
thông
dịch
Java
(Java
Interpreter)
IBM
Sparc
9. 9
II.8. Tính thông dịch
Trình thông dịch Java sẽ thông dịch mã bytecode sang mã máy nơi mà nó được cài đặt.
Quá trình này cũng làm các chương trình Java chạy chậm hơn. Tuy nhiên đây lại là giải pháp cho
tính di động.
II.9. Tính thực thi cao
Java sử dụng công nghệ Just-In-Time (JIT) giúp quá trình thông dịch thực hiện nhanh
hơn. Với công nghệ này, những mã bytecode giống nhau sẽ chỉ cần thông dịch một lần. Ngày
nay, công nghệ này liên tục được cải tiến và cho kết quả vượt trội so với các trình thông dịch
truyền thống. Ví dụ như JIT có thể quản lý các đoạn mã được sử dụng thường xuyên trong
chương trình, tối ưu chúng để nâng cao tốc độc thực hiện.
II.10. Tính đa luồng
Với chương trình Java, lập trình viên có thể cùng lúc quản lý nhiều tiến trình khác nhau.
Điều này giúp cho việc cài đặt các thuật toán song song bằng Java trên các máy tính nhiều CPU
được dễ dàng hơn, đặc biệt trong các ứng dụng thời gian thực.
II.11. Tính động
Các chương trình Java có thể được nâng cấp mà không ảnh hưởng tới người sử dụng. Các
phương thức mới có thể được cài đặt thêm vào các lớp đối tượng hay các giao diện trong thư viện
của chương trình đang chạy.
III. Các loại ứng dụng của Java
Ứng dụng console: Không có giao diện GUI.
Ứng dụng đồ hoạ: Có giao diện GUI.
Applet: Nhúng trong các trang Web.
Servlet: Các class thực thi phía web server.
JSP: Các file nhúng mã Java và HTML.
Ứng dụng EJB, RMI, JMS: Xây dựng ứng dụng bởi nhiều thành phần ghép lại,
giao tiếp từ xa.
IV. Công cụ và môi trường lập trình Java
Hiện nay có rất nhiều môi trường phát triển Java (Integrated Development Environment -
IDE). Mỗi môi trường cung cấp cho lập trình viên những tiện ích lập trình ở mức độ khác nhau.
Một số IDE thông dụng là:
Netbeans (miễn phí tại http://www.netbeans.org).
Jcreator (thương mại).
Jbuilder (thương mại).
Eclipse (miễn phí http://www.eclipse.org/).
V. Cài đặt Java
Java phiên bản Java mới nhất có thể download tại địa chỉ http://java.sun.com/j2se. Sau đó
cài đặt như ứng dụng bình thường.
Thư mục cài đặt mặc định của Java trên Windows là C:Program FilesJavajdk1.6.0_02
(nếu phiên bản cài là jdk1.6.0_02). Trong đó có chứa các thư mục với ý nghĩa sau:
10. 10
bin Chứa các công cụ và trình biên dịch Java
demo Chứa các chương trình Java Demo
docs Chứa các tài liệu mô tả thư viện của Java
includes Chứa các file dùng để biên dịch các đoạn mã nguồn viết bằng ngôn ngữ khác (native).
jre Chứa các file lưu thông tin môi trường lúc thực thi
lib Chứa các file thư viện
src Chứa mã nguồn java
Trong thư mục bin có chữa các công cụ chính của Java:
Trình biên dịch, 'javac'
Cú pháp:javac [options] sourcecodename.java
Trình thông dịch, 'java'
Cú pháp:java [options] classname
Trình dịch ngược, 'javap'
javap dịch ngược bytecode và in ra thông tin về các thuộc tính (các trường), các phương
thức của một lớp.
Cú pháp:javap [options] classname
Công cụ sinh tài liệu, 'javadoc'
Tiện ích này cho phép ta tạo ra tệp HTML dựa trên các lời giải thích trong mã chương
trình (phần nằm trong cặp dấu /*.... */).
Cú pháp:javadoc [options] sourcecodename.java
Chương trình tìm lỗi - Debug, 'jdb„
Cú pháp:jdb [options] sourcecodename.java
hay
jdb -host -password [options] sourcecodename.java
Cài đặt đường dẫn mặc định.
1. Mở Control Panel
2. Chọn System
11. 11
3. Chọn Tab Advanced
4. Chọn Environment Variables
5. Thêm đường dẫn C:Program FilesJavajdk1.6.0_02bin vào biến môi trường Path
- Chọn Variable Path
- Chọn Edit
12. 12
Đề tài 1. Ngôn ngữ mô hình hóa UML
I. Xây dựng hệ thống phần mềm theo hướng đối tượng
I.1 Các khái niệm căn bản của công nghệ hướng đối tượng
Hướng đối tượng là một công nghệ để sản sinh ra các mô hình phản ánh một cách tự
nhiên các nghiệp vụ thực tế. Xét cho cùng thì mọi quy trình nghiệp vụ trong thực tế đều là sự
tương tác của các đối tượng theo một trình tự nhằm đạt được một mục đích cụ thể. Nói cách khác,
các đối tượng và mối quan hệ giữa chúng phản ánh quy trình nghiệp vụ. Ví dụ như nghiệp vụ
tuyển nhân sự cho một công ty có thể được tóm tắt qua một chuỗi các tương tác như sau:
1. Công ty đưa ra thông báo tuyển nhân sự tới các ứng viên có nhu cầu
2. Ứng viên gửi hồ sơ dự tuyển tới công ty
3. Công ty duyệt hồ sơ và gửi giấy hẹn phỏng vấn tới ứng viên
4. Công ty phỏng vấn ứng viên
5. Công ty ký hợp đồng với ứng viên hoặc từ chối
Trong ví dụ trên có sự tham gia của hai đối tượng “công ty” và “ứng viên”. Sự trao đổi
thông tin giữa hai đối tượng này cho thấy mối quan hệ phụ thuộc giữa chúng (dependence).
Một ví dụ khác là trong hệ thống quản lý nhân sự chúng ta có các đối tượng như: nhân
viên, quản lý,…cho thấy mối quan hệ dạng khác: các nhân viên làm công việc quản lý tất nhiên
cũng là nhân viên của công ty nhưng có thêm các thuộc tính riêng biệt – một quan hệ kế thừa
(inheritance).
Trong một hệ thống bán hàng, mỗi đơn hàng bao gồm trong nó các thông tin về khách
hàng, ngày giờ, …và một danh mục các mặt hàng. Khi này ta nói rằng giữa đơn hàng và mặt
hàng tồn tại một quan hệ bao gồm (aggregation)
Mục tiêu của công nghệ hướng đối tượng chính là thể hiện được các đối tượng và mối
quan hệ giữa chúng vào trong các hệ thống phần mềm. Vì vậy, các hệ thống phần mềm theo công
nghệ hướng đối tượng phản ánh một cách tự nhiên và trung thực nghiệp vụ thực tế và có khả
năng đáp ứng các thay đổi dễ dàng.
Phát triển một hệ thống phần mềm theo hướng đối tượng dựa trên 5 khái niệm cơ bản:
Lớp (class), đối tượng (object), thông điệp (mesage), thừa kế (inheritance) và đa hình
(polymorphism).
Lớp là sự trừu tượng hóa các đối tượng thực tế theo phạm vi nghiệp vụ. Lấy ví dụ về hệ
thống quản lý sinh viên của trường ĐHBK Hà Nội cần quản lý rất nhiều đối tượng sinh viên khác
nhau nhưng có thể chỉ được trừu tượng hóa thành một lớp đối tượng có tên SinhVien chẳng hạn.
Sự trừu tượng hóa một lớp đối tượng cho ta kết quả một tập các thuộc tính (attributes) và các
hành vi (operations) đặc trưng cho bất kỳ đối tượng nào thuộc lớp đó. Đối tượng thực tế thì có vô
số thuộc tính và hành vi nhưng chỉ thuộc tính và hành vi trong phạm vi nghiệp vụ là được xét
đến. Sự chi tiết phụ thuộc vào phạm vi nghiệp vụ.
Sự trừu tượng hóa diễn ra ở nhiều cấp độ. Lấy ví dụ: lớp động vật có vú bao gồm lớp
động vật 4 chân, lớp 4 chân lại bao gồm các lớp như lớp mèo, lớp trâu,…
Mỗi đối tượng là một biểu hiện thực tế của một lớp.
object = name + attributes + operations
Hệ thống hướng đối tượng nếu được mô hình đúng sẽ rất linh hoạt, dễ hiệu chỉnh, được
cài đặt dễ dàng bằng các ngôn ngữ hướng đối tượng. Các hệ thống phần mềm hướng đối tượng
cũng được cài đặt bởi các ngôn ngữ lập trình hướng đối tượng.
13. 13
Hướng đối tượng không chỉ là một lý thuyết mà đã được chứng minh bằng những ứng
dụng rất thành công trong thực tế ở nhiều lĩnh vực khác nhau. Tuy nhiên, lĩnh vực này vẫn cần
được chuẩn hóa hơn nữa.
I.2 Quy trình chung phát triển hệ thống phần mềm
Xây dựng một hệ thống phần mềm hướng đối tượng cũng tuân theo quy trình chung như
mọi công nghệ khác:
1. Requirements : Thu thập yêu cầu
2. Analysis : Phân tích
3. Design: Thiết kế
4. Implementation: Cài đặt
5. Test: Kiểm thử
6. Deployment: Triển khai
Theo nguyên tắc chung này, mỗi công ty lại ứng dụng những công nghệ khác nhau để
phát triển ứng dụng như các mô hình water fall, mô hình hướng chức năng,…
I.3 Những thách thức của ngành công nghiệp phần mềm hiện nay
Mặc dù đã ứng dụng các công nghệ tiến tiến và quy trình phát triển chuẩn hóa nhưng
ngành công nghiệp phần mềm vẫn phải đối mặt với những thách thức:
1. Sự gia tăng về quy mô từ nhỏ đến lớn của ứng dụng
2. Sức ép về thời gian hoàn thành
3. Sự phân tán về không gian làm việc
4. Đa dạng về nội dung
5. Sự thay đổi các yêu cầu của người sử dụng
Những thách thức này có thể nói là gắn liền với mọi công ty phần mềm đặc biệt là ở Việt
Nam, nơi mà vai trò của quá trình khảo sát, phân tích còn bị xem nhẹ cũng như các công ty còn
đang bỡ ngỡ với sự mở rộng về quy mô và thiếu nhân lực chuyên môn về phân tích thiết kế.
II. Lịch sử phát triển ngôn ngữ mô hình hóa UML
II.1. Tóm tắt lịch sử UML
Những năm 1980 là thời kỳ bùng nổ số lượng các công ty phần mềm sử dụng ngôn ngữ
lập trình hướng đối tượng(Object Oriented Programming - OOP) để xây dựng các ứng dụng.
Điều này dẫn tới một đòi hỏi phải có một quy trình làm phần mềm tiếp cận theo hướng phân tích
và thiết kế hướng đối tượng (Object Oriented Analyze and Design - OOAD). Nhiều nhà nghiên
cứu phương pháp trong đó có Booch, Rumbaugh và Jacobson đã làm việc độc lập và đã đề xuất
các quy trình thỏa mãn yêu cầu này. Mỗi một quy trình có một tập ký hiệu mô hình riêng để
truyền đạt và diễn tả các kết quả phân tích và thiết kế.
Vào đầu những năm 1990, các công ty khác nhau, thậm chí là các bộ phận khác nhau của
cùng một công ty đã sử dụng các quy trình khác nhau. Thêm vào đó, các công ty này lại muốn sử
dụng các công cụ phần mềm hỗ trợ các quy trình của họ. Với quá nhiều quy trình khác nhau, các
công ty phần mềm đã rất khó khăn trong việc cung cấp các công cụ này. Điều này cho thấy việc
cần thiết phải có một quy trình với tập ký hiệu thống nhất.
Năm 1994, James Rumbaugh đã hợp tác cùng Grady Booch tại công ty phần mềm
Rational Software Corporation để cùng xây dựng một quy trình thống nhất dựa trên kết quả của
từng người. Sau đó Ivar Jacobson cũng sớm gia nhập nhóm này. Năm 1996, nhóm đã cho xuất
14. 14
bản phiên bản đầu tiên của UML tới cộng đồng phát triển phần mềm và yêu cầu phản hồi. Cũng
cùng thời gian đó, một tổ chức có tên Object Management Group (OMG) đã mời nhóm đệ trình
một ngôn ngữ mô hình. OMG là một tổ chức phi lợi nhuận chuyên xúc tiến việc sử dụng công
nghệ hướng đối tượng trong ngành công nghiệp phần mềm thông qua việc đưa ra các hướng dẫn
và đặc tả OOP. Các thành viên của OMG ban đầu là 3Com Corporation; American Airlines;
Canon, Inc.; Data General; Hewlett-Packard; Philips Telecommunications N.V.; Sun
Microsystems; và Unisys Corporation. Các tập đoàn lớn như HP, IBM, Microsoft, Oracle và
Rational Software đã nhận thấy lợi ích của UML và đã nhận lời tài trợ cho các dự án về UML của
OMG. Năm 1997, OMG tiếp tục xem xét lại UML và đến năm 2001 thì phiên bản UML 1.4 ra
đời. Hiện nay OMG đã phát hành tới phiên bản UML 2.0 và đang nghiên cứu phiên bản 2.1.
II.2. Khái niệm về UML
UML – Unified Modeling Language là một ngôn ngữ dùng các sơ đồ và mô hình thống
nhất để mô hình các hệ thống phần mềm.
Mục đích của UML là:
Trở thành ngôn ngữ mô hình mà tất cả mọi người làm mô hình có thể sử dụng
Tập trung hướng tới giải quyết các vấn đề tồn tại trong phát triển phần mềm hiện
nay.
Đơn giản nhất có thể trong khi vẫn mô hình được phần lớn các ứng dụng.
Nâng cao tính tái sử dụng các thành phần của một hệ thống phần mềm
UML là một ngôn ngữ diễn tả, UML không phải là một quy trình.
Thuật ngữ “Unified” ở đây có một ý nghĩa quan trọng, nó nói lên các nguyên tắc của
UML:
Thống nhất phương thức, ký hiệu, thuật ngữ
Gắn kết giữa các chu trình phát triển
Không phụ thuộc vào lĩnh vực ứng dụng
Không phụ thuộc vào ngôn ngữ lập trình và môi trường thực hiện
Không phụ thuộc vào quy trình phát triển
Gắn kết chặt chẽ các khái niệm nội tại của hệ thống.
II.3 Đặc trưng của UML
Hiện nay, UML là một ngôn ngữ đã được OMG chuẩn hóa và được đặc tả rõ ràng. Tất cả
các mô hình, sơ đồ của UML đều theo hướng đối tượng.
Các đặc tính của UML bao gồm:
Mô hình class (class diagrams) mô tả cấu trúc tĩnh của hệ thống và mối quan hệ
giữa các đối tượng
Mô hình tương tác (interaction diagrams), mô hình trạng thái (state diagrams), mô
hình hoạt động (activity diagrams) mô tả các hành vi động của các đối tượng trong
hệ thống cũng như các thông điệp giữa chúng.
Mô hình Use-case và mô hình hoạt động mô tả các yêu cầu và các luồng công việc
trong hệ thống.
Các mô hình cấu trúc hỗn hợp (composite structure diagrams) mô tả sự hợp tác
cũng như các đặc điểm về cài đặt.
Mô hình triển khai (deployment diagrams) mô tả việc triển khai phần mềm trên
một môi trường xác định.
15. 15
III. Ngôn ngữ UML
III.1. Các thành phần của UML
Xét trên khía cạnh ngôn ngữ diễn tả, UML có đầy đủ các mô hình và sơ đồ để thể hiện
hầu hêt các khía cạnh của hệ thống phần mềm. Các thành phần của ngôn ngữ UML bao gồm:
Các Views (các hướng nhìn): Các view thể hiện các cách nhìn khác nhau tới hệ
thống. Một hệ thống không thể chỉ được mô tả bởi một sơ đồ. Nhiều hướng nhìn
khác nhau cho ta nhiều sơ đồ mô tả đầy đủ về hệ thống. Các hướng nhìn cũng liên
kết ngôn ngữ mô hình với các quy trình được chọn cho việc phát triển hệ thống.
Các Diagrams (các sơ đồ): Các sơ đồ bao gồm các phần tử hình vẽ dùng để mô tả
nôi dung của các View. UML 2.0 bao gồm 13 loại sơ đồ khác nhau.
Các Model Elements (các phần tử mô hình): Các khái niệm được sử dụng trong
các sơ đồ và các phần tử của sơ đồ diễn tả các khái niệm phổ biến của công nghệ
hướng đối tượng như class, object, message (thông điệp) và mối quan hệ giữa
chúng bao gồm quan hệ dependence, inheritance và aggregation. Một phần tử mô
hình có thể được sử dụng trong nhiều sơ đồ nhưng chúng luôn có cùng ý nghĩa và
ký hiệu giống nhau.
Các General Mechanisms (các đặc tả chung mở rộng): Mô tả các thông tin chú
thích, ngữ nghĩa của các phần tử mô hình, thuật ngữ.
III.2. Các hướng nhìn (view)
Use-case view: Đây là hướng nhìn về mặt chức năng của hệ thống được thực hiện bởi các
tác nhân bên ngoài.
17. 17
8. Ngoại lệ
9. Hậu điều kiện
Sau đây là một ví dụ về use-case text detail:
Use-case: Đòi tiền bồi thường
Phạm vi: Công ty Bảo hiểm PCM
Actor chính: Người đòi bồi thường
Dòng chính
1. Người đòi bồi thường gửi đơn yêu cầu với các dữ liệu bằng chứng về tai nạn
2. Công ty bảo hiểm xác nhận người viết đơn có quyền lợi bảo hiểm hợp lệ
3. Công ty bảo hiểm phân công cho một đại lý xác minh trường hợp này
4. Đại lý đối chiếu tất cả các chi tiết trong đơn theo chính sách bảo hiểm của công ty
5. Công ty bảo hiểm trả tiền bảo hiểm
Dòng phụ
1a. Bằng chứng tai nạn không đầy đủ
1a1. Công ty bảo hiểm yêu cầu dữ liệu thiếu
1a2. Người đòi bồi thường gửi lại các dữ liệu thiếu
2a. Người đòi bồi thường không có chính sách bảo hiểm hợp lệ
2a1. Công ty bảo hiểm từ chối yêu cầu, nhắc nhở, ghi lại và kết thúc xử lý vụ việc
3a. Không có đại lý nào rảnh rỗi
3a1. (Công ty bảo hiểm sẽ làm gì trong trường hợp này???)
4a. Vụ tai nạn vi phạm chính sách bảo hiểm cơ bản
4a1. Công ty bảo hiểm từ chối yêu cầu, nhắc nhở, ghi lại và kết thúc xử lý vụ việc
4b. Vụ tai nạn chỉ vi phạm chính sách bảo hiểm nhỏ
4b1. Công ty bảo hiểm điều đình với người đòi bảo hiểm và đồng ý trả bảo hiểm
Trong trường hợp các use-case quá phức tạp và chưa được mô tả rõ ràng, chúng có thể
được tác ra thành các use-case nhỏ hơn theo hai dạng:
Include: use-case mới được tách ra và được bao gồm trong use-case chính một
cách vô điều kiện
Extend: use-case mới xảy ra khi một điều kiện xảy ra trong use-case chính.
uc Use Case Model
Use Case Principal
Use Case Include
«include»
18. 18
Nói chung, use-case view giúp ta trả lời câu hỏi WHAT? về hệ thống.
Logical views
Đây là hướng nhìn cho biết các chức năng được thiết kế vào trong hệ thống như thế nào
(HOW?) thông qua việc mô tả các cấu trúc tĩnh và các hành vi động của hệ thống. Sau đây là một
số sơ đồ quan trọng thường được sử dụng.
Các cấu trúc tĩnh (static structure): Cấu trúc tĩnh được mô hình bằng UML chính là các
class diagrams. Đây là sự mô hình các khái niệm trong ứng dụng, các đặc điểm nội tại cũng như
mối quan hệ giữa chúng.
Ví dụ về mô hình class:
Các khái niệm
Mô hình hóa
Classes
Attributes Operations
Object
uc Use Case Model
Use Case Principal
Use Case Extend
«extend»
20. 20
Đây là mô hình mô tả việc chuyển đổi trạng thái của đối tượng trong quá trình tham gia
các hoạt động nghiệp vụ của hệ thống. Trạng thái của đối tượng bị thay đổi bởi một hành vi nào
đó.
Sơ đồ hành động (activity diagrams): Đây là sơ đồ mô tả luồng nghiệp vụ trong hệ thống.
22. 22
III.3 Ứng dụng UML trong quy trình làm phần mềm
Như đã trình bày ở trên, UML chỉ thuần túy là một ngôn ngữ mô hình. Các công ty phần
mềm khác nhau tuy đều ứng dụng UML nhưng có thể sử dụng các quy trình phát triển khác nhau.
23. 23
Sơ đồ trên cho thấy một trình tự sử dụng các mô hình UML để xây dựng một ứng dụng.
Xuất phát từ ý tưởng ban đầu thuần túy mang tính nghiệp vụ, các bước tiếp theo cần làm song
song là xây dựng mô hình use-case và vẽ phác thảo giao diện chương trình. Tiếp theo xây dựng
mô hình sequence system vì thông qua giao diện ta đã biết user tương tác với system như thế nào.
Sau đó xây dựng mô hình class ở mức phác thảo, sơ đồ trạng thái và sơ đồ hành động. Đến đây ta
đã biết user tương tác với cụ thể đối tượng nào của system và các thông điệp giữa các đối tượng
từ mô hình class. Đây là cơ sở để xây dựng sequence detail và hoàn chỉnh mô hình class với các
quan hệ đầy đủ.
Theo quan điểm về phân tích thiết kế bằng UML thì việc lập trình rõ ràng không chỉ bắt
đầu khi cài đặt các class và các sequence detail bằng một ngôn ngữ lập trình mà thực tế chúng ta
đã lập trình ngay từ khi xây dựng mô hình use-case và viết text detail cho nó. Như vậy việc lập
trình cài đặt chỉ được tiến hành sau khi cac mô hình đã hoàn tất. Trong quá trình xây dựng các
mô hình cần liên tục tiếp xúc với khách hàng để đảm bảo tính chính xác của mô hình. Một khi
các mô hình và tài liệu đặc tả đã hoàn chỉnh, việc coding thực sự chỉ chiếm khoảng 20% tổng số
thời gian.
Sau đây là một số công cụ giúp sử dụng UML trong phát triển hệ thống phần mềm:
IV. Quy trình Rational Unified Process (RUP) phát triển phần mềm dựa trên UML
IV.1. Giới thiệu về RUP
Trong số các quy trình hiện nay, RUP được phát triển bởi công ty Rational Software được
sử dụng khá phổ biến.
Lịch sử: RUP là sự phối hợp giữa cách tiếp cận công nghệ hướng đối tượng của Rational
trong những năm 1980s và 1990s với công nghệ xử lý đối tượng của Ival Jarcobson.
Phiên bản mới nhất của RUP là version 7.0 phát hành 2005.
Động cơ phát triển RUP là tìm ra nguyên nhân của các lỗi phần mềm và tìm cách khắc
phục chúng thông qua một quy trình.
IV.2. Các nguyên tắc chính của RUP:
1- Tuân thủ tiến trình (Adapt the process)
2- Cân bằng các ưu tiên của stakeholder (Balance stackeholder priorities). Stakeholder là
những người đưa ra những ý kiến có ảnh hưởng lớn tới tư tưởng thiết kế hệ thống.
3- Cộng tác giữa các nhóm (Collaborate across teams)
24. 24
4- Thể hiện kết quả theo quy trình lặp (Demonstrate value iteratively). Kết thúc mỗi quy
trình cần theo dõi kết quả và kiểm tra chặt chẽ.
5- Nâng cao mức độ trừu tượng (Elevate the level of abstraction)
6- Tập trung theo dõi chất lượng liên tục (Focus continuously on quality)
IV.3. Vòng đời của phần mềm theo quy trình RUP
Trong một vòng đời của phần mềm, có 4 pha: Inception, Elaboration, Construction và
Transition.
Biểu đồ trên cho biết trình tự các pha và lượng tài nguyên sử dụng cho mỗi pha.
Inception: Đây là giai đoạn chuẩn bị, tiếp xúc với khách hàng để nắm bắt ý tưởng
và thu thập yêu cầu, chuẩn bị nhân lực, vật tư kỹ thuật.
Elaboration: Sau khi đã thu thập được yêu cầu thì đây là pha thiết kế phác thảo sử
dụng các sơ đồ UML để mô hình hóa các yêu cầu, các quy trình nghiệp vụ của
ứng dụng,…
Construction: Pha xây dựng hệ thống yêu cầu sử dụng nhiều nhân lực, tài nguyên
của công ty. Các công việc như thiết kế chi tiết, cài đặt, kiểm thử,…đều được tiến
hành trong pha này.
Transition: Pha chuyển giao cho khách hàng.
Một biểu đồ khác chi tiết hơn cho ta thấy các các giai đoạn phát triển được tiến hành khi
nào và mức độ sử dụng tài nguyên của chúng trong các pha theo các nguyên tắc chung.
25. 25
Các giai đoạn công việc của RUP bao gồm:
Mô hình hóa nghiệp vụ (business modeling): mô tả cấu trúc và quy trình nghiệp
vụ.
Xác định yêu cầu (requirement): mô tả nghiệp vụ bằng phương pháp “tình huống
sử dụng” (use case base method)
Phân tích và thiết kế (analysis & design): mô tả kiến trúc hệ thống thông qua các
sơ đồ phân tích thiết kế.
Lập trình (Implement): thực hiện các việc xây dựng chương trình bằng ngôn ngữ
lập trình.
Thử nghiệm (Test): mô tả các tình huống và kịch bản thử nghiệm, tiến hành thử
nghiệm hệ thống phần mềm.
Triển khai (Deployment): đưa hệ thống phần mềm vào sử dụng.
Quản trị cấu hình và quản trị thay đổi (Configuration & Change Management):
kiểm soát các thay đổi và duy trì sự hợp nhất của các thành phần dự án.
Quản trị dự án: quản lý toàn bộ quá trình làm việc của dự án.
Đảm bảo môi trường: đảm bảo các hạ tầng cần thiết để có thể phát triển được hệ
thống.
IV.4. Các công cụ của RUP
Để áp dụng được quy trình phát triển hệ thống phần mềm của Rational thì yêu cầu không
thể thiếu là hệ thống các phần mềm công cụ hỗ trợ. Hãng Rational đã xây dựng một hệ thống
công cụ như vậy, mà tiêu biểu và thường dùng nhất là:
Phần mềm Rational Requisite Pro: cho phép phân tích các yêu cầu, xây dựng kế
hoạch thực hiện, xác định các tác nhân của hệ thống cùng những tình huống sử
dụng.
26. 26
Phần mềm Rational Rose: cho phép xây dựng các mô hình phân tích, thiết kế, triển
khai.
Phần mềm Rational XDE: cho phép vừa xây dựng các mô hình vừa kết sinh mà
nguồn chương trình song song với nhau.
Phần mềm Rational Clear Case: quản trị dự án phân tích thiết kế, cho phép làm
việc theo nhóm.
Bài tập
1. Xây dựng mô hình use-case cho hệ thống quản lý việc mượn và trả sách tại thư viện.
Hãy tiết text detail và xây dựng mô hình sequence system cho các use-case : “Mượn sách” và
“Trả sách”.
2. Hãy mô tả một quy trình ứng dụng UML trong phát triển hệ thống phần mềm.
