Bài giảng môn Lập trình hướng đối tượng | Trường Đại học Duy Tân

TRƯỜNG ĐẠI HỌC DUY TÂN
KHOA CÔNG NGHỆ THÔNG TIN TẬP BÀI GIẢNG
Môn học: LẬP TRÌNH HƯỚNG ĐỐI TƯỢNG Mã môn học: CS 311 Số tín chỉ: 04 Lý thuyết: 03 Thực hành: 01
Dành cho sinh viên ngành: công nghệ phần mềm, mạng máy tính, cao đẳng tin
Khoa: Công nghệ thông tin
Bậc đào tạo: Đại học – Cao đẳng Học kỳ: Năm học:
Đà Nẵng, tháng 11 năm 2011 LỜI NÓI ĐẦU
Lập trình theo phương pháp hướng đối tượng là một phương pháp lập trình tương
đối mớivà được hầu hết các ngôn ngữ lập trình hiện nay hỗ trợ. Lập trình hướng đối tượng
được xây dựng dựa trên các khái niệm hoàn toàn khác với lập trình theo hướng thủ tục.
Giáo trình này giới thiệu các đặc trưng của một ngôn ngữ lập trình hướng đối tượng như
tính thừa kế, tính đóng gói, tính đa hình.
Tập bài giảng chọn ngôn ngữ Java để minh họa cho các khái niệm, đặc trưng của
lập trình hướng đối tượng. Sau khi hoàn tất học phần này sinh viên sẽ biết được cách mô
hình hóa các lớp trong thế giới thực thành các lớp trong ngôn ngữ Java, phối hợp giữa các
đối tượng thuộc các lớp khác nhau để giải quyết bài toàn đặt ra.
Tập bài giảng này giới thiệu về lập trình hướng đối tượng sử dụng ngôn ngữ lập
trình Java để minh họa. Nội dung chính được trình bày trong 6 chương:
Chương 1: Trình bày tổng quan về ngôn ngữ lập trình Java, cách viết và thực thi
một chương trình Java đơn giản, giới thiệu về miền ứng dụng có thể sử dụng Java.
Chương 2: Trình bày về Lập trình hướng đối tượng với Java. Chương này trình bày
các khái niệm, các tính chất, đặc điểm đặc trưng của ngôn ngữ lập trình hướng đối tượng.
Cách thức cài đặt các khái niệm, tính chất, đặc điểm đặc trưng đó trên Java.
Chương 3: Trình bày về Lập trình giao diện đồ họa. Giao diện đồ họa có tầm quan
trọng to lớn trong các ứng dụng. Giao diện giúp người sử dụng nhanh chóng nắm bắt các
chức năng của hệ thống, đạt hiệu suất cao hơn trong công việc,..
Chương 4: Trình bày về ứng dụng ký sinh trên web – applet, applet là một chương
trình Java có thể thực thi trên trình duyệt hỗ trợ ngôn ngữ Java.
Chương 5: Trình bày về kỹ thuật lập trình tuyến đoạn.
Chương 6: Trình bày về các cấu trúc lưu trữ cơ bản trong Java.
Mặc dù rất cố gắng nhưng tập bài giảng này chắc chắn không tránh khỏi những sai
sót. Rất mong nhận được các ý kiến đóng góp từ quý thầy cô, cũng như các bạn sinh viên. Chân thành cảm ơn !
PHÂN BỔ THỜI GIAN GIẢNG DẠY GIỜ THỨ NỘI DUNG TRANG 1 – 6
CHƯƠNG 1: CƠ BẢN VỀ JAVA 9 – 49 7 – 24
CHƯƠNG 2: LẬP TRÌNH HƯỚNG ĐỐI TƯỢNG VỚI JAVA 50 – 85 25 – 36
CHƯƠNG 3: LẬP TRÌNH GIAO DIỆN ĐỒ HỌA 86 – 119 37 – 39
CHƯƠNG 4: ỨNG DỤNG KÝ SINH TRÊN WEB – APPLET 120 – 141 40 – 42
CHƯƠNG 5: KỸ THUẬT LẬP TRÌNH TUYẾN ĐOẠN 142 – 149 43 – 46
CHƯƠNG 6: CẤU TRÚC LƯU TRỮ DỮ LIỆU 150 – 161 MỤC LỤC
LỜI NÓI ĐẦU...................................................................................................................2
PHÂN BỔ THỜI GIAN GIẢNG DẠY..............................................................................3
MỤC LỤC.........................................................................................................................4
CHƯƠNG 1: CƠ BẢN VỀ JAVA.....................................................................................9
1.1 Tổng quan về Java........................................................................................................9
1.1.1 Giới thiệu Java, các môi trường soạn thảo và biên dịch Java................................9
1.1.2 Các ứng dụng với Java........................................................................................14
1.1.3 Soạn thảo và thực hiện ứng dụng Java đơn giản..................................................16
1.2 Lập trình cơ bản với Java...........................................................................................18
1.2.1 Các thành phần cơ bản của ngôn ngữ Java..........................................................18
1.2.2 Kiểu dữ liệu, biến, hằng......................................................................................22
1.2.3 Phép toán và biểu thức........................................................................................26
1.2.4 Cấu trúc điều khiển.............................................................................................29
1.2.5 Ngoại lệ và lệnh bắt ngoại lệ...............................................................................38
1.2.6 Nhập dữ liệu từ bàn phím....................................................................................41
a. Sử dụng lớp InputStreamReader, BufferedReader................................................41
b.Sử dụng lớp Scanner.............................................................................................42
1.2.7 Đọc dữ liệu từ tập tin văn bản.............................................................................43
a.Sử dụng lớp FileReader.........................................................................................43
b.Sử dụng lớp Scanner.............................................................................................43
1.2.8 Mảng...................................................................................................................44
CHƯƠNG 2: LẬP TRÌNH HƯỚNG ĐỐI TƯỢNG VỚI JAVA.....................................50
2.1 Khái niệm lập trình hướng đối tượng.........................................................................50
2.1.1 Lập trình hướng đối tượng OOP (Object Oriented Programming)......................50
2.1.2 Trừu tượng hóa (Abstraction)..............................................................................52
2.1.3 Cơ chế triển khai mô hình hướng đối tượng........................................................53
a. Tính đóng gói (Encapsulation).............................................................................53
Lớp (Class)...............................................................................................................53
Gói (Package)..........................................................................................................53
Đối tượng (Object)...................................................................................................54
Thuộc tính (Attribute)...............................................................................................54
Phương thức (Method).............................................................................................54
Thông điệp (Message)..............................................................................................54
Sự kiện (Event).........................................................................................................54
b.Tính kế thừa (Inheritance).....................................................................................54
c.Tính đa hình (Polymorphism)................................................................................55
2.2 Lớp và đối tượng........................................................................................................56
2.2.1 Xây dựng lớp.......................................................................................................56
2.2.2 Tạo đối tượng......................................................................................................58
2.2.3 Truy xuất thành phần lớp....................................................................................58
2.3 Phương thức...............................................................................................................59
2.3.1 Khai báo phương thức.........................................................................................59
2.3.2 Phạm vi truy xuất thành phần lớp........................................................................60
2.3.3 Phương thức main().............................................................................................60
2.3.4 Phương thức khởi tạo..........................................................................................61
2.3.5 Phương thức hủy.................................................................................................62
2.3.6 Từ khóa this.........................................................................................................63
2.3.7 Nạp chồng phương thức......................................................................................63
2.3.8 Truyền tham đối cho phương thức......................................................................64
2.4 Lớp kế thừa................................................................................................................65
2.4.1 Khai báo..............................................................................................................65
2.4.2 Viết chồng phương thức......................................................................................65
2.4.3 Từ khóa super......................................................................................................65
2.5 Gói.............................................................................................................................66
2.5.1 Định nghĩa...........................................................................................................66
2.5.2 Sử dụng gói.........................................................................................................67
2.6 Lớp, phương thức trừu tượng.....................................................................................67
2.7 Lớp, phương thức hằng..............................................................................................69
2.7.1 Sử dụng từ khóa final cấm viết chồng.................................................................69
2.7.2 Sử dụng từ khóa final cấm sự kế thừa.................................................................69
2.8 Lớp lồng nhau............................................................................................................69
2.9 Giao diện....................................................................................................................73
2.9.1 Định nghĩa giao diện...........................................................................................73
2.9.2 Hiện thực giao diện.............................................................................................74
2.9.3 Kế thừa giao diện................................................................................................76
2.9.4 Biến trong giao diện............................................................................................76
2.10 Chuyển đổi kiểu.......................................................................................................76
2.10.1 Chuyển đổi giữa các kiểu cơ bản.......................................................................76
2.10.2 Chuyển đổi giữa các kiểu tham chiếu................................................................77
2.10.3 Chuyển đổi kiểu cơ bản thành kiểu tham chiếu.................................................77
LỚP STRING VÀ NUMBER..........................................................................................78
Lớp String và StringBuffer...............................................................................................78
Các lớp Number...............................................................................................................80
Định dạng số....................................................................................................................82
CHƯƠNG 3: LẬP TRÌNH GIAO DIỆN ĐỒ HỌA.........................................................86
3.1Giới thiệu thư viện lập trình giao diện đồ họa.............................................................86
3.1.1 Package java.awt (Abstract Windowing Toolkit)................................................86
3.1.2 Package javax.swing...........................................................................................86
3.2 Các lớp tương tác với người dùng..............................................................................87
3.2.1 JFrame.................................................................................................................87
3.2.2 JComponent và Component................................................................................89
3.2.3 JLabel..................................................................................................................90
3.2.4 JTextField............................................................................................................91
3.2.5 JTextArea............................................................................................................92
3.2.6 AbstractButton....................................................................................................93
3.2.7 JButton................................................................................................................95
3.2.8 JCheckBox..........................................................................................................95
3.2.9 JRadioButton.......................................................................................................96
3.2.10 ButtonGroup......................................................................................................97
3.2.11 Tạo trình đơn.....................................................................................................98
3.2.12 JComboBox.......................................................................................................98
3.2.13 JList.................................................................................................................100
3.2.14 JPanel..............................................................................................................102
3.2.15 JToolBar..........................................................................................................103
3.2.16 Tạo hộp thoại...................................................................................................104
3.2.17 JTable..............................................................................................................105
3.3 Xử lý sự kiện trên các đối tượng cửa sổ...................................................................106
3.3.1 Hiện thực giao diện ActionListener...................................................................106
3.3.2 Hiện thực giao diện ItemListener......................................................................111
3.3.3 Kế thừa lớp WindowAdapter.............................................................................113
3.3.4 Kế thừa lớp KeyAdapter và xử lý sự kiện bàn phím..........................................114
3.3.5 Kế thừa lớp MouseAdapter và xử lý sự kiện Mouse.........................................115
3.3.6 Kế thừa lớp MouseMotionListener xử lý các sự kiện di chuyển Mouse............116 3.4
Giới thiệu các môi trường phát triển ứng dụng giao diện đồ họa với Java...........117
CHƯƠNG 4: ỨNG DỤNG KÝ SINH TRÊN WEB - APPLET....................................120 4.1
Khái niệm Applet.................................................................................................120 4.2
Tạo và thực hiện Appet........................................................................................120
4.2.1 Cấu trúc một Applet..........................................................................................120
4.2.2 Nhúng Applet vào trang web.............................................................................122
4.2.3 Các giới hạn bảo mật trên Applet......................................................................124 4.3
Truyền tham đối cho ứng dụng Applet.................................................................125
4.3.1 Tạo Applet có truyền tham đối..........................................................................125
4.3.2 Nhúng Applet có truyền tham đối vào trang web..............................................126 4.4
Lớp Graphics........................................................................................................126
4.4.1 Vẽ các chuỗi, ký tự và các byte.........................................................................126
4.4.2 Vẽ đường thẳng (Line) và hình Oval.................................................................128
4.4.3 Vẽ hình chữ nhật (Rectangle) và hình chữ nhật bo góc (RoundedRectangle)...128
4.4.4 Vẽ hình chữ nhật 3D và vẽ hình cung (Arc)......................................................129
4.4.5 Vẽ hình PolyLine..............................................................................................130
4.4.6 Vẽ và tô đa giác (Polygon)................................................................................131
4.4.7 Điều khiển màu.................................................................................................133
4.4.8 Điều khiển phông chữ.......................................................................................134
4.4.9 Lớp FontMetrics................................................................................................134
4.4.10 Chọn chế độ vẽ................................................................................................137
CHƯƠNG 5: KỸ THUẬT LẬP TRÌNH TUYẾN ĐOẠN.............................................142 5.1
Khái niệm tuyến đoạn..........................................................................................142 5.2
Tạo tuyến đoạn bằng cách kế thừa lớp Thread.....................................................145 5.3
Tạo tuyến đoạn bằng cách cài đặt giao diện Runnable.........................................146 5.4
Đồng bộ tuyến đoạn.............................................................................................147
CHƯƠNG 6: CẤU TRÚC LƯU TRỮ DỮ LIỆU..........................................................150 6.1
Vector...................................................................................................................150 6.2
Hashtable.............................................................................................................151 6.3
Enumeration.........................................................................................................153 6.4
Properties.............................................................................................................154 6.5
ArrayList..............................................................................................................154 6.6
HashSet và TreeSet..............................................................................................156 6.7
Stack....................................................................................................................158 6.8
Queue...................................................................................................................158
CHƯƠNG 1: CƠ BẢN VỀ JAVA A. MỤC TIÊU CHƯƠNG 1. VỀ KIẾN THỨC:
Giúp sinh viên nắm và hiểu rõ:
Lịch sử phát triển của ngôn ngữ lập trình Java.
Các đặc trưng của Java.
Các loại ứng dụng có thể triển khai bằng Java.
Cài đặt và triển khai các ứng dụng Java trên IDE.
Lập trình cơ bản trên ngôn ngữ Java:
o Các thành phần cơ bản của Java
o Kiểu dữ liệu, biến, hằng. o Biểu thức, toán tử. o Các câu lệnh.
o Cấu trúc điều khiển và nhập xuất dữ liệu.
o Khái niệm, định nghĩa và truy xuất mảng. 2. VỀ KỸ NĂNG:
Sau khi học xong chương này sinh viên có thể vận dụng những kiến thức được học
để cài đặt các ứng dụng Java đơn giản, nhập xuất dữ liệu từ bàn phím, cài đặt các cấu
trúc điều khiển, vận dụng kiến thức mảng trong các ứng dụng có các thao tác liên quan đến mảng. B.
NỘI DUNG CHƯƠNG HỌC
1.1 Tổng quan về Java
1.1.1 Giới thiệu Java, các môi trường soạn thảo và biên dịch Java
a. Lịch sử phát triển Java
Năm 1991, một nhóm các kỹ sư của Sun Microsystems muốn lập trình để điều khiển
các thiết bị điện tử dân dụng như tivi,đầu video,...Ban đầu, họ định sử dụng C/C++
nhưng trình biên dịch C/C++ lại phụ thuộc vào từng loại CPU. Do đó, họ đã bắt tay vào
xây dựng một ngôn ngữ chạy nhanh, hiệu quả và độc lập với thiết bị. Java khởi đầu tên
là “Oak” – là cây sồi mọc phía sau văn phòng của nhà thiết kế chính ông Jame Gosling.
Sau này ông nhận thấy đã có ngôn ngữ lập trình Oak rồi nên nhóm thiết kế quyết định
đổi tên thành Java. Java là tên của quán cà phê mà nhóm thiết kế Java hay đến đó uống.
Ngôn ngữ lập trình Java được Sun Microsystems giới thiệu vào tháng 6 năm 1995
và nó nhanh chóng trở thành một ngôn ngữ lập trình yêu thích của các lập trình viên
chuyên nghiệp. Java được xây dựng dựa trên nền tảng của ngôn ngữ C/C++ nghĩa là sử
dụng cú pháp của C và đặc trưng hướng đối tượng của C++. Java là ngôn ngữ lập trình
hướng đối tượng, vì vậy không thể sử dụng Java để viết một chương trình theo hướng
chức năng. Java là ngôn ngữ vừa biên dịch vừa thông dịch. Đầu tiên mã nguồn được
biên dịch thành dạng bytecode sử dụng công cụ Javac, sau đó được thực thi trên từng
loại máy nhờ trình thông dịch java. Mục tiêu của các nhà thiết kế Java là cho phép
người lập trình viết chương trình một lần nhưng có thể chạy trên các nền phần cứng khác nhau.
Ngày nay, Java được sử dụng rộng rãi, không chỉ để viết các ứng dụng chạy trên các
máy cục bộ hay trên mạng còn còn để xây dựng các ứng dụng thiết bị di động, PDA,
...Với sự mạnh mẽ của Java đã khiến nó trở nên nổi tiếng vượt mức tưởng tượng của
những nhà thiết kế ra nó.
b. Các đặc trưng của ngôn ngữ Java: Đơn giản :
Những người thiết kế mong muốn phát triển một ngôn ngữ dễ học và quen thuộc
với đa số lập trình viên. Java dựa trên C++ nhưng đã bỏ đi các đặc trưng phức tạp không
cần thiết của C và C++ như: thao tác con trỏ, định nghĩa chồng toán tử, không sử dụng
lệnh goto, không sử dụng file header (.h), cấu trúc struct và union cũng được loại bỏ khỏi Java.
Hướng đối tượng :
Java là ngôn ngữ lập trình hoàn toàn hướng đối tượng:
o Mọi thực thể trong hệ thống đều được xem là đối tượng, là thể hiện của một lớp xác định.
o Tất cả các chương trình đều phải thuộc một class.
o Không thể sử dụng Java để viết một chức năng mà không thuộc bất kỳ một class
nào. Hay nói một cách khác, Java không cho định nghĩa dữ liệu cũng như các
hàm tự do trong chương trình như ở lập trình hướng thủ tục.
Độc lập phần cứng và hệ điều hành :
Mục tiêu chính của các nhà thiết kế Java là độc lập với các nền phần cứng và các hệ
điều hành khác nhau. Đây là khả năng một chương trình được viết một lần nhưng có
thể chạy trên bất kỳ máy nào.
Tính độc lập với phần cứng được hiểu theo nghĩa một chương trình Java nếu được
chạy đúng trên phần cứng của một họ máy nào thì nó cũng sẽ chạy đúng trên các họ
máy khác. Một chương trình chỉ chạy đúng trên một số họ cụ thể được xem là phụ thuộc vào phần cứng.
Tính độc lập với hệ điều hành được hiểu theo nghĩa một chương trình Java có thể
chạy được trên tất cả các hệ điều hành. Một chương trình chỉ chạy được trên một số
loại hệ điều hành nhất định gọi là phụ thuộc vào hệ điều hành.
Một chương trình Java có thể chạy trên hầu hết các hệ nền mà không cần phải thay
đổi gì, điều này đã được những người lập trình đặt cho nó một khẩu hiệu “viết một lần,
chạy mọi nơi”, điều này là không thể có đối với các ngôn ngữ lập trình khác.
Đối với các chương trình viết bằng C hay C++ hoặc một ngôn ngữ nào khác, trình
biên dịch sẽ chuyển tập lệnh thành mã máy, hay lệnh của bộ vi xử lý. Những lệnh này
phụ thuộc vào CPU trên máy của bạn. Nên khi muốn chạy trên CPU khác, chúng ta
phải biên dịch lại chương trình.
Quá trình dịch và thông dịch của Java Mạnh mẽ :
Java là ngôn ngữ yêu cầu chặt chẽ về kiểu dữ liệu, việc ép kiểu tự động bừa bãi của
C, C++ nay được hạn chế trong Java, điều này làm chương trình rõ ràng, ít lỗi hơn. Java
kiểm tra lúc biên dịch và cả trong thời gian thông dịch, vì vậy, Java loại bỏ một số loại
lỗi lập trình nhất định. Java không sử dụng con trỏ và các phép toán con trỏ. Java kiểm
tra tất cả các truy cập đến mảng, chuỗi khi thực thi để đảm bảo các truy cập đó không
vượt ra ngoài giới hạn kích thước.
Trong các môi trường lập trình truyền thống, lập trình viên phải tự mình cấp phát
bộ nhớ. Trước khi kết thúc phải tự giải phóng bộ nhớ đã cấp. Vấn đề nảy sinh khi lập
trình viên quên giải phóng bộ nhớ đã cấp phát trước đó. Trong chương trình Java, lập
trình viên không phải quan tâm tới việc cấp phát bộ nhớ. Quá trình cấp phát, giải phóng
được thực hiện tự động nhờ sử dụng dịch vụ thu gom các đối tượng không còn sử dụng nữa.
Hỗ trợ lập trình đa tuyến :
Đây là tính năng cho phép viết một chương trình có nhiều đoạn mã lệnh được chạy
song song với nhau. Với Java ta có thể viết các chương trình có khả năng chạy song
song một cách dễ dàng, hơn nữa việc đồng bộ tài nguyên dùng chung trong Java cũng
rất đơn giản. Điều này là không thể đối với một số ngôn ngữ lập trình khác như C/C+ +,... Phân tán :
Java hỗ trợ các mô hình tính toán phân tán: client/ server, các thủ tục triệu gọi từ xa RPC,... Hỗ trợ internet :
Mục tiêu quan trọng của các nhà thiết kế java là tạo điều kiện cho các nhà phát triển
ứng dụng có thể viết các chương trình ứng dụng Internet và web một cách dễ dàng, với
Java ta có thể viết các chương trình sử dụng các giao thức TCP, UDP một cách dễ dàng.
Về lập trình web phía máy khách java có công nghệ java applet, về lập trình web có
JSP/ servlet, lập trình phân tán có RMI, CORBA, WebService. Thông dịch :
Các chương trình Java cần được thông dịch trước khi chạy, một chương trình java
được biên dịch thành mã byte code – mã độc lập với hệ nền. Trình thông dịch Java ánh
xạ mã byte code này lên mỗi nền cụ thể, điều này khiến java chậm đi phần nào. Bảo mật :
Java cung cấp môi trường quản lý thực thi chương trình với nhiều mức kiểm soát tính an toàn:
o Dữ liệu và phương thức được đóng gói trong lớp. Chúng chỉ được truy xuất qua
giao diện được cung cấp bởi các lớp.
o Trình biên dịch kiểm soát để bảo đảm mã là an toàn, và tuân theo các nguyên tắc của Java.
o Đảm bảo bởi trình thông dịch. Chúng kiểm tra xem mã bytecode có đảm bảo an
toàn trước khi thực thi hay không.
Kiểm soát việc nạp các lớp vào bộ nhớ để giám sát việc vi phạm giới hạn truy cập
trước khi nạp vào hệ thống.
c. Môi trường soạn thảo và biên dịch Java
Cài đặt bộ công cụ phát triển JDK( Java Development Kit)
Bộ JDK do Sun cung cấp thực hiện dựa trên các lệnh đơn khá đơn giản. Bộ JDK
cung cấp các công cụ và các chương trình sau:
o javac: Chương trình biên dịch mã nguồn thành mã byte
Cú pháp:javac [option] filename.java o java:
Chương trình thông dịch, thực thi các ứng dụng.
Cú pháp:java [option] classname o appletviewer: Chương trình thông dịch
dùng để thực thi các ứng dụng Applet thay vì sử dụng các trình duyệt để thực thi.
Cú pháp:appletviewer [option] url o javadoc: Tạo tài liệu dạng HTML
từ mã nguồn cùng các chú thích bên trong.
Cú pháp:javadoc [option] filename.java o jdb: Trình gỡ rối (java debugger)
cho phép thực hiện từng dòng lệnh, đặt điểm dừng, xem giá trị của biến, ...
Cú pháp:jdb [option] filename.java hay
jdb – host – password [option] filename.java
o javap: Trình dịch ngược Assembler. Hiển thị các phương thức, dữ liệu truy nhập
được bên trong tập tin .class đã được dịch và hiển thị nghĩa của bytecode. Cú
pháp:javap [option] classname
Để tiến hành cài đặt JDK trước hết chúng ta cần download bộ JDK phiên bản mới nhất tại địa chỉ sau:
http://www.oracle.com/technetwork/java/javase/downloads/index.html Sau khi
download về máy, tiến hành cài đặt JDK vào máy của bạn. Cài đặt IDE
Hiện nay, có nhiều môi trường hỗ trợ để phát triển phần mềm với Java như: JBuilder,
EditPlus, Eclipse, NetBean, ...Vì vậy các bạn cần lựa chọn cho mình một môi trường
phát triển tích hợp thích hợp để phát triển ứng dụng. Khi cài đặt IDE các bạn cần chỉ
định vị trí cài đặt JDK trên máy cục bộ của bạn. Thực hiện theo hướng dẫn của từng IDE riêng biệt.
1.1.2 Các ứng dụng với Java
a. Java và ứng dụng Console
Chương trình ứng dụng Console không sử dụng giao diện đồ họa mà sử dụng giao
diện dòng lệnh. Các thông tin nhập xuất của chương trình được thực hiện tại dấu nhắc
lệnh trên giao diện này.
Hình ảnh minh họa ứng dụng Console
b. Java và ứng dụng Applet
Chương trình Applet không thể thực hiện thông qua chương trình thông dịch java
như đối với chương trình ứng dụng Console. Chương trình Applet phải được đưa vào
trang tư liệu HTML để sau đó được nạp xuống thông qua Web Browser hoặc
appletviewer của JDK. Vậy, Applet là chương trình được tạo ra để sử dụng trên Internet
thông qua trình duyệt hỗ trợ Java. Khi trang web hiển thị trong trình duyệt, applet sẽ
được tải về và thực thi tại trình duyệt.
Hình ảnh minh họa chương trình ứng dụng Applet
c. Java và phát triển ứng dụng desktop dùng AWT và JFC
Đây là các chương trình độc lập cho phép người dùng tương tác với chương trình
thông qua giao diện đồ họa.
Minh họa dứng dụng đồ họa
d. Java và phát triển ứng dụng Web
Java thích hợp để phát triển các ứng dụng nhiều lớp. Applet là chương trình đồ họa
chạy trên trình duyệt tại máy trạm. Đối với ứng dụng Web, máy trạm gởi yêu cầu tới
máy chủ. Máy chủ xử lý và gởi trả kết quả lại cho máy trạm. Các Java API xử lý các
yêu cầu của máy trạm tại máy chủ và sau đó gởi kết quả lại cho máy trạm. Các Java
API tại máy chủ mở rộng khả năng của các ứng dụng Java API chuẩn. Ứng dụng trên
máy chủ này được gọi là các JSP/Servlet hoặc Applet tại máy chủ. Sử dụng form HTML
là cách sử dụng đơn giản nhất của JSP/Servlet. Chúng còn được dùng để xử lý dữ liệu,
thực thi các giao dịch, và thường được thực thi thông qua máy chủ Web.
Quá trình thực thi của JSP/Servlet tổng quan
e. Java và phát triển các ứng dụng nhúng
Hiện nay phần lớn các thiết bị di động như điện thoại di động, PDA, ...đều hỗ trợ
Java. Vì vậy, có thể xây dựng các ứng dụng chạy trên các thiết bị di động sử dụng công
nghệ J2ME. Đây là lĩnh vực khá hấp dẫn vì ngày nay các thiết bị di động ngày càng trở
nên phổ biến và nhu cầu cần có các ứng dụng chạy trên nó càng cao, đặc biệt là các ứng
dụng có tính chất giải trí như game,...
Ứng dụng nhúng chạy trên điện thoại di động
1.1.3 Soạn thảo và thực hiện ứng dụng Java đơn giản
a. Cấu trúc một chương trình Java:
Phần đầu của chương trình Java xác định thông tin môi trường. Để thực hiện được
điều này chương trình được chia thành các lớp hoặc các gói riêng biệt. Những gói này
sẽ được chỉ dẫn trong chương trình. Thông tin này được chỉ ra với sự trợ giúp của lệnh
“import”. Mỗi chương trình có thể có nhiều hơn một lệnh nhập. Dưới đây là một ví dụ: import java.io.*;
Lệnh này nạp tất cả các lớp thuộc gói IO phục vụ cho các công việc nhập xuất trong ứng dụng của bạn.
Trong Java, toàn bộ mã lệnh bao gồm các biến và các hàm, các khai báo,...đều nằm
trong phạm vi một lớp. Bởi vậy các khai báo được tiến hành sau lệnh nhập. Một ứng
dụng đơn giản có thể bao gồm một số ít các lớp. Những lớp này có thể mở rộng thành
các lớp khác. Mỗi một lệnh đều phải kết thúc bằng dấu chấm phẩy. Chương trình còn
có thể bao gồm các chú thích và chỉ dẫn. Khi dịch, những dòng chú thích và chỉ dẫn sẽ
được loại bỏ.Dạng cơ bản của một lớp được xác định như sau:
// Nạp các gói cần thiết class Tên_lớp{
/* Đây là dòng chú thích */
Vị trí khai báo các biến
Vị trí các hàm trong lớp Các câu lệnh thuộc hàm }
b. Chương trình Java đầu tiên:
Bạn có thể sử dụng bất kỳ trình soạn thảo văn bản nào để soạn thảo một chương
trình Java, quá trình soạn thảo bao gồm việc gõ và chỉnh sửa các lỗi gõ sai khi cần thiết.
Chương trình được lưu trong một tập tin văn bản theo định dạng ClassName.java với
ClassName là tên của lớp chứa trong tập tin .java. /**
* Chương trình ứng dụng HelloWorld
* Tên tập tin: HelloWorld.java */ class HelloWorld // Tiêu đề lớp {
// Bắt đầu thân lớp public static void
main(String[] args) // Phương thức main {
System.out.println("Hello World!"); }
// Kết thúc phương thức main }
// Kết thúc lớp HelloWorld
Trong ví dụ trên, chương trình HelloWorld phải được lưu với tập tin có tên là
HelloWorld.java. Kí hiệu /* ....*/ và // là kí hiệu dùng để ghi chú, trong đó /* ....*/
dùng để chứa nhiều hơn một dòng ghi chú, // ghi chú trên một dòng. Từ đó ta thấy 4
dòng đầu tiên trong chương trình HelloWorld ở trên là ghi chú. Dòng kế tiếp khai báo
lớp HelloWorld, sử dụng từ khóa class sau đó là tên lớp (cũng chính là tên tập tin) như sau: class HelloWorld
Thông thường, tên lớp bắt đầu bằng chữ viết hoa. Từ khóa class khai báo định nghĩa
lớp, “HelloWorld” là tên của lớp. Một định nghĩa lớp nằm hoàn toàn trong cặp dấu
ngoặc móc {....}. Cặp dấu ngoặc này đánh dấu bắt đầu và kết thúc một khối lệnh. public
static void main(String[] args)
Phương thức này là phương thức chính, chương trình bắt đầu việc thực thi từ phương
thức này. Mọi ứng dụng java đều sử dụng một phương thức main này. Từ khóa public
là một chỉ định truy xuất, cho biết thành viên của lớp có thể được truy xuất bất kì vị trí
nào trong chương trình. Phương thức main được khai báo với từ khóa public nên JVM
có thể truy xuất phương thức này. Từ khóa static cho phép phương thức main được gọi
mà không cần tạo ra một thể hiện của lớp, nhưng trong trường hợp này phương thức
main được phép tồn tại trên bộ nhớ, thậm chí không có một thể hiện của lớp đó được
tạo ra. Điều này rất quan trọng vì đầu tiên JVM gọi phương thức main để thực thi
chương trình, nên nó cần phải là một phương thức tĩnh để không phụ thuộc vào các đối
tượng của lớp được tạo ra. Từ khóa void cho biết khi thực thi phương thức này thì
không có bất kì giá trị nào được trả về cho chương trình. String[] args là tham số của
phương thức main, các biến số trong dấu ngoặc đơn nhận từng thông tin được chuyển
vào main. Những biến này là các tham số của phương thức. Khi không có tham số nào
được truyền vào cho phương thức main thì phương thức này vẫn thực hiện với dữ liệu rỗng.
System.out.println("Hello World!");
Dòng lệnh trên hiển thị chuỗi “Hello World!” trên màn hình.
c. Thực thi một ứng dụng Java đơn giản
Để thực thi ứng dụng HelloWorld ở trên trước hết chúng ta cần biên dịch mã nguồn
HelloWorld.java sử dụng trình biên dịch javac theo cấu trúc sau:
C:\Program Files\Java\jdk1.6.0_26\bin>javac HelloWorld.java
Sau khi biên dịch tập tin HelloWorld.class được tạo ra chứa các mã bytecode. Những
mã này chưa thể thực thi được. Để chương trình thực thi được ta sử dụng trình thông
dịch java theo cấu trúc sau:
C:\Program Files\Java\jdk1.6.0_26\bin>java HelloWorld
Kết quả hiển thị trên màn hình như sau: Hello World!
1.2 Lập trình cơ bản với Java
1.2.1 Các thành phần cơ bản của ngôn ngữ Java
Giống như những ngôn ngữ lập trình khác, ngôn ngữ Java được định nghĩa bằng tập
các quy tắc dẫn xuất của văn phạm cho phép kiểm tra xem cấu trúc được xây dựng từ
các phần tử của ngôn ngữ có hợp lệ (chính xác về mặt cú pháp) hay không và thông
qua các định nghĩa về mặt ngữ nghĩa để kiểm chứng ý nghĩa của những cấu trúc đó.
a. Bộ ký tự dùng trong Java
Mọi ngôn ngữ nói chung, ngôn ngữ lập trình nói riêng đều phải xây dựng trên một
tập hợp chữ cái, các ký tự được nhóm lại theo một cách nào đó để tạo thành các từ, các
từ lại được nhóm thành các câu (trong ngôn ngữ lập trình gọi là câu lệnh), một chương
trình máy tính là một tập hợp các câu lệnh được bố trí theo một trật tự mà người viết ra
chúng sắp đặt. Ngôn ngữ Java được xây dựng dựa trên bảng chữ cái Unicode, do vậy
ta có thể sử dụng các ký tự Unicode để đặt tên cho các định danh. b. Từ khóa(Keyword)
Các từ khóa của một ngôn ngữ lập trình là những định danh được định nghĩa sẵn
của ngôn ngữ và không thể sử dụng để định tên cho các thành phần khác. Các từ khóa
của Java có thể chia thành 9 nhóm: Tổ chức các lớp: package
Xác định một gói sẽ chứa một số lớp ở trong tập tin nguồn import
Yêu cầu một hay một số lớp ở các gói chỉ định cần nhập
vào để sử dụng trong ứng dụng hiện tại. Định nghĩa các lớp: interface
Định nghĩa các biến, hằng, phương thức chung như là
giao diện có thể chia sẽ chung giữa các lớp. class
Định nghĩa tuyển tập các thuộc tính dữ liệu, phương thức
mô tả các đặc tính và các hành vi của tập các đối tượng có quan hệ với nhau. extends
Chỉ ra lớp kế thừa của một lớp khác, hay còn gọi là lớp con của lớp cho trước.
implements Xây dựng một lớp mới cài đặt những phương thức từ
giao diện (interface) định trước.
Các từ khóa cho các biến và các lớp: abstract
Khai báo lớp trừu tượng không có thể hiện cụ thể. public
Khai báo lớp, biến dữ liệu, phương thức công khai có thể
truy nhập ở mọi nơi trong chương trình. private
Khai báo biến dữ liệu, phương thức riêng trong từng lớp
và chỉ cho phép truy nhập vào trong lớp đó. protected
Khai báo biến, phương thức được bảo vệ, cho phép truy
nhập ở lớp chứa chúng và các lớp con của lớp đó. static
Định nghĩa các biến, phương thức tĩnh của lớp, dùng
chung cho tất cả các đối tượng trong một lớp.
synchronized Chỉ ra ở mỗi thời điểm chỉ có một đối tượng hoặc một lớp
có thể truy nhập đến biến dữ liệu, hoặc phương thức loại
đó, nghĩa là chúng được đồng bộ hóa. volatile
Báo cho chương trình dịch biết là biến khai báo volatile
có thể thay đổi tùy ý trong các luồng (threat). final
Chỉ ra các biến, phương thức không được thay đổi sau khi đã được định nghĩa. native
Liên kết một phương thức với mã máy (native code), mã
được liên kết trong những ngôn ngữ lập trình khác như C chẳng hạn. Các kiểu nguyên thủy: long
Kiểu số nguyên lớn với các giá trị chiếm 8 byte int
Kiểu số nguyên với giá trị chiếm 4 byte short
Kiểu số nguyên với các giá trị chiếm 2 byte. byte
Kiểu số nguyên với các giá trị chiếm 1 byte. char
Kiểu ký tự Unicode với mỗi ký tự chiếm 2 byte. float
Kiểu số thực với các giá trị biểu diễn theo dạng dấu phẩy động 4 byte. double
Kiểu số thực với các giá trị biểu diễn theo dạng dấu phẩy động 8 byte.
boolean Kiểu logic với hai giá trị: true hay false. void
Kiểu trống, sử dụng cho các hàm không có giá trị trả về.
Những từ khóa cho những giá trị và các biến: true
Giá trị kiểu logic đúng. false Giá trị kiểu logic sai. this
Biến chỉ đối tượng hiện tại. super
Biến chỉ đối tượng ở lớp cha. null
Chỉ đối tượng không tồn tại. Xử lý ngoại lệ: