Bài giảng ngôn ngữ lập trình Java

Chia sẻ: Duong Thua Tuong | Ngày: | Loại File: DOC | Số trang:151

Thêm vào BST

Báo xấu

305
lượt xem 125
download

Download Vui lòng tải xuống để xem tài liệu đầy đủ

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.

Chủ đề:

Bình luận(0) Đăng nhập để gửi bình luận!

Lưu

Nội dung Text: Bài giảng ngôn ngữ lập trình Java

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...................................................................................................................8 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 ..........................................................................................................................10 Đề tài 1. Ngôn ngữ mô hình hóa UML......................................................................................... 13 I. Xây dựng hệ thống phần mềm theo hướng đối tượng........................................................13 I.1 Các khái niệm căn bản của công nghệ hướng đối tượng.............................................. 13 I.2 Quy trình chung phát triển hệ thống phần mềm.............................................................14 I.3 Những thách thức của ngành công nghiệp phần mềm hiện nay....................................14 II. Lịch sử phát triển ngôn ngữ mô hình hóa UML...................................................................14 II.1. Tóm tắt lịch sử UML..................................................................................................... 14 II.2. Khái niệm về UML........................................................................................................15 II.3 Đặc trưng của UML........................................................................................................15 III. Ngôn ngữ UML....................................................................................................................16 III.1. Các thành phần của UML.............................................................................................16 III.2. Các hướng nhìn (view)..................................................................................................17 III.3 Ứng dụng UML trong quy trình làm phần mềm.......................................................... 24 IV. Quy trình Rational Unified Process (RUP) phát triển phần mềm dựa trên UML..............26 IV.1. Giới thiệu về RUP........................................................................................................26 IV.2. Các nguyên tắc chính của RUP:...................................................................................26 IV.3. Vòng đời của phần mềm theo quy trình RUP.............................................................26 IV.4. Các công cụ của RUP...................................................................................................28 Bài tập........................................................................................................................................28 Đề tài 2. Nhập môn Java...............................................................................................................29 I. Viết và thực hiện một chương trình Java ............................................................................ 29 I.1 Tìm hiểu mã nguồn một chương trình đơn giản............................................................ 29 I.2. Thực hiện chương trình Java.......................................................................................... 29 I.3. Một số chú ý khi lập trình Java.......................................................................................30 1
I.4. Cấu trúc một chương trình Java..................................................................................... 30 II. Các kiểu dữ liệu trong Java..................................................................................................31 II.1 Các kiểu dữ liệu số nguyên............................................................................................31 II.2 Các kiểu số thực............................................................................................................. 32 II.3 Kiểu ký tự (character).....................................................................................................32 II.4 Kiểu logic (boolean)........................................................................................................32 II.5 Kiểu chuỗi.......................................................................................................................32 II.6 Chuyển đổi giữa các kiểu số..........................................................................................32 III. Khai báo biến và hằng trong Java.......................................................................................33 III.1 Quy tắc đặt tên biến......................................................................................................33 III.2 Khai báo biến................................................................................................................. 33 III.3 Biến kiểu mảng.............................................................................................................34 III.4 Hằng số (literal).............................................................................................................35 III.5 Phạm vi hoạt động của hằng và biến:......................................................................... 36 IV. Các toán tử và biểu thức..................................................................................................... 36 IV.1 Các toán tử và thứ tự ưu tiên.........................................................................................36 IV.2 Biểu thức....................................................................................................................... 37 V. Các lệnh điều khiển rẽ nhánh..............................................................................................38 V.1 Lệnh if.............................................................................................................................38 V.2. Lệnh switch …case........................................................................................................ 38 VI. Các lệnh lặp.........................................................................................................................39 VI.1. Vòng lặp for..................................................................................................................39 VI.2. Vòng lặp while..............................................................................................................40 VI.3. Vòng lặp do... while......................................................................................................41 VI.4. Phép nhảy......................................................................................................................41 VII. Vào dữ liệu từ bàn phím và xuất dữ liệu ra màn hình..................................................... 42 VII.1. Lấy giá trị nhập vào từ bàn phím............................................................................... 42 VII.2 Kết xuất dữ liệu ra màn hình..................................................................................... 43 Bài tập........................................................................................................................................44 Đề tài 3. Lập trình hướng đối tượng trong Java.......................................................................... 46 I. Khái niệm lập trình hướng đối tượng (Object-Oriented Programming - OOP)...................46 I.1. Khái niệm OOP............................................................................................................... 46 I.2 Cơ sở lý luận của OOP....................................................................................................46 I.3 Trừu tượng hóa.................................................................................................................46 II. Tính đóng gói trong Java....................................................................................................... 48 II.1 Khái niệm tính đóng gói..................................................................................................48 II.2 Mối quan hệ giữa các class.............................................................................................48 II.3 Một số gợi ý khi thiết kế class.......................................................................................48 IV. Sử dụng các Class xây dựng sẵn trong thư viện................................................................49 V. Xây dựng Class trong Java....................................................................................................50 V.1 Cấu trúc của class...........................................................................................................50 V.2 Các thuộc tính thành phần:............................................................................................. 51 V.3 Các phương thức thành phần......................................................................................... 52 V.4 Gọi và truyền tham số cho phương thức.......................................................................53 V.6 Các hàm và phương thức đặc biệt................................................................................. 53 V.7 Khai báo chồng các phương thức...................................................................................54 V.8 Lớp lồng nhau – lớp nội.................................................................................................55 2
VI. Tính kế thừa trong Java.......................................................................................................56 VI.1 Sự kế thừa các thuộc tính và phương thức.................................................................. 56 VI.2 Sự kế thừa đối với các constructor...............................................................................59 VII. Tính đa hình trong Java.......................................................................................................60 VII.1 Sự ép kiểu và gán tham chiếu đối tượng....................................................................60 VII.2 Sự ràng buộc động –Dynamic Binding .......................................................................61 VIII. Lớp Object.........................................................................................................................62 IX. Giao diện..............................................................................................................................62 IX.1 Cấu trúc của giao diện..................................................................................................62 IX.2 Các tính chất của giao diện...........................................................................................64 X. Package..................................................................................................................................64 X.1 Sử dụng các package trong thư viện Java......................................................................64 X.2 Đặt lớp vào package....................................................................................................... 65 Bài tập........................................................................................................................................65 Đề tài 4. Lớp và phương thức trừu tượng....................................................................................67 I. Khái niệm lớp trừu tượng......................................................................................................67 II. Cài đặt lớp và phương thức trừu tượng trong Java.............................................................67 Bài tập........................................................................................................................................68 Đề tài 5. Lưu trữ và xử lý đối tượng............................................................................................69 I. Lớp Vector và giao diện Enumeration...................................................................................69 I.1 Lớp Vector........................................................................................................................69 I.2 Giao diện Enumeration.....................................................................................................70 II. Mảng trong Java và lớp ArrayList........................................................................................72 II.1 Mảng trong Java..............................................................................................................72 II.2. Các thuật toán cơ bản trên mảng.................................................................................. 73 II.3 Class Arrays.....................................................................................................................74 III Danh sách trong java và giao diện Lists ..............................................................................76 Bài tập........................................................................................................................................77 Đề tài 6. Các luồng vào ra dữ liệu với file...................................................................................78 I. Khái niệm luồng vào ra (I/O stream).....................................................................................78 II. Lớp InputStream:...................................................................................................................79 III. Lớp OutputStream................................................................................................................80 IV. Lớp FileInputStream............................................................................................................80 V. Lớp FileOutputStream...........................................................................................................80 VI. Lớp File................................................................................................................................80 VII. Nhập xuất lọc ................................................................................................................... 82 VII.1 Lớp FilterInputStream: ................................................................................................ 82 VII.2 Lớp FilterOutputStream................................................................................................82 VIII. Vào/ra có sử dụng bộ đệm ..............................................................................................82 VIII.1 Lớp BufferedInputStream:.......................................................................................... 82 VIII.2 Lớp BufferedOutputStream.........................................................................................82 IX. Lớp RandomAccessFile ......................................................................................................85 X. Đối tượng System.in.............................................................................................................85 XI. Truy cập file ở chế độ tuần tự...........................................................................................85 XII. Truy cập file nhị phân........................................................................................................ 89 Bài tập .......................................................................................................................................90 Đề tài 7. Xử lý ngoại lệ................................................................................................................ 91 3
I. Các tình huống sử dụng ngoại lệ.......................................................................................... 91 II. Cơ sở quản lý ngoại lệ trong Java.......................................................................................91 III. Cấu trúc cây kế thừa các xử lý ngoại lệ............................................................................92 IV. Sử dụng ngoại lệ được kiểm soát......................................................................................93 V. Xây dựng một ngoại lệ........................................................................................................94 VI. Bài tập..................................................................................................................................95 Đề tài 8. Xử lý các sự kiện trong Java..........................................................................................96 I. Khái niệm và cơ sở xử lý sự kiện.........................................................................................96 II. Truy cập thông tin sự kiện................................................................................................. 102 III. Xử lý các sự kiện trên window......................................................................................... 103 IV. Các lớp thích nghi..............................................................................................................104 V. Xử lý các sự kiện chuột..................................................................................................106 Bài tập......................................................................................................................................107 Đề tài 9. Applet............................................................................................................................108 I. Xây dựng một Applet đơn giản...........................................................................................108 II. Cấu trúc cơ bản và vòng đời của một Applet................................................................... 108 III. An ninh và khả năng của Applet....................................................................................... 110 IV. Ứng dụng Applet với của sổ Popup................................................................................. 110 V. Các thẻ HTML của Applet................................................................................................. 111 VI. Các phương thức, lập trình đồ họa và bắt sự kiện của applet........................................112 Đề tài 10. Lập trình giao diện đồ họa GUI................................................................................114 I. Giới thiệu AWT .................................................................................................................. 114 II. Vật chứa (Container).......................................................................................................... 115 II.1 JFrame............................................................................................................................115 II.2 JPanel............................................................................................................................. 115 II.3 JDialog...........................................................................................................................116 II.4 JScrollPane.....................................................................................................................118 III. Giới thiệu về các thành phần GUI cơ bản.......................................................................118 III.1 Nút nhấn ......................................................................................................................118 III.2 Nhãn (Label).................................................................................................................118 III.3 Nút đánh dấu (checkbox).............................................................................................120 III.4 Nút chọn (radio button)................................................................................................122 III.5 Hộp thoại Combo ....................................................................................................... 122 III.6 Danh sách (Lists)..........................................................................................................123 III.7 Ô văn bản (text field) và vùng văn bản (text areas).................................................... 125 III.8 Thanh trượt (Scrollbar)................................................................................................ 128 IV. Thành phần Menu..............................................................................................................129 V. Bộ quản lý cách trình bày (Layout Manager).....................................................................132 V.1 Cách trình bày FlowLayout:.......................................................................................... 133 V.2 Cách trình bày GridLayout:...........................................................................................133 V.3 Cách trình bày BorderLayout........................................................................................ 133 VI. Các hộp thoại.....................................................................................................................133 VI.1 Hộp thoại thông báo.................................................................................................... 133 VI.2 Hộp thoại chọn File.....................................................................................................134 VI.3 Hộp thoại chọn màu....................................................................................................135 Bài tập......................................................................................................................................135 Đề tài 11. Threading.................................................................................................................... 137 4
I. Khái niệm thread.................................................................................................................. 137 I.1 Khái niệm:...................................................................................................................... 137 I.2. Lớp Thread.....................................................................................................................137 I.3 Các bước để tạo một thread.......................................................................................... 138 II. Các trạng thái của thread....................................................................................................138 III. Các thuộc tính của thread..................................................................................................139 III.1 Độ ưu tiên của thread.................................................................................................. 139 III.2 Nhóm thread................................................................................................................. 140 III.3 Quản lý các ngoại lệ của thread................................................................................. 140 IV. Điều khiển các thread........................................................................................................141 IV.1 Interrupt một thread..................................................................................................... 141 IV.2 Dừng một thread..........................................................................................................142 IV.3 Tạm dừng và phục hồi một thread.............................................................................143 IV.4 Giải phóng thời gian cho CPU.................................................................................... 143 IV.5 Đợi một thread kết thúc công việc............................................................................. 143 V. Đồng bộ thread................................................................................................................... 144 V.1 Tình trạng “đua tranh”.................................................................................................. 144 V.2 Khóa đối tượng.............................................................................................................145 V.3 Đối tượng điều kiện.....................................................................................................146 Bài tập......................................................................................................................................148 Phụ lục A. Các từ khóa của Java................................................................................................ 149 Phụ lục B Một số hàm hay sử dụng...........................................................................................150 Tài liệu tham khảo.......................................................................................................................151 5
Đề 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: 6
Phiên Số các Class và Interface bản 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 7
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. 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. IBM Trình thông Bytecode dịch Sparc Java Trình biên (Java dịch Interpreter) Macintosh 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 8
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. 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/). 9
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 Files\Java\jdk1.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: Chứa các công cụ và trình biên dịch Java bin Chứa các chương trình Java Demo demo Chứa các tài liệu mô tả thư viện của Java docs 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). Chứa các file lưu thông tin môi trường lúc thực thi jre Chứa các file thư viện lib Chứa mã nguồn java src 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 10
3. Chọn Tab Advanced 4. Chọn Environment Variables 5. Thêm đường dẫn C:\Program Files\Java\jdk1.6.0_02\bin vào biến môi trường Path - Chọn Variable Path 11
- Chọn Edit 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
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 ả 14
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 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. 15
• 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. 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. 16
• 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. ud Primary Use Cases HÖthèng b¸n qua m Interrnet hµng ¹ng Chän hµng Xem chi tiÕt s¶n phÈm CËp nhËt giá Kh¸ch hµng µng h Göi th«ng in ph¶n håi t § ¨ng ký LËp ® n m ua ¬ hµng kh¸ch hµng Qu¶n lý danh m ôc hµng hãa Qu¶n trÞhÖ thèng Tr¶ lêi kh¸chhµng CËp nhËt th«ng tin m t hµng Æ Nh© viªn dâi Theo n kinh ® n hµng ¬ doanh Các nguyên tắc cho việc xây dựng use-case view là: • Các use-case đượ hình trên ơ sở nhìn từ ngoài vào tronghệth ống c thành c bên (out-> in). • Các use-case ph i đầ đủ, chúng ược tổng h p theo ph ươngpháp đi từt ốiđa ả y đ ợ đến tối thiểu (ban đầu mở rộng tối đa các use-case có th ể sau đó thu h ẹp l ại theo nhucầu kháchhàng). • Các use-case cần có tính độc lập tương đối để dễ tổ chức nhóm làm vi ệc và có tính táisử ụngcao. d Bên cạnh sơ đồ, người làm mô hình có thể sử dụng mô tả b ằng văn bản chi ti ết cho mỗi use-case (text detail). Mỗimôtả cầnđ m ảo các thông sau: ả b tin 17
1. Tên use-case 2. Mục tiêu của use-case 3. Phạm vi của use-case 4. Các tác nhân chính 5. Tiền điều kiện 6. Dòng chính 7. Dòng phụ 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 18
uc Use Case Model Use Case Include «include» Use Case Principal • 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 «extend» Use Case Extend 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. 19
Classes Các khái niệm Mô hình hóa Attributes Operations Object Ví dụ về mô hình class: cd Jav a M odel StockItem LineItem Order A uthor: string - - quantity: int - date: Date - catalogNumber: string deliveryInstructions: String - property get -i costPrice: number tem - - orderNumber: String - listPrice: number + getItem() : StockItem «enumeration» t string - itle: + g int etQuantity() : checkForOutstandingOrders() :void + OrderStatus property set property get property get + s : void etItem(StockItem) enum getDate() : Date + getAuthor() : + string + setQuantity(int) : void -status - closed: int + getDeliveryInstructions() : String + getCatalogNumber() : string - delivered: int - dispatched: int getLineItem() :LineItem + getCostPrice(): number + + getOrderNumber() : String + getListPrice() : number - new: int + getStatus() : OrderStatus + getTitle() : string - packed: int set property property set + setDate(Date) : void + setAuthor(string) : void setDeliveryInstructions(String) :void + setCatalogNumber(string) :void + + setLineItem(LineItem) : void + setCostPrice(number) : void setOrderNumber(String) void + : setListPrice(number): + void + setStatus(OrderStatus) : void + setTitle(string) : void -account Account ShoppingBasket Transaction - billingAddress: String - shoppingBasketNumber: String - date: Date - c losed: boolean - d String eliveryAddress: a : - orderNumber: String + ddLineItem() void + createNewBasket() : void - emailAddress: String -basket + loadAccountHistory() : void + d : eleteItem() void - n + loadOpenOrders() :void ame: String + processOrder() : void property get + c reateNewAccount() : void property get + loadAccountDetails() void : + getAccount() Account : + getLineItem() : LineItem + getDate() : Date + markAccountClosed() : void property set s : + getLineItem(): LineItem + retrieveAccountDetails() :void + etLineItem(LineItem) void + getOrderNumber() : String + s ubmitNewAccountDetails() : void property set + v String) alidateUser(String, + setAccount(Account) : void property get -hi story -account + setDate(Date) : void + getBasket() : ShoppingBasket + s : etLineItem(LineItem) void + getBillingAddress() : String + setOrderNumber(String) : void + getClosed() : boolean + getDeliveryAddress(): String + getEmailAddress() : String + getName() String : + getOrder() : Order property set + s etBasket(ShoppingBasket) : void + s etBillingAddress(String) : void + s : etClosed(boolean) void + s etDeliveryAddress(String) : void + s void etEmailAddress(String) : + s etName(String) : void + s :void etOrder(Order) Các hành vi động: State machine: 20