LAP TRINH JAVA-3
----------------------- Page 1-----------------------
----------------------- Page 2-----------------------
Chương 1
Giới thiệu ngôn ngữ
lập trình Java
----------------------- Page 3-----------------------
Giới thiệu
• Sựphát triển của Java
• Hướng tới người dùng
• Giống với C / C++
----------------------- Page 4-----------------------
Các đặc trưng của Java
Đơn giản
Hướng đối tượng
Độc lập phần cứng
Mạnh
Bảo mật
Phân tán
Đa luồng
Động
----------------------- Page 5-----------------------
Các chương trình dịch
truyền thống
----------------------- Page 6-----------------------
Chương trình dịch Java
----------------------- Page 7-----------------------
Các loại chương trình Java
Applets
Ứng dụng độc lập (console Application)
Ứng dụng giao diện (GUI Application)
Servlet
Ứng dụng cơ sởdữliệu
----------------------- Page 8-----------------------
Máy ảo Java
• Là một phần mềm dựa trên cơ sởmáy tính ảo
• Là tập hợp các lệnh logic đểxác định hoạt
động của máy tính
• Được xem như là một hệđiều hành thu nhỏ
• Nó thiết lập 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
----------------------- Page 9-----------------------
Quá trình dịch chương trình
Java
• Trình biên dịch chuyển mã nguồn thành tập
các lệnh 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 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 để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”
----------------------- Page 10-----------------------
Trình dịch Java
Java Development Kit
• Java 1.0 - Sửdụng lần đầu vào năm
1995
• Java 1.1 – Đưa ra năm 1997
• Java 2 – Phiên bản mới nhất
----------------------- Page 11-----------------------
Bộcông cụJDK
• Trình biên dịch, 'javac'
– javac [options] sourcecodename.java
• Trình thông dịch, 'java'
– java [options] classname
• Trình dịch ngược, 'javap'
– javap [options] classname
• Công cụsinh tài liệu, 'javadoc'
– javadoc [options] sourcecodename.java
----------------------- Page 12-----------------------
• Chương trình tìm lỗi - Debug, 'jdb‘
– jdb [options] sourcecodename.java
OR
– jdb -host -password [options]
sourcecodename.java
• Chương trình xem Applet ,
'appletviewer‘
– appletviewer [options]
sourcecodename.java / url
----------------------- Page 13-----------------------
Các gói chuẩn của Java
• java.lang
• java.applet
• java.awt
• java.io
• java.util
• java.net
• java.awt.event
• java.rmi
• java.security
• java.sql
----------------------- Page 14-----------------------
Các đặc trưng mớI của
Java2
• Swing
• Kéo và thả
• Java 2D API
• Âm thanh
• RMI
----------------------- Page 15-----------------------
Chương 2
Các phần tửcơbản ngôn ngữJava
----------------------- Page 16-----------------------
Cấu trúc một
chương trình Java
• Xác lập thông tin môi trường
• Khai báo lớp đối tượng (Class)
• Các thành phần (Tokens):
– Định danh
– Từkhóa / từdựphòng
– Ký tựphân cách
– Nguyên dạng (Literals)
– Toán tử
----------------------- Page 17-----------------------
Ví dụmột chương trình Java
mẫu
// This is a simple program called “Ex1.java”
class Ex1
{
public static void main(String args[])
{
System.out.println(“My first program in Java”);
}
}
----------------------- Page 18-----------------------
Biên dịch chương trình java
• ..\jdk\bin>javac Ex1.java
• ..\jdk\bin>java Ex1
• Kết quả:
My first program in Java
----------------------- Page 19-----------------------
Truyền đối sốtrong dòng lệnh
class Pass
{
public static void main(String parameters[])
{
System.out.println("This is what the main method
received");
System.out.println(parameters[0]);
System.out.println(parameters[1]);
System.out.println(parameters[2]);
}
}
----------------------- Page 20-----------------------
Truyền đối sốtrong dòng lệnh
(Tiếp theo…)
----------------------- Page 21-----------------------
Các phần tửcơ bản củangôn ngữ
Java
• Lớp và phương thức (Classes &
Methods)
• Kiểu dữliệu
• Biến số
• Toán tử
• Cấu trúc điều khiển
----------------------- Page 22-----------------------
Lớp trong Java
• Cú pháp khai báo lớp (Class)
class Classname
{
var_datatype variablename;
:
met_datatype methodname(parameter_list)
:
}
----------------------- Page 23-----------------------
Lớp mẫu
----------------------- Page 24-----------------------
Các lớp lồng nhau (Nested
Classes)
Việc định nghĩa một lớp bên trong một lớp
khác được gọi là “xếp lồng” (Nesting)
Các kiểu xếp lồng:
Tĩnh (Static)
Động (Non-static)
----------------------- Page 25-----------------------
Kiểu dữliệu
Kiểu dữliệu cơ sở(Primitive Data Types)
Kiểu dữliệu tham chiếu (Reference data types)
----------------------- Page 26-----------------------
Kiểu dữliệu cơ sở
• byte
• char
• boolean
• short
• int
• long
• float
• double
----------------------- Page 27-----------------------
Kiểu dữliệu tham chiếu
• Mảng (Array)
• Lớp (Class)
• Interface
----------------------- Page 28-----------------------
Ép kiểu (Type Casting)
• Kiểu dữliệu này được chuyển đổi sang
một kiểu dữliệu khác
• Ví dụ
float c = 34.89675f;
int b = (int)c + 10;
----------------------- Page 29-----------------------
Biến số
• Khai báo biến sốgồm 3 thành phần:
– Kiểu dữliệu của biến số
– Tên biến
– Giá trịban đầu của biến (không bắt buộc)
• Cú pháp
datatype identifier [=value][,
identifier[=value]...];
----------------------- Page 30-----------------------
Những từkhóa của Java
----------------------- Page 31-----------------------
Khai báo mảng
• Ba cách đểkhai báo mảng:
– datatype identifier [ ];
– datatype identifier [ ] = new
datatype[size];
– datatype identifier [ ]=
{value1,value2,….valueN};
----------------------- Page 32-----------------------
Phương thức
(Methods in Classes)
• Phương thức được định nghĩa như là
một hành động hoặc một tác vụthật sự
của đối tượng
• Cú pháp
access_specifier modifier datatype
method_name(parameter_list)
{
//body of method
}
----------------------- Page 33-----------------------
Ví dụvềsửdụng phương thức
class Temp {
static int x = 10; // variable
public static void show( ) { // method
System.out.println(x);
}
public static void main(String args[ ]) {
Temp t = new Temp( ); // object 1
t.show( ); // method call
Temp t1 = new Temp( ); // object 2
t1.x = 20;
t1.show( );
}
}
----------------------- Page 34-----------------------
Access specifiers
• public
• private
• protected
----------------------- Page 35-----------------------
Method Modifiers
• static
• abstract
• final
• native
• synchronized
• volatile
----------------------- Page 36-----------------------
Những phương thức được nạp chồng :
(Methods Overloading)
• Những phương thức được nạp chồng :
– Cùng ởtrong một lớp
– Có cùng tên
– Khác nhau vềdanh sách tham số
• Những phương thức được nạp chồng là
một hình thức đa hình (polymorphism)
trong quá trình biên dịch (compile time)
----------------------- Page 37-----------------------
Ghi đè phương thức
(Methods Overriding)
• Những phương thức được ghi đè:
– Có mặt trong lớp cha (superclass) cũng
nhưlớp kếthừa (subclass)
– Được định nghĩa lại trong lớp kếthừa
(subclass)
• Những phương thức được ghi đè là một
hình thức đa hình (polymorphism) trong
quá trình thực thi (Runtime)
----------------------- Page 38-----------------------
Phương thức khởi tạo
(Class Constructors)
• Là một phương thức đặc biệt dùng đểkhởi
tạo giá trịcho các biến thành viên của lớp
đối tượng
• Có cùng tên với tên lớp và không có giá trị
trảvề
• Được gọi khi đối tượng được tạo ra
• Có 2 loại:
– Tường minh (Explicit constructors)
– Ngầm định (Implicit constructors)
----------------------- Page 39-----------------------
Phương thức khởi tạo của lớp dẫn xuất
(Derived class constructors)
• Có cùng tên với lớp dẫn xuất (subclass)
• Mệnh đề gọi constructor của lớp cha
(superclass) phải là mệnh đềđầu tiên
trong constructor của lớp dẫn xuất
(subclass)
----------------------- Page 40-----------------------
Các toán tử
• Các loại toán tử:
– Toán tửsốhọc (Arithmetic operators)
– Toán tửdạng Bit (Bitwise operators)
– Toán tửso sánh (Relational operators)
– Toán tửlogic (Logical operators)
– Toán tửđiều kiện (Conditional operator)
– Toán tửgán (Assignment operator)
----------------------- Page 41-----------------------
Toán tửsốhọc
Arithmetic Operators
+ Addition (Phép cộng)
- Subtraction (Phép trừ)
* Multiplication (Phép nhân)
/ Division (Phép chia)
% Modulus (Lấy sốdư)
++ Increment (Tăng dần)
-- Decrement (Giảm dần)
----------------------- Page 42-----------------------
+= Phép cộng và gán
-= Phép trừvà gán
*= Phép nhân và gán
/= Phép chia và gán
%= Phép lấy sốdưvà gán
----------------------- Page 43-----------------------
Toán tửBit
(Bitwise Operators)
~ Phủđịnh (NOT)
& Và (AND)
| Hoặc (OR)
^ Exclusive OR
>> Dịch sang phải (Shift right)
<< Dịch sang trái (Shift left)
----------------------- Page 44-----------------------
Toán tửso sánh
(Relational Operators)
== So sánh bằng
!= So sánh khác
< Nhỏhơn
> Lớn hơn
<= Nhỏhơn hoặc bằng
>= Lớn hơn hoặc bằng
----------------------- Page 45-----------------------
Toán tửLogic
(Logical Operators )
&& Logical AND
|| Logical OR
! Logical unary NOT
----------------------- Page 46-----------------------
Toán tửđiều kiện
(Conditional Operator)
• Cú pháp
Biểu thức 1 ? Biểu thức 2 : Biểu thức 3;
• Biểu thức 1
Điều kiện kiểu Boolean trả về giá trị True
hoặc False
• Biểu thức 2
Trảvềgiá trịnếu kết quảcủa mệnh đề1 là
True
• Biểu thức 3
----------------------- Page 47-----------------------
Toán tửgán
(Assignment Operator)
= Assignment (Phép gán)
Giá trịcó thểđược gán cho nhiều biến số
• Ví dụ
a = b = c = d = 90;
----------------------- Page 48-----------------------
Thứtựưu tiên của các toán tử
Thứtự Toán tử
1. trong ngoặc tính trước
2. Các toán tửđơn như+,-,++,--
3. Các toán tửsốhọc và các toán tửdịch
như*,/,+,-,<<,>>
4. Các toán tửquan hệnhư>,<,>=,<=,= =,!=
5. Các toán tửlogic và Bit như&&,II,&,I,^
5. Các toán tửgán như=,*=,/=,+=,-=
Thứtựcủa các toán tửcó thể được thay đổi bằng
cách sửdụng các dấu ngoặc đơn trong mệnh đề
----------------------- Page 49-----------------------
Các kí tựđịnh dạng xuất dữliệu
(Escape Sequences)
Escape
Mô tả
Sequence
Xuống dòng mới
\r Chuyển con trỏđến đầu dòng hiện hành
\t Chuyển con trỏđến vịtrí dừng Tab kếtiếp
(ký tựTab)
\\ In dấu \
\’ In dấu nháy đơn (’)
\’’ In dấu nháy kép (’’)
----------------------- Page 50-----------------------
Các lệnh điều khiển
• Điều khiển rẻnhánh:
– Mệnh đềif-else
– Mệnh đềswitch-case
• Vòng lặp (Loops):
– Vòng lặp while
– Vòng lặp do-while
– Vòng lặp for
----------------------- Page 51-----------------------
Lệnh if-else
• Cú pháp
if (condition)
{
action1 statements;
}
else
{
action2 statements;
}
----------------------- Page 52-----------------------
Lệnh switch-case
• Cú pháp
switch (expression)
{
case 'value1': action1 statement(s);
break;
case 'value2': action2 statement(s);
break;
:
:
case 'valueN': actionN statement(s);
break;
----------------------- Page 53-----------------------
Lệnh lặp while
Cú pháp
while(condition)
{
action statements;
:
:
}
----------------------- Page 54-----------------------
Lệnh lặp do-while
• Cú pháp
do
{
action statements;
:
:
} while(condition);
----------------------- Page 55-----------------------
Vòng lặp for
• Cú pháp
for(initialization statements; condition;
increment statements)
{
action statements;
:
:
}
----------------------- Page 56-----------------------
----------------------- Page 57-----------------------
Chương 3
Gói & Interface
(Packages & Interfaces)
----------------------- Page 58-----------------------
Giới thiệu
• Những thành phần cơbản của 1 chương
trình Java:
– Gói (Packages)
– Giao diện (Interfaces)
• Những phần của một chương trình Java:
– Lệnh khai báo gói(package )
– Lệnh chỉđịnh gói được dùng (Lệnh import)
– Khai báo lớp public (một file java chỉchứa 1 lớp
public class)
– Các lớp khác (classes private to the package)
• Tập tin nguồn Java có thểchứa tất cảhoặc
một vài trong sốcác phần trên.
----------------------- Page 59-----------------------
Interfaces
• Chương trình Java chỉcó thểkếthừa từ
1 lớp duy nhất trong cùng một thời
điểm, nhưng có thểdẫn xuất cùng lúc
nhiều Interfaces
• Không được phép có những phương
thức cụthể(concrete methods)
• interface cần phải được hiện thực
(implements).
----------------------- Page 60-----------------------
Các bước tạo interface
• Định nghĩa Interface
• Biên dịch Interface
• Hiện thực Interface
• Tính chất của interface:
– Tất cảphương thức trong interface phải là
public.
– Các phương thức phải được định nghĩa
trong lớp dẫn xuất giao diện đó.
----------------------- Page 61-----------------------
Sửdụng Interface
• Không thểdẫn xuất từlớp khác, nhưng có
thểdẫn xuất từnhững interface khác
• Nếu một lớp dẫn xuất từmột interface mà
interface đó dẫn xuất từcác interface khác
thì lớp đó phải định nghĩa tất cảcác phương
thức có trong các interface đó
• Khi định nghĩa một interface mới thì một kiểu
dữliệu tham chiếu cũng được tạo ra.
----------------------- Page 62-----------------------
Gói (Packages)
• Tương tự nhưthưmục lưu trữnhững
lớp, interface và các gói con khác. Đó
là những thành viên của gói
----------------------- Page 63-----------------------
• Những ưu điểm khi dùng gói (Package):
– Cho phép tổchức các lớp vào những đơn
vịnhỏhơn
– Giúp tránh được tình trạng trùng lặp khi
đặt tên.
– Cho phép bảo vệcác lớp đối tượng
– Tên gói (Package) có thểđược dùng để
nhận dạng chức năng của các lớp.
----------------------- Page 64-----------------------
• Những lưu ý khi tạo gói:
– Mã nguồn phải bắt đầu bằng lệnh ‘package’
– Mã nguồn phải nằm trong cùng thưmục mang tên
của gói
– Tên gói nên bắt đầu bằng ký tựthường (lower case)
đểphân biệt giữa lớp đối tượng và gói
– Những lệnh khác phải viết phía dưới dòng khai báo
gói là mệnh đềimport, kếđến là các mệnh đềđịnh
nghĩa lớp đối tượng
– Những lớp đối tượng trong gói cần phải được biên
dịch
– Để chương trình Java có thểsửdụng những gói
này, ta phải import gói vào trong mã nguồn
----------------------- Page 65-----------------------
• Import gói (Importing packages):
– Xác định tập tin cần được import trong gói
– Hoặc có thểimport toàn bộgói
----------------------- Page 66-----------------------
Các bước tạo ra gói
(Package)
• Khai báo gói
• Import những gói chuẩn cần thiết
• Khai báo và định nghĩa các lớp đối
tượng có trong gói
• Lưu các định nghĩa trên thành tập tin
.java, và biên dịch những lớp đối tượng
đã được định nghĩa trong gói.
----------------------- Page 67-----------------------
Sửdụng những gói do người dùng định
nghĩa (user-defined packages)
• Mã nguồn của những chương trình này phải ở
cùng thư mục của gói do người dùng định
nghĩa.
• Để những chương trình Java khác sử dụng
những gói này, import gói vào trong mã nguồn
• Import những lớp đối tượng cần dùng
• Import toàn bộgói
• Tạo tham chiếu đến những thành viên của gói
----------------------- Page 68-----------------------
Xác lập CLASSPATH
• Là danh sách các thưmục, giúp cho
việc tìm kiếm các tập tin lớp đối tượng
tương ứng
• Nên xác lập CLASSPATH trong lúc
thực thi (runtime), vì nhưvậy nó sẽxác
lập đường dẫn cho quá trình thực thi
hiện hành
----------------------- Page 69-----------------------
Gói và điều khiển truy xuất
(Packages & Access Control)
----------------------- Page 70-----------------------
Gói java.lang
• Mặc định thì bất cứchương trình Java
nào cũng import gói java.lang
• Những lớp Wrapper (bao bọc) cho các
kiểu dữliệu nguyên thủy:
----------------------- Page 71-----------------------
Lớp String
• Phương thức khởi tạo (Constructor):
– String str1 = new String();
– String str2 = new String(“Hello World”);
– char ch[ ] = {“A”,”B”,”C”,”D”,”E”};
– String str3 = new String(ch);
– String str4 = new String(ch,0,2);
----------------------- Page 72-----------------------
String Pool
• ‘String Pool’ đại diện cho tất cảcác ký
tựđược tạo ra trong chương trình
• Khái niệm ‘String Pool’
----------------------- Page 73-----------------------
Những phương thức của lớp String
• charAt( )
• startsWith()
• endsWith( )
• copyValueOf( )
• toCharArray( )
• indexOf( )
• toUpperCase( )
• toLowerCase( )
• trim( )
• equals( )
----------------------- Page 74-----------------------
Lớp StringBuffer
• Cung cấp những phương thức khác nhau để
thao tác trên đối tượng string (chuỗi ký tự)
• Những đối tượng của lớp này khá linh hoạt
• Cung cấp những phương thức khởi tạo
(constructor) đã được nạp chồng
(overloaded)
• Những phương thức của lớp StringBuffer:
– append( )
– insert( )
– charAt( )
– setCharAt( )
– setLength( )
– getChars( )
----------------------- Page 75-----------------------
Lớp java.lang.Math
• abs() • random()
• ceil() • sqrt()
• floor() • sin()
• max() • cos()
• min() • tan()
• round()
----------------------- Page 76-----------------------
Lớp Runtime
• Đóng gói (Encapsulates) môi trường thực thi
• Dùng đểquản lý bộnhớ, và thi hành những
tiến trình cộng thêm
• Phương thức:
– exit(int)
– freeMemory( )
– getRuntime( )
– gc( )
– totalMemory( )
– exec(String)
----------------------- Page 77-----------------------
Lớp System
• Cung cấp những hạ tầng chuẩn như nhập
(Input), xuất (Output) và các luồng lỗi(Error
Streams)
• Cung cấp khả năng truy xuất đến những
thuộc tính của hệ thống thực thi Java, và
những thuộc tính môi trường nhưphiên bản,
đường dẫn, nhà cung cấp…
• Phương thức:
– exit(int)
– gc()
– getProperties()
– setProperties()
– currentTimeMillis()
----------------------- Page 78-----------------------
Lớp Class
• Thể hiện (Instance) của lớp này che
giấu tình trạng thực thi của đối tượng
trong một ứng dụng Java
• Đối tượng hoặc thểhiện của lớp này có
thểtạo ra bằng 1 trong 3 cách sau:
– Sửdụng phương thức getClass( ) của đối tượng
– Sửdụng phương thức tĩnh forName( ) của lớp để
tạo ra một thểhiện của lớp đó trong lúc đặt tên
cho lớp
– Sửdụng đối tượng ClassLoader đểnạp một lớp
mới
----------------------- Page 79-----------------------
Lớp Object
• Là lớp cha (superclass) của tất cảcác lớp
• Phương thức:
– equals(Object)
– finalize()
– notify()
– notifyAll()
– toString()
– wait()
----------------------- Page 80-----------------------
Gói java.util
• Cung cấp phần lớn những lớp Java
hữu dụng và thường xuyên cần đến
trong hầu hết các ứng dụng
• Giới thiệu những lớp trừu tượng sau:
– Hashtable
– Random
– Vector
– StringTokenizer
----------------------- Page 81-----------------------
Lớp Hashtable
• Mởrộng lớp trừu tượng Dictionary
• Dùng đểnối kết những khóa vào những
giá trịcụthể
• Phương thức khởi tạo Hashtable:
– Hashtable(int)
– Hashtable(int, float)
– Hashtable( )
----------------------- Page 82-----------------------
Những phương thức của lớp
Hashtable
• clear() • keys()
• done() • put(Object, Object)
• contains(Object) • rehash()
• containsKey(Obj • remove(Object
ect) key)
• elements() • size()
• get(Object key) • toString()
• isEmpty()
----------------------- Page 83-----------------------
Lớp Random
• Tạo ra những số ngẫu nhiên theo thuật toán
pseudo
• Những phương thức nhận giá trịngẫu nhiên:
– nextDouble( )
– nextFloat( )
– nextGaussian( )
– nextInt( )
– nextLong( )
• Phương thức khởi tạo (Constructors):
– random()
– random(long)
----------------------- Page 84-----------------------
Những phương thức của lớp
Random
• nextDouble()
• nextFloat()
• nextGaussian()
• nextInt()
• nextLong()
• setSeed(long)
----------------------- Page 85-----------------------
Lớp Vector
• Cung cấp khả năng co giản cho mảng khi
thêm phần tửvào mảng
• Lưu trữnhững thành phần của kiểu Object
• Một Vector riêng rẽ có thể lưu trữ những
phần tửkhác nhau, đó là những instance của
những lớp khác nhau
• Phương thức khởi tạo (Constructors):
– Vector(int)
– Vector(int, int)
– Vector()
----------------------- Page 86-----------------------
Những phương thức của lớp
Vector
• addElement(Object) • isEmpty( )
• capacity( ) • lastElement( )
• clone( ) • lastIndexOf(Object)
• contains(Object) • lastIndexOf(Object,
• copyInto(Object [ ])
• removeAllElements(
• elementAt(int)
• elements( )
• removeElement(Obj
• ensureCapacity(int) ect)
• firstElement( ) • removeElementAt(in
• indexOf(Object) t)
• indexOf(Object, int) • setElementAt(Object
• insertElementAt(Objec , int)
----------------------- Page 87-----------------------
Lớp StringTokenizer
• Có thểđược dùng đểtách một chuỗi thành
những thành phần cấu thành của nó
(constituent tokens)
• Ký tựphân cách có thểđược chỉđịnh khi
một đối tượng StringTokenizer được khởi
tạo
• Phương thức khởi tạo (Constructors):
– StringTokenizer(String)
– StringTokenizer(String, String)
– StringTokenizer(String, String, Boolean)
• Lớp StringTokenizer sửdụng giao diện liệt
----------------------- Page 88-----------------------
Những phương thức của lớp
StringTokenizer
• countTokens( )
• hasMoreElements( )
• hasMoreTokens( )
• nextElement( )
• nextToken( )
• nextToken(String)
----------------------- Page 89-----------------------
Chương 4
Xửlý biệt lệ
----------------------- Page 90-----------------------
Giới thiệu vềbiệt lệ
• Là một kiểu lỗi đặc biệt
• Nó xảy ra trong thời gian thực thi đoạn lệnh
• Thông thường các điều kiện thực thi chương
trình gây ra biệt lệ
• Nếu các điều kiện này không được quan tâm,
thì việc thực thi có thểkết thúc đột ngột
----------------------- Page 91-----------------------
Mục đích của việc xửlý biệt lệ
• Giảm thiểu việc kết thúc bất thường của hệ
thống và của chương trình.
• Ví dụ, thao tác xuất/nhập trong một tập tin, nếu
việc chuyển đổi kiểu dữ liệu không thực hiện
đúng, một biệt lệsẽxảy ra và chương trình bị
hủy mà không đóng tập tin. Lúc đó tập tin sẽ
bịhưhại và các nguồn tài nguyên được cập
phát cho tập tin không được thu hồi lại cho hệ
thống.
----------------------- Page 92-----------------------
Xửlý biệt lệ
• Khi một biệt lệxảy ra, đối tượng tương ứng với biệt lệ
đó sẽđược tạo ra.
• Đối tượng này sau đó được truyền tới phương thức
nơi mà biệt lệxảy ra.
• Đối tượng này chức các thông tin chi tiết vềbiệt lệ.
Thông tin này có thểnhận được và xửlý.
• Lớp ’throwable’ mà Java cung cấp là lớp trên nhất
của lớp biệt lệ.
----------------------- Page 93-----------------------
Mô hình xửlý biệt lệ
• Mô hình được biết đến là mô hình ‘catch and
throw’
• Khi một lỗi xảy ra, biệt lệsẽđuợc chặn và
được vào một khối.
• Từkhóa đểxửlý biệt lệ:
– try
– catch
– throw
– throws
– finally
----------------------- Page 94-----------------------
Cấu trúc của mô hình xửlý biệt lệ
• Cú pháp
try { …. }
catch(Exception e1) { …. }
catch(Exception e2) { …. }
catch(Exception eN) { …. }
finally { …. }
----------------------- Page 95-----------------------
Mô hình ‘Catch and Throw’ nâng cao
• Người lập trình chỉquan tâm tới các lỗi
khi cần thiết.
• Một thông báo lỗi có thểđược cung cấp
trong exception-handler.
----------------------- Page 96-----------------------
Khối ‘try’ và ‘catch’
• Được sử dụng đểthực hiện trong mô hình
‘catch and throw’ của xửlý biệt lệ.
• Khối lệnh ‘try’ gồm tập hợp các lệnh thực thi
• Một phương thức mà có thểbắt biệt lệ, cũng
bao gồm khối lệnh ‘try’.
• Một hoặc nhiều khối lệnh ‘catch’ có thểtiếp
theo sau một khối lệnh ‘try’
• Khối lệnh ‘catch’ này bắt biệt lệtrong khối
lệnh ‘try’.
----------------------- Page 97-----------------------
Khối lệnh ‘try’ và ‘catch’ Blocks
• Đểbắt bất kỳloại biệt lệnào, ta phải chỉra kiểu
biệt lệlà ‘Exception’
catch(Exception e)
• Khi biệt lệ bị bắt không biết thuộc kiểu nào,
chúng ta có thểsửdụng lớp ‘Exception’ đểbắt
biệt lệđó.
• Lỗi sẽ được truyền thông qua khối lệnh ‘try
catch’ cho tới khi chúng bắt gặp một ‘catch’
tham chiếu tới nó, hoặc chương trình sẽbịkết
thúc
----------------------- Page 98-----------------------
Khối lệnh chứa nhiều Catch
• Các khối chứa nhiều ‘catch()’ xử lý các
kiểu biệt lệkhác nhau một cách độc lập.
• Ví dụ
try
{ doFileProcessing();
displayResults(); }
catch(LookupException e)
{ handleLookupException(e); }
catch(Exception e)
{
System.err.println(“Error:”+e.printStackTrace
----------------------- Page 99-----------------------
Khối lệnh chứa nhiều Catch (tt)
• Khi sửdụng các ‘try’ lồng nhau, khối ‘try’ bên
trong được thi hành đầu tiên
• Bất kỳbiệt lệnào bịchặn trong khối lệnh ‘try’
sẽbịbắt giữtrong khối lệnh ‘catch’ tiếp ngay
sau.
• Nếu khối lệnh ‘catch’ thích hợp không được
tìm thấy, thì các khối ‘catch’ của khối ‘try’ bên
ngoài sẽđược xem xét
• Ngược lại, Java Runtime Environment sẽxử
lý biệt lệ.
----------------------- Page 100-----------------------
Khối ‘finally’
• Thực hiện tất cảcác việc thu dọn khi biệt lệ
xảy ra
• Có thểsửdụng kết hợp với khối ‘try’
• Chứa các câu lệnh thu hồi tài nguyên vềcho
hệthống hay lệnh in ra các câu thông báo:
– Đóng tập tin
– Đóng lại bộkết quả(được sửdụng trong chương
trình cơsởdữliệu)
– Đóng lại các kết nối được tạo trong cơsởdữliệu.
----------------------- Page 101-----------------------
Khối ‘finally’ (tt)
• Ví dụ
try
{
doSomethingThatMightThrowAnException( );
}
finally
{
cleanup( );
}
----------------------- Page 102-----------------------
Khối ‘finally’ (tt)
• Là tùy chọn không bắt buộc
• Được đặt sau khối ‘catch’
• Khối ‘finally’ bảo đảm lúc nào cũng được thực
hiện bất chấp biệt lệcó xảy ra hay không.
----------------------- Page 103-----------------------
Các biệt lệđược định nghĩa với
lệnh ‘throw’ và ‘throws’
• Các biệt lệthì được chặn với sựtrợgiúp của từ
khóa ‘throw’
• Từkhóa ‘throw’ chỉra một biệt lệvừa xảy ra.
• Toán hạng của throw là một đối tượng của một
lớp, mà lớp này được dẫn xuất từlớp ‘Throwable’
• Ví dụcủa lệnh ‘throw’
try{
if (flag < 0)
{
throw new MyException( ) ; // user-
defined
}
----------------------- Page 104-----------------------
Các biệt lệđược định nghĩa vớ
lệnh ‘throw’ và ‘throws’(tt)
• Một phương thức đơn có thểchặn nhiều hơn một
biệt lệ
• Ví dụtừkhóa ‘throw’ xửlý nhiều biệt lệ
public class Example {
public void exceptionExample( ) throws
ExException, LookupException {
try
{ // statements }
catch(ExException exmp)
{ …. }
catch(LookupException lkpex)
{ …. } } }
----------------------- Page 105-----------------------
Các biệt lệđược định nghĩa với
lệnh ‘throw’ và ‘throws’(tt)
• Lớp ‘Exception’ thực thi giao diện
‘Throwable’ và cung cấp các tính năng
hữu dụng đểphân phối cho các biệt lệ.
• Một lớp con của lớp Exception là một
biệt lệmới có thểbắt giữđộc lập các loại
Throwable khác.
----------------------- Page 106-----------------------
Danh sách các biệt lệ
• RuntimeException
• ArithmeticException
• IllegalAccessException
• IllegalArgumentException
• ArrayIndexOutOfBoundsException
• NullPointerException
• SecurityException
• ClassNotFoundException
----------------------- Page 107-----------------------
Danh sách các biệt lệ(tt)
• NumberFormatException
• AWTException
• IOException
• FileNotFoundException
• EOFException
• NoSuchMethodException
• InterruptedException
----------------------- Page 108-----------------------
Chương V
LẬP TRÌNH GIAO DIỆN VỚI AWT
----------------------- Page 109-----------------------
GIỚI THIỆU VỀAWT
• AWT viết tắt của Abstract Windowing
Toolkit
• AWT là tập hợp các lớp Java cho phép
chúng ta tạo một GUI
• Cung cấp các mục khác nhau đểtạo hoạt
động và hiệu ứng GUI như
–Containers
–Components
–Layout managers
–Graphics và drawing capabilities
–Fonts
–Events
----------------------- Page 110-----------------------
• AWT bao gồm các lớp, interfaces và các gói
khác
----------------------- Page 111-----------------------
Components
• Tất cảcác thành phần cấu tạo nên chương
trình GUI được gọi là component.
• Ví dụ
– Containers,
– textfields, labels, checkboxes, textareas
– scrollbars, scrollpanes, dialog
----------------------- Page 112-----------------------
Containers
• Là thành phần mà có thể chứa các
thành phần khác. có thểvẽvà tô màu.
• Có các frames, panes,latches, hooks
• Java.awt chứa một lớp có tên là
Container. Lớp này dẫn xuất trực tiếp
và không trực tiếp theo 2 cách là:
– Frames
– Panels
----------------------- Page 113-----------------------
Frames
• Là các cửa sổ
• Là lớp con của Windows
• Được hiển thịtrong một cửa sổvà có đường
viền
----------------------- Page 114-----------------------
Panels
• Là các vùng chứa trong một cửa sổ.
• Hiển thị trong một cửa sổ mà trình duyệt
hoặc appletviewer cung cấp và không có
đường viền.
• Được sửdụng đểnhóm một sốcác thành
phần
• Một panel không có sẳn vì thếchúng ta cần
phải thêm nó vào frame.
• Hàm dựng
– Panel()
----------------------- Page 115-----------------------
Dialog
• Là một lớp con của lớp Window
• Đối tượng dialog được cấu trúc như sau :
Frame myframe = new Frame(“My frame”);
String title = “Title”;
boolean modal = true;
Dialog dlg = new Dialog( myframe, title, modal);
----------------------- Page 116-----------------------
Các Components khác
• Ví dụ
– textfields, labels, checkboxes, textareas
– scrollbars, scrollpanes, dialog
----------------------- Page 117-----------------------
Label
• Được dùng đểhiển thịchuỗi (String)
• Các hàm dựng:
– Label( )
– Label(String labeltext)
– Label(String labeltext, int alignment)
• Các phương thức:
– setFont(Font f)
– setText(String s)
– getText( )
----------------------- Page 118-----------------------
TextField
• Là điều khiển text cho phép hiển thịtext hoặc
cho user nhập dữliệu vào.
• Các hàm dựng:
– TextField( )
– TextField(int columns)
– TextField(String s)
– TextField(String s, int columns)
• Các phương thức:
– setEchoChar(char)
– setTest(String s)
– getText( )
– setEditable(boolean)
– isEditable( )
----------------------- Page 119-----------------------
TextArea
• Được dùng khi text có nội dung từhai
dòng trởlên
• Là điều khiển text có thể soạn thảo
được với nhiều dòng
• Các bước đểtạo TextArea:
– Tạo một phần tử(element)
– Chỉra sốdòng hay sốcột (tùy chọn)
– Chỉra vịtrí của điều khiển trên màn hình
----------------------- Page 120-----------------------
TextArea (tt…)
• Các hàm dựng:
– TextArea( )
– TextArea(int rows, int cols )
– TextArea(String text)
– TextArea(String text, int rows, int cols)
----------------------- Page 121-----------------------
Các phương thức của
TextArea
• setText(String)
• getText( )
• setEditable(boolean)
• isEditable( )
• insertText(String, int)
• replaceText(String, int, int)
----------------------- Page 122-----------------------
Button
• Các nút Push hay Command là cách dễnhất
đểlấy các sưkiện của user
• Các bước đểtạo button:
– Tạo một phần tử button, nên tạo cho nó một
caption đểchỉra mục đích của nó
– Chỉra vịtrí đặt button trên màn hình
– HIển thịra trên màn hình
• Các hàm dựng:
– Button( )
– Button(String text)
----------------------- Page 123-----------------------
Checkboxes and
RadioButtons
• Checkboxes được dùng khi cho phép user nhiều cọn
chọn lựa
• Radiobuttons được dùng đểuser chỉra một lựa chọn
duy nhất
• Các bước đểtạo checkbox hoặc radiobutton:
– Tạo một phần tử(element)
– Khởi tạo giá trịban đầu (có giá trịselected hay unselected)
– Chỉra vịtrí trên màn hình
– Hiển thịra màn hình
• Các hàm dựng đểtạo checkbox:
– Checkbox( )
– Checkbox(String text)
• Để tạo radiobutton, ta phải tạo đối tượng
CheckBoxGroup trước khi tạo button
----------------------- Page 124-----------------------
Choice Lists
• Lớp ‘Choice’ cho phép ta tạo danh sách có nhiều
chọn lựa
• Khi list được tạo lần đầu tiên, nó được khởi tạo là
empty
• Các bước đểtạo danh sách chọn lựa:
– Tạo một phần tử
– Thêm các mục (có kiểu Strings) vào danh sách đó,
từng mục một
– Chỉra vịtrí trên màn hình
– Hiển thịra màn hình
• Ví dụ
Choice colors=new Choice( );
colors.addItem(“Red”);
colors.addItem(“Green”);
----------------------- Page 125-----------------------
Trình quản lý bốtrí
Layout Manager
• Các loại layout khác nhau:
– Flow Layout
– Border Layout
– Card Layout
– Grid Layout
– GridBag Layout
• Trình quản lý layout được thiết lập bằng
cách gọi phương thức ‘setLayout( )’
----------------------- Page 126-----------------------
FlowLayout
• Là trình quản lý layout mặc định cho các
applet và các panel
• Với FlowLayout các thành phần sẽ được
xắp xếp từgóc trái trên đến góc phải dưới
của màn hình
• Các constructor:
FlowLayout mylayout = new FlowLayout();
FlowLayout exLayout = new
flowLayout(FlowLayout.RIGHT);
----------------------- Page 127-----------------------
BorderLayout
• Là trình quản lý layout mặc định cho Window,
Frame và Dialog
• Trình quản lý này có thểxắp xếp đến 5 thành
phần trong container
• Các thành phần có thểđược đặt vào 5 hướng
NORTH, EAST, SOUTH, WEST và CENTER
của container
• Ví dụ: Để thêm một thành phần vào vùng
North của container
Button b1= new Button(“North Button”);
setLayout(new BorderLayout( ));
add(b1, BorderLayout.NORTH);
----------------------- Page 128-----------------------
CardLayout
• Có thểlưu trữmột danh sách các kiểu layout
khác nhau
• Mỗi layout được xem nhưmột thẻ(card)
• Thẻthường là đối tượng Panel
• Một thành phần độc lập nhưbutton sẽđiều
khiển các thẻ được đặt ởphía trên nhất
• Các bước đểtạo CardLayout:
– Bốtrí layout của panel chính là CardLayout
– Lần lượt thêm các panel khác vào panel chính
----------------------- Page 129-----------------------
GridLayout
• Hỗtrợviệc chia container thành một lưới
• Các thành phần được bố trí trong các
dòng và cột
• Một ô lưới nên chứa ít nhất một thành
phần
• Kiểu layout này được sửdụng khi tất cả
các thành phần có cùng kích thước
• Hàm constructor
GridLayout gl = new GridLayout(no. of rows,
no. of columns);
----------------------- Page 130-----------------------
GridBagLayout
• Bốtrí các thành phần một cách chính xác
• Các thành phần không cần có cùng kích
thước
• Các thành phần được xắp xếp trong một
lưới chứa các dòng và các cột
• Thứ tự đặt các thành phần không tuân
theo hướng từ trái-sang-phải và trên-
xuống-dưới
• Hàm constructor
GridBagLayout gb = new GridBagLayout( );
----------------------- Page 131-----------------------
GridBagLayout
• Để sử dụng layout này, bạn cần phải
biết thông tin vềkích cỡvà cách bốtrí
của các thành phần
• Lớp ‘GridBagLayoutConstraints’ lưu trữ
tất cảcác thông tin mà lớp GridLayout
yêu cầu: Vịtrí và kích thuớc mỗi thành
phần
----------------------- Page 132-----------------------
Xửlý các sựkiện
• Các sự kiện (Events) được xử lý bằng các
công cụsau:
– Abstract Windowing Toolkit
– Trình duyệt.
– Các trình xử lý sự kiện do các lập trình viên tạo
riêng.
• Các ứng dụng cần đăng ký trình xửlý sựkiện
với đối đối tượng
• Các trình xử lý này được gọi khi có một sự
kiện tương ứng xảy ra
----------------------- Page 133-----------------------
Xửlý các sựkiện (tt…)
• Event Listener sẽlắng nghe một sựkiện cụ
thểmà một đối tượng tạo ra
• Mỗi event listener cung cấp các phương
thức đểxửlý các sựkiện này
• Lớp có cài đặt listener cần định nghĩa những
phương thức này
----------------------- Page 134-----------------------
Xửlý các sựkiện(tt…)
• Các bước cần tuân thủđểsửdụng mô hình
Event Listener:
– Cài đặt Listener tương ứng
– Nhận diện được tất cảcác thành phần tạo ra sự
kiện
– Nhận diện được tất cảcác sựkiện được xửlý
– Cài đặt các phương thức của listener, và viết các
đoạn mã đểxửlý sựkiện trong các phương thức
đó
• Interface định nghĩa các phương thức khác
nhau đểxửlý mỗi sựkiện
----------------------- Page 135-----------------------
Các sựkiện và Listener tương
ứng
• ActionEvent ActionListener
• AdjustmentEvent AdjustmentListener
• ComponentEvent ComponentListener
• FocusEvent FocusListener
• ItemEvent ItemListener
• WindowEvent WindowListener
• TextEvent TextListener
• MouseEvent MouseListener
MouseMotionListener
• KeyEvent KeyListener
----------------------- Page 136-----------------------
Menus
• Các loại menu :
– Pull-down
– Pop-up menu
• Chỉcó thểđặt các thanh menubar vào
trong các Frame mà thôi
• Các thành phần của menu:
– Menubar
– MenuItems
----------------------- Page 137-----------------------
Chương VI
Applets
----------------------- Page 138-----------------------
Applets
• Là một chương trình Java mà chạy với
sựhổtrợcủa trình duyệt web
• Tất cả các applets là lớp con của lớp
‘Applet’
• Đểtạo một applet, bạn cần import hai
gói sau:
– java.applet
– java.awt
----------------------- Page 139-----------------------
Cấu trúc applet
• Định nghĩa một applet từbốn sựkiện xảy ra
trong quá trình thực thi
• Đối với mỗi sựkiện được định nghĩa bởi một
phương thức tương ứng.
• Các phương thức:
– init( )
– start( )
– stop( )
– destroy( )
----------------------- Page 140-----------------------
• Các phương thức khác:
– paint( )
– repaint( )
– showStatus( )
– getAppletInfo( )
• Các phương thức init(), start(), stop(),
destroy(), and paint() được thừa kếtừapplet.
• Mỗi phương thức này mặc định là rỗng. Vì thế
các phương thức này phải được nạp chồng.
----------------------- Page 141-----------------------
Biên dịch và thực thi applet
• Một applet thì được biên dịch theo cú pháp
sau
javac Applet1.java
• Đểthực thi một applet, tạo một tập tin HTML
có sửdụng thẻapplet
– Thẻapplet có hai thuộc tính:
• Width
• Height
– Đểtruyền tham sốtới applet, sửdụng thẻ‘param’,
và tiếp theo là thẻ‘value’
• Applet có thể được thực thi bằng applet
viewer
----------------------- Page 142-----------------------
Điểm khác biệt giữa applet và một ứng dụng
• Các ứng dụng khi thực thi phải sửdụng
trình biên dịch Java, trong khi các applets
thực thi được trên bất kỳtrình duyệt nào
mà hổ trợ Java, hoặc sử dụng
‘AppletViewer’ trong JDK.
• Một ứng dụng bắt đầu với phương thức
‘main()’. Còn đối với applet thì không sử
dụng phương thức này
• Một ứng dụng sử dụng
‘System.out.println()’ đểhiển thị, trong khi
môt applet thì sử dụng phương thức
‘drawstring()’ đểhiển thị.
----------------------- Page 143-----------------------
Những hạn chếvềbảo mật
trong applet
• Không thểđọc hoặc viết các tập tin trên hệ
thống tập tin của người sửdụng
• Không thểgiao tiếp với một site trên internet.
Mà chỉgiao tiếp với một dịch vụtrên trang
web có applet.
• Không thểchạy bất kỳchương trình nào trên
hệthống của người đọc
• Không thể load bất kỳ chương trình nào
được lưu trên hệthống của người sửdụng
----------------------- Page 144-----------------------
Chu trình sống của applet
----------------------- Page 145-----------------------
Truyền tham sốtới một applet
• Để truyền tham số, sử dụng PARAM
trong thẻHTML
• Ví dụ
<applet code = "Mybutton1" width = “100” height = “100”>
<PARAM NAME = “Mybutton” value = “Display Dialog”>
</applet>
----------------------- Page 146-----------------------
Lớp đồhọa
• Được cung cấp bởi gói AWT
• Cung cấp một tập hợp các phương thức để
vẽnhưsau:
– Oval
– Rectangle
– Square
– Circle
– Lines
– Text in different fonts
----------------------- Page 147-----------------------
Graphical Background
• Các phương thức đểvẽnền :
– getGraphics( )
– repaint( )
– update(Graphics g)
– paint(Graphics g)
----------------------- Page 148-----------------------
Hiển thịchuổi, ký tựvà bytes
• Phương thức đểvẽhoặc hiển thị một chuổi
trên frame
Cú pháp
– drawString(String str, int xCoor, int yCoor);
• Phương thức đểvẽ hoặc hiển thịcác ký tự
trên frame
Cú pháp
– drawChars(char array[ ], int offset, int length,
int xCoor, int yCoor);
• Phương thức đểvẽhoặc hiển thịbytes trên
frame
Cú pháp
– drawBytes(byte array[ ], int offset, int length,
int xCoor, int yCoor);
----------------------- Page 149-----------------------
Vẽcác hình thể
• Phương thức được sử dụng để vẽ
đường thẳng nhưsau
Cú pháp
– drawLine(int x1, int y1, int x2, int y2);
• Các phương thức được sửdụng đểvẽ
đường tròn nhưsau
Cú pháp
– drawOval(int xCoor, int yCoor, int width,
int height);
– setColor(Color c);
– fillOval(int xCoor, int yCoor, int width, int
height);
----------------------- Page 150-----------------------
• Phương thức sửdụng đểvẽhình vuông:
Cú pháp
– drawRect(int xCoor, int yCoor, int width, int
height);
– fillRect(int xCoor, int yCoor, int width, int
height);
• Các phương thức được sửdụng đểvẽ
hình vuông có góc tròn
Cú pháp
– drawRoundRect(int xCoor, int yCoor, int
width, int height, int arcWidth, int
arcHeight);
– fillRoundRect (int xCoor, int yCoor, int
width, int height, int arcWidth, int
arcHeight);
----------------------- Page 151-----------------------
3D Rectangles & Arcs
• Các phương thức được sửdụng đểvẽ
hình 3D Cú pháp
– draw3DRect(int xCoord, int yCoord, int
width, int height, boolean raised);
– drawArc(int xCoord, int yCoord, int width,
int height, int arcwidth, int archeight);
– fillArc(int xCoord, int yCoord, int width, int
height, int arcwidth, int archeight);
----------------------- Page 152-----------------------
Drawing PolyLines
• Các phương thức được sửdụng đểvẽ
nhiều được thẳng
Cú pháp
– drawPolyline(int xArray[ ], int yArray[ ], int
totalPoints);
– g.setFont(new Font("Times Roman",
Font.BOLD,15));
----------------------- Page 153-----------------------
Vẽvà tô các hình đa giác
• Các phương thức đểvẽvà tô các hình đa
giác
Cú pháp
– drawPolygon(int x[ ], int y[ ], int
numPoints);
– fillPolygon(int x[ ], int y[ ], int numPoints);
----------------------- Page 154-----------------------
Màu
• Java sửdụng màu RGB
• Bảng các giá trịmàu
Element Range
Red 0-255
Green 0-255
Blue 0-255
Cú pháp của hàm dựng đểtạo một màu
color(int red, int green, int blue);
----------------------- Page 155-----------------------
• Bảng trình bày các giá trị
thường
Color Red Green Blue
White 255 255 255
Light Gray 192 192 192
Gray 128 128 128
Dark Gray 64 64 64
Black 0 0 0
Pink 255 175 175
Orange 255 200 0
Yellow 255 255 0
Magenta 255 0 255
----------------------- Page 156-----------------------
Font
• Gói java.awt package cung cấp bởi lớp
‘Font’
• Các phương thức của lớp Font:
– getAllFont( )
– getLocalGraphicsEnvironment( )
– getFont( )
– getFontList( )
----------------------- Page 157-----------------------
• Hàm dựng Font nhận 3 tham số
– Tên font trong chuổi định dạng; tên này
có trong phương thức getFontList( ).
– Kiểu của font. Ví dụ như: Font.BOLD,
Font.PLAIN, Font.ITALIC
– Kích thước của font.
• Ví dụ
Font f1 = new Font("SansSerif", Font.ITALIC, 16);
g.setFont(f1);
----------------------- Page 158-----------------------
Lớp FontMetrics
• Đo lường các ký tựkhác nhau hiển thịtrong
các font khác nhau.
• Việc đo lường bao gồm ‘height’, ‘baseline’,
‘ascent’, ‘descent’ và ‘leading’ của font.
• Nó không cụthểvì nó là một lớp trừu tượng
----------------------- Page 159-----------------------
Lớp FontMetrics (tiếp theo…)
• Phương thức:
– getFontMetrics(f1)
– getHeight( )
– getAscent( )
– getDescent( )
– getLeading( )
– getName( )
----------------------- Page 160-----------------------
Kiểu vẽ
• Các đối tượng đểvẽđược sửdụng.
• Method used to make old and new
contents visible on the screen
setXORMode(Color c)
• Method used to revert to the overwrite
mode
setPaintMode( )
----------------------- Page 161-----------------------
Chương VII
Lập trình đa tuyến
----------------------- Page 162-----------------------
Tuyến
• Lập trình đa tuyến là một đặc trưng của
Java
• Tuyến là đơn vịnhỏnhất của đoạn mã
có thểthi hành được mà thực hiện một
công việc riêng biệt
----------------------- Page 163-----------------------
Đa tuyến
• Là khả năng làm việc với nhiều tuyến
• Đa tuyến chuyên sử dụng cho việc
thực thi nhiều công việc đồngthời
• Đa tuyến giảm thời gian rỗi của hệ
thống đến mức thấp nhất.
----------------------- Page 164-----------------------
Tạo và quản lý tuyến (1)
• Khi chương trình Java thực thi hàm
main() tức là tuyến main được thực thi.
Tuyến này được tạo ra một cách tự
động. tại đây :
- Các tuyến con sẽđược tạo ra từđó
- Nó là tuyến cuối cùng kết thúc việc thực
hiện. Trong chốc lát tuyến chính ngừng
thực thi, chương trình bịchấm dứt
• Tuyến có thểđược tạo ra bằng 2 cách:
– Dẫn xuất từlớp Thread
– Dẫn xuất từRunnable.
----------------------- Page 165-----------------------
Vòng đời của một tuyến
----------------------- Page 166-----------------------
Trạng thái của tuyến và các
phương thức của lớp tuyến
• trạng thái: • Phương thức:
– born – start( )
– ready to run
– sleep( )
– running
– wait( )
– sleeping
– waiting – notify( )
– ready – run( )
– blocked – stop( )
– dead
----------------------- Page 167-----------------------
Các phương thức Khác
• enumerate(Thread t)
• getName( )
• isAlive( )
• getPriority( )
• setName(String name)
• join( )
• isDaemon( )
• setDaemon(Boolean on)
• resume( )
• sleep( )
• start( )
----------------------- Page 168-----------------------
Phân chia thời gian giữa các tuyến
• CPU chỉthực thi chỉmột tuyến tại một
thời điểm nhất định.
• Các tuyến có độưu tiên bằng nhau thì
được phân chia thởi gian sửdụng bộvi
xửlý.
----------------------- Page 169-----------------------
tuyến Daemon(ngầm)
• Hai kiểu tuyến trong một chương trình
Java:
– Các tuyến người sửdụng
– tuyến ngầm
• tuyến ngầm dọn rác
----------------------- Page 170-----------------------
Đa tuyến với Applets
• Các chương trình Java dựa trên Applet
thường sửdụng nhiều hơn một tuyến
• Trong đa tuyến với Applets, Lớp
‘java.applet.Applet’ là lớp con được tạo ra
một Applet người sửdụng đã định nghĩa
• nó không thểthực hiện được trực tiếp lớp con
của lớp tuyến trong các applet
• Con đường đểlớp con sửdụng lớp tuyến:
– Sửdụng một đối tượng của tuyến người sửdụng
định nghĩa, mà, lần lượt, dẫn xuất lớp tuyến
– Thực thi chạy giao tiếp (interface)
----------------------- Page 171-----------------------
Sựđồng bộtuyến
• Thâm nhập các tài nguyên/dữliệu bởi
nhiều tuyến
• Sựđồng bộ(Synchronization)
• Sựquan sát (Monitor)
• Mutex
----------------------- Page 172-----------------------
Mã đồng bộ
• Đểthâm nhập sựquan sát của một đối
tượng, lập trình viên sửdụng từ khóa
‘synchronized’ đểgọi một phương thức
hiệu chỉnh (modified method)
• Khi một tuyến đang được thực thi trong
phạm vi một phương thức đồng bộ
(synchronized), bất kỳtuyến khác hoặc
phương thức đồng bộkhác mà cốgắng
gọi nó trong thời gian đó sẽphải đợi
----------------------- Page 173-----------------------
Khuyết điểm của các phương
thức đồng bộ
• Các trạng thái chắc chắn không lợi ích
cho đa tuyến
• Trình biên dịch Java từ Sun không
chứa nhiều phương thức đồng bộ
• Các phương thức đồng bộchậm hơn từ
ba đến bốn lần so với các phương thức
tương ứng không đồng bộ.
----------------------- Page 174-----------------------
Kỹthuật “wait-notify” (đợi –
thông báo) (1)
• tuyến chia các tác vụ thành các đơn vị
riêng biệt và logic (hợp lý)
• Đểtránh trường hợp kiểm soát vòng, Java
bao gồm một thiết kếtốt trong tiến trình kỹ
thuật truyền thông sử dụng các phương
thức “wait()” (đợi), “notify()” (thông báo) và
“notifyAll()” (thông báo hết) :
– wait( )
– notify( )
– notifyAll( )
----------------------- Page 175-----------------------
Kỹthuật “wait-notify” (đợi –
thông báo) (1)
• Các chức năng của các phương thức
“wait()”, “notify()”, và “notifyAll()” là :
– wait( )
– notify( )
– notifyAll( )
• tuyến ưu tiên cao nhất chạy đầu tiên
• Cú pháp của các phương thức:
– final void wait( ) throws IOException
– final void notify( )
– final void notifyAll( )
----------------------- Page 176-----------------------
Một sốđiểm cần nhớtrong khi
sửdụng phương thức wait():
• tuyến đang gọi đưa vào CPU
• tuyến đang gọi đưa vào khóa
• tuyến đang gọi đi vào vùng đợi của
----------------------- Page 177-----------------------
Các điểm chính cần nhớ về
phương thức notify()
• Một tuyến đưa ra ngoài vùng đợi của monitor, và vào
trạng thái sẵn sàng
• tuyến mà đã được thông báo phải thu trởlại khóa của
monitor trước khi nó có thểbắt đầu
• Phương thức notify() là không chính xác
• Trong một số trường hợp này, các phương thức của
monitor đưa ra 2 sựđềphòng:
– Trạng thái của monitor sẽ được kiểm tra trong một vòng lặp
“while” tốt hơn là câu lệnh if
– Sau khi thay đổi trạng thái của monitor, phương thức notifyAll()
sẽđược sửdụng, tốt hơn phương thức notify().
----------------------- Page 178-----------------------
Sựbếtắt (Deadlocks)
• Một “deadlock” (sựbếtắt) xảy ra khi hai tuyến
có một phụthuộc vòng quanh trên một cặp đối
tượng đồng bộ
• Nó khó đểgỡlỗi một bếtắt bởi những nguyên
nhân sau:
– Nó hiểm khi xảy ra, khi hai tuyến chia nhỏ
thời gian trong cùng một con đường
– Nó có thểbao hàm nhiều hơn hai tuyến và
hai đối tượng đồng bộ
• Nếu một chương trình đa tuyến khóa kín
thường xuyên, ngay lập tức kiểm tra lại điều
----------------------- Page 179-----------------------
Thu dọn “rác” (Garbage
collection)
• Cải tạo hoặc làm trống bộnhớđã định vị
cho các đối tượng mà các đối tượng này
không sửdụng trong thời gian dài
• Sự dọn rác thực thi như là một tuyến
riêng biệt có quyền ưu tiên thấp
• Sửdụng câu lệnh sau đểtắt đi sựdọn
rác trong ứng dụng:
java –noasyncgc…
----------------------- Page 180-----------------------
Phương thức finalize() (hoàn
thành)
• Java cung cấp một con đường để làm sạch
một tiến trình trước khi điều khiển trởlại hệđiều
hành
• Phương thức finalize(), nếu hiện diện, sẽđược
thực thi trên mỗi đối tượng, trước khi sựdọn
rác
• Câu lệnh của phương thức finalize() như sau
:
– protected void finalize( ) throws Throwable
• Tham chiếu không phải là sựdọn rác; chỉcác
đối tượng mới được dọn rác
----------------------- Page 181-----------------------
Chương VIII
Các luồng I/O
----------------------- Page 182-----------------------
Các luồng
• Các luồng là những đường ống dẫn đểgửi
và nhận thông tin trong các chương trình
java.
• Khi một luồng đọc hoặc ghi , các luồng khác bị
khoá.
• Nếu lỗi xẩy ra trong khi đọc hoặc ghi luồng,
một ngoại lệsẽkích hoạt.
• Lớp ‘java.lang.System’ định nghĩa luồng nhập
và xuất chuẩn.
----------------------- Page 183-----------------------
Các lớp luồng I/O
• Lớp System.out.
• Lớp System.in.
• Lớp System.err.
----------------------- Page 184-----------------------
Lớp InputStream
• Là lớp trừu tượng
• Định nghĩa cách nhận dữliêu
• Cung cấp số phương thức dùng đểđọc và
các luồng dữliệu làm đầu vào.
• Các phương thức:
– read( )
– available( )
– close ( )
– mark ( )
– markSupported( )
– reset( )
– skip( )
----------------------- Page 185-----------------------
Lớp OutputStream
• Là lớp trừu tượng.
• Định nghĩa cách ghi dữliệu vào luồng.
• Cung cấp tập các phương thức trợ giúp.
trong việc tạo, ghi và xửlý các luồng xuất.
• Các phương thức:
– write(int)
– write(byte[ ])
– write(byte[ ], int, int)
– flush( )
– close( )
----------------------- Page 186-----------------------
Nhập mảng các Byte
• Sửdụng các đệm bộnhớ
• Lớp ByteArrayInputStream
• Tạo ra một luồng nhập từđệm bộnhớ
không gì cảvềmảng các byte.
– Không hỗtrợcác phương thức mới
– Các phương thức nộp chồng của lớp
InputStream, giống như ‘read()’, ‘skip()’,
‘available()’ và ‘reset()’.
----------------------- Page 187-----------------------
Byte Array Output
• sửdụng các vùng đệm bộnhớ
• Lớp ByteArrayOutputStream
– Tạo ra một luồng kết xuất trên mảng byte
– Cung cấp các khả năng bổsung cho mảng
kết xuất tăng trưởng nhằm chừa chổcho dữ
liệu mới ghi vào.
– Cũng cung cấp các phương thức để
chuyển đổi luồng tới mảng byte, hay đối
tượng String.
----------------------- Page 188-----------------------
• Phương thức của lớp
ByteArrayOutputStream :
– reset( )
– size( )
– writeTo( )
----------------------- Page 189-----------------------
Các lớp nhập/xuất tập tin
• Các lớp này trợgiúp trong Java đểhổtrợcác
thao tác nhập và xuất:
– File
– FileDescriptor
– FileInputStream
– FileOutputStream
• Các lớp File, FileDescriptor, và
RandomAccessFile được sửdụng hỗtrợtrực
tiếp hoặc truy cập nhập/xuất ngẫu nhiên.
----------------------- Page 190-----------------------
Lớp tập tin
• Được sửdụng truy cập các đối tượng tập tin
và thw mục
• Những tập tin có tên được đặt tên theo qui
ước của hệđiều hành chủ
• Lớp này cung cấp phương thức khởi tạo để
tạo ra các thư mục và tập tin
• Tất cảcác thao tác thư mục và tập tin đều
được sửdụng các phương thức truy cập và
các phương thức thư mục mà các lớp tập tin
cung cấp
----------------------- Page 191-----------------------
Lớp FileDescriptor
• Cung cấp việc truy cập tới các tập tin
mô tả
• Không cung cấp bất kỳtính rõ nét nào
tới thông tin mà hệđiều hành duy trì.
• Cung cấp chỉmột phương thức gọi là
‘valid( )’
----------------------- Page 192-----------------------
Lớp FileInputStream
• Cho phép đầu vào đọc từ một tập tin
trong một mẫu của một dòng
• Các đối tượng được tạo ra sửdụng chuỗi
tên tập tin, tập tin, đối tượng
FileDescriptor như một tham số.
• Các phương thức nạp chồng của lớp
InputStream. nó cung cấp phương thức
‘finalize( )’ và ‘getFD( )’
----------------------- Page 193-----------------------
Lớp FileOutputStream
• Cho phép kết xuất đểghi ra một luồng
tập tin
• Các đối tượng cũng tạo ra sửdụng một
chuỗi tên tập tin, tạp tin, hay đối tượng
FileDescriptor như một tham số.
• Lớp này nạp chồng các phương thức
của lớp OutputStream và cung cấp
phương thức ‘finalize( )’ và ‘getFD( )’
----------------------- Page 194-----------------------
Nhập xuất lọc
• Lọc:
– Là kiểu luồng sửa đổi cách điều quản một luồng
hiện có.
– về cơ bản được sửdụng đểthích ứng các luồng
theo các nhu cầu của chương trình cụthể.
– Bộlọc nằm giữa luồng nhập và luồng xuất.
– Thực hiện một sốtiến trình đặt biệt trên các byte
được chuyển giao từđầu vào đến kết xuất.
– Có thểphối hợp đểthực hiện một dãy các tuỳchọn
lọc.
----------------------- Page 195-----------------------
Lớp FilterInputStream
• Là lớp trừu tượng.
• Là cha của tất cảcác lớp luồng nhập đã lọc.
• Cung cấp khả năng tạo ra một luồng từluồng
khác.
• Một luồng có thểđọc và cung cấp cung cấp
dưới dạng kết xuất cho luồng khác.
• duy trì một dãy các đối tượng của lớp
‘InputStream’
• Cho phép tạo ra nhiều bộ lọc kết xích
(chained filters
• ).
----------------------- Page 196-----------------------
Lớp FilterOutputStream
• Là dạng bổ trợ cho lớp
‘FilterInputStream’.
• Là cha của tất cảcác lớp luồng kết xuất.
• Duy trì đối tượng của lớp
‘OutputStream’ như là một biến ‘out’.
• Dữliệu ghi ra lớp này có thểsửa đổi để
thực hiện các thao tác lọc, và sau đó
phản hồi đến đối tượng ‘OutputStream’.
----------------------- Page 197-----------------------
Vùng đệm nhập/xuất
• Vùng đệm:
– Là kho lưu trữdữliệu.
– Có thểcung cấp dữliệu thay vì quay trợlại nguồn
dữliệu gốc ban đầu.
– Java sửdụng vùng đệm nhập và kết xuất đểtạm
thời lập cache dữliệu được đọc hoặc ghi vào một
luồng.
• Trong khi thực hiện vùng đệm nhập:
– Số lượng byte lớn được đọc cùng thời điểm, và lưu
trữtrong một vùng đệm nhập.
– Khi chương trình đọc luồng nhập, các byte nhập
được đọc vào vùng đệm nhập.
----------------------- Page 198-----------------------
Vùng đệm nhập/xuất (tt…)
• Trong trường hợp vùng đệm kết xuất, một
chương trình ghi ra một luồng.
• Dữliệu kết xuất đựơc lưu trữtrong một vùng
đệm kết xuất.
• Dữliệu được lưu trữ cho đến khi vùng đệm trợ
nên đầy, hay luồng kết xuất được xảtrống.
• Kết thúc, vùng đệm kết xuất được chuyển gửi
đến đích của luồng xuất.
----------------------- Page 199-----------------------
Lớp BufferedInputStream
• Tựđộng tạo ra và duy trì vùng đệm đểhổtrợ
vùng đệm nhập.
• bởi lớp ‘BufferedInputStream’ là một bộđệm,
nó có thểáp đụng cho một sốcác đối tượng
nhất định của lớp ‘InputStream’.
• Cũng có thể phối hợp các tập tin đầu vào
khác.
• Sửdụng vài biến đểtriển khai vùng đệm nhập.
----------------------- Page 200-----------------------
Lớp BufferedInputStream
(Contd…)
• Định nghĩa hai phương thức thiết lập:
– Một chó phép chỉđịnh kích thước của vùng đệm
nhấp.
– phương thức kia thì không.
• Cả hai phương thức thiết lập đều tiếp nhận một
đối tượng của lớp ‘InputStream’ như một tham
số.
• Nạp chồng các phương thức truy cập mà
InputStream cung cấp, và không đưa vào bất
kỳ phương thức mới nào.
----------------------- Page 201-----------------------
Lớp BufferedOutputStream
• Thực hiện vùng đệm kết xuất theo cách
tương ứng với lớp ‘BufferedInputStream’.
• Định nghĩa hai phương thức thiết lập. Nó cho
phép chúng ta ấn định kích thước của vùng
đệm xuất trong một phương thức thiết lập,
cũng giống như cung cấp kích thước vùng
đệm mặc định.
• Nạp chồng tất cả phương thức của lớp
‘OutputStream’ và không đưa vào bất kỳ
phương thức nào.
----------------------- Page 202-----------------------
Lớp Reader và Writer
• Là các lớp trừu tượng.
• Chúng nằm tại đỉnh của hệ phân cấp
lớp, hỗtrợviệc đọc và ghi các luồng ký
tựunicode.
----------------------- Page 203-----------------------
Lớp Reader
• Hỗtrợcác phương thức sau:
– read( )
– reset( )
– skip( )
– mark( )
– markSupported( )
– close( )
– ready( )
----------------------- Page 204-----------------------
Lớp Writer
• Hỗtrợcác phương thức sau :
– write( )
– flush( )
– close( )
----------------------- Page 205-----------------------
Nhập/xuất chuỗi và mảng ký tự
• Hỗtrợnhập và xuất từcác vùng đệm bộ
nhớ
• Hỗtrợ8 bít ký tựnhập và kết xuất
• Lớp ‘CharArrayReader’ không bổ sung
phương thức mới vào các phương thức
mà lớp ‘Reader’ cung cấp.
----------------------- Page 206-----------------------
Nhập/xuất chuỗi và mảng ký tự
• Lớp ‘CharArrayWriter’ bổ sung phương
thức sau đây vào phương thức của lớp
‘Writer’ cung cấp:
– reset( )
– size( )
– toCharArray( )
– toString( )
– writeTo( )
----------------------- Page 207-----------------------
Nhập/xuất chuỗi và mảng ký tự
• Lớp ‘StringReader’ trợgiúp đọc các ký tựđầu
vào từsâu chuỗi.
• Nó không bổsung bất kỳ phương thức nào
mà lớp Reader cung cấp.
• Lớp ‘StringWriter’ trợgiúp đểghi luồng kết xuất
ký tựra một đối tượng ‘StringBuffer’.
• Lớp này bổsung thêm các phương thức sau:
– getBuffer( )
– toString( )
----------------------- Page 208-----------------------
Lớp PrinterWriter
• Thực hiện một kết xuất.
• Lớp này có phương thức bổsung , trợgiúp in
các kiểu dữliệu cơ bản .
• Lớp PrintWriter thay thếlớp ‘PrintStream’
• Thực tế cải thiện lớp ‘PrintStream’; lớp này
dùng một dấu tách dòng phụthuộc nền tảng
điểm các dòng thay vì ký tự‘
’.
• Cung cấp phần hỗtrợ cho các ký tựunicode
so với PrintStream.
• Các phương thức:
– checkError( )
----------------------- Page 209-----------------------
Giao diện DataInput
• Được sửdụng đểđọc các byte từ luồng nhị
phân, và
• Is used to read bytes from a binary stream,
and xây dựng lại dữliệu trong một sốkiểu dữ
liệu nguyên thuỷ.
• Cho phép chúng ta chuyển đổi dữ liệu từtừ
khuôn dạng UTF-8 được sửa đổi Java đến
dạng chuỗi
• Định nghiã số phương thức, bao gồm các
phương thức đểđọc các kiểu dữliệu nguyên
thuỷ.
----------------------- Page 210-----------------------
Những phương thức giao diện
DataInput
• boolean readBoolean( • float readFloat( )
• int readInt( )
• byte readByte( ) • double readDoubl
• char readChar( )
• String readUTF( )
• short readShort( )
• String readLine( )
• long readLong( )
----------------------- Page 211-----------------------
Giao diện DataOutput
• Được sửdụng đểxây dựng lại dữliệu một số
kiểu dữ liệu nguyên thuỷvào trong dãy các
byte
• Ghi các byte dữliệu vào luồng nhịphân
• Cho phép chúng ta chuyển đổi một chuỗi vào
khuôn dạng UTF-8 được sửa đổi Java và viết
nó vào trong một dãy.
• Định nghĩa một số phương thức và tất cả
phương thức kích hoạt IOException trong
trường hợp lỗi.
----------------------- Page 212-----------------------
Các phương thức giao diện
DataOutput
• void writeBoolean(boolean b)
• void writeByte( int value)
• void writeChar(int value)
• void writeShort(int value)
• void writeLong(long value)
• void writeFloat(float value)
• void writeInt(int value)
• void writeDouble(double value)
• void writeUTF Strin value
----------------------- Page 213-----------------------
Lớp RandomAccessFile
• Cung cấp khả năng thực hiện I/O theo các vị
trí cụthểbên trong một tập tin.
• dữ liệu có thể đọc hoặc ghi ngẫu nhiên ở
những vịtrí bên trong tập tin thay vi một kho
lưu trữthông tin liên tục.
• phương thức ‘seek( )’ hỗtrợtruy cập ngẫu
nhiên.
• Thực hiện cảđầu vào và đầu ra dữliệu.
• Hỗtrợcác cấp phép đọc và ghi tập tin cơ
bản.
• Kế thừa các phương thức từ các lớp
‘ ’ ‘ ’
----------------------- Page 214-----------------------
Các phương thức của lớp
RandomAccessFile
• seek( )
• getFilePointer( )
• length( )
----------------------- Page 215-----------------------
Gói java.awt.print
• Gồm có các giao diện
– Pageable:
• Định nghĩa các phương thức dùng đểcác đối tượng
biểu thịcác trang sẽđược in.
• Chỉđịnh số trang đã được in, và trang hiện tại hay là
tranh giới trang đã được in
– Printable:
• Chi định phương thức ‘print( )’ sửdụng đểin một trang
trên đối tượng ‘Graphics’
– PrinterGraphics:
• Cung cáp khả năng truy cập đối tượng ‘PrinterJob’
----------------------- Page 216-----------------------
• Giao diê n ‘PrinterGraphics’ cung cấp các lớp
sau:
– Paper
– Book
– PageFormat
– PrinterJob
• Gói ‘java.awt.print’ kích hoạt các ngoại lệ:
– PrinterException
– PrinterIOException
– PrinterAbortException
----------------------- Page 217-----------------------
Chương IX
KẾT NỐI CSDL
Java Database Connectivity
----------------------- Page 218-----------------------
Tổng quan
• JDBC cung cấp tập các lớp và interface
cho phép chương trình Java có thểnói
chuyện được với hệCSDL
• Tập các lớp của JDBC
có thểlàm việc được với
mọi hệcsdl.
----------------------- Page 219-----------------------
• Có 3 bước chính đểkết nối CSDL.
– Nạp database drivers
– Tạo nối kết, Tạo đối tượng Connection
– Tạo đối tượng Statement đểthực thi các
lệnh sql..
----------------------- Page 220-----------------------
Ví dụ
try{
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
Connection con=DriverManager.getConnection("jdbc:odbc:ATM");
Statement stmt = con.createStatement();
:
:
:
:
----------------------- Page 221-----------------------
Database URL
• Database URL là một chuổi được dùng
đểkết nối csdl.
• cú pháp :
• jdbc:subprotocol name:other_stuff
• The subprotocol name được dùng tuỳ
vào loại driver sửdụng đểkết nối csdl.
• ví dụ: subprotocol name là odbc nếu
driver là cầu nối jdbcodbc
• Other_stuff cũng phụthuộc vào loại
driver nào được sửdụng. ví dụnếu
driver là cầu nối jdbcodbc thì thành phần
này là tên của đối tượng ODBC
----------------------- Page 222-----------------------
Database Driver
• Bảo đảm ứng dụng java tương tác với mọi
csdl dưới một cách thức chuẩn và duy nhất.
• Bảo đảm những yêu cầu từ chương trình sẽ
được biểu diễn trong csdl dưới một ngôn ngữ
mà csdl hiểu được
• nhận các yêu cầu từclient, chuyển nó nó vào
định dạng mà csdl có thểhiểu được và thể
hiện trong csdl.
• Nhận các phản hồi, chuyển nó ngược lại định
dạng dữliệu java và thểhiện trong ứng dụng.
----------------------- Page 223-----------------------
Nạp Driver
• Lớp DriverManager chịu trách nhiệm nạp driver và
tạo kết nối đến csdl.
DriverManager.registerDriver(new sun.jdbc.odbc.JdbcOdbcDriver());
• hoặc
Class.forName(String);
– This returns the object associated with the class with
the given string name.
– Class.forName(“sun.jdbc.odbc.JdbcOdbcDriver”);
• Equivalent to:
new sun.jdbc.odbc.JdbcOdbcDriver();
If you have a driver from another vendor, then
find out the class name of that driver and load it
instead.
----------------------- Page 224-----------------------
JDBC Driver
• Có 4 loại JDBC Driver
– Loại 1: JDBC/ODBC
– Loại 2: Native-API
– Loại 3: Open Protocol-Net
– Loại 4: Proprietary-Protocol-Net
• Loại 2,3,4 nói chung được viết bởi nhà
cung cấp csdl. hiệu quả hơn loại 1
nhưng thực hiện phức tạp hơn.
----------------------- Page 225-----------------------
Loại I JDBC/ODBC
• jdk hỗtrợcầu nối jdbc-odbc (jdbc-odbc
bridge).
• Mềm dẻo nhưng không hiệu quả.
Aplication Client
Aplication
JDBC Driver
JDBC Driver Disk
Disk
ODBC Driver
ODBC Driver
Network Interface
Network Interface
Database
Database
Server
----------------------- Page 226-----------------------
Loại 2: Native-API
• Tốt hơn loại 1, loại này cho phép JDBC giao
tiếp trực tiếp với các driver hay các hàm API
của CSDL.
Aplication Client
Aplication
JDBC Driver
JDBC Driver Disk
Disk
Native Database Library
Native Database Library
Network Interface
Network Interface
Database
Database
Server
----------------------- Page 227-----------------------
Loại 3: Open Protocol-Net
• Drivers
– Có thểchuyển các yêu cầu đến các csdl nằm ởxa.
– Có thểgiao tiếp với nhiều loại CSDL.
– Không phải của nhà cung cấp csdl
Aplication Client
Aplication
– Tất cảbằng mã java
JDBC Driver Client
JDBC Driver Client Disk
Disk
Network Interface
Network Interface
Server
JDBC Driver Server
JDBC Driver Server
Database
Database
Native Database Library
Native Database Library
----------------------- Page 228-----------------------
Loại 4: Proprietary-Protocol Net
• 100% java
• Có khả năng giao tiếp trực tiếp với hệ
Aplication Client
Aplication
CSDL không cần chuyển đổi
JDBC Driver
JDBC Driver Disk
Disk
Network Interface
Network Interface
Database
Database
Server
----------------------- Page 229-----------------------
Gói Java.sql
• Cung cấp tập hợp các lớp và interface dùng để
trao đổi với CSDL.
• Các lớp
– DriverManager
– Date, Time
– Timestamp
– Types
• Các Interfaces
Driver PreparedStatement
Connection CallableStatement
DatabaseMetaData ResultSet
Statement ResultSetMetaData
----------------------- Page 230-----------------------
Đối tượng Statement
• Đối tượng Connection chứa liên kết trực
tiếp đến csdl.
• Sửdụng đối tượng Connection đểtạo đối
tượng Statement.
– Statement s = con.createStatement();
• Đối tượng này có nhiệm vụgửi các câu
lệnh sql đến csdl.
• executeQuery(String) or
executeUpdate(String) method
• Cùng một đối tượng Statement có thểsử
dụng cho nhiều câu lệnh sql khác nhau.
----------------------- Page 231-----------------------
• Có 3 phương thức thực thi
– executeQuery()
– executeUpdate()
– execute()
• The executeQuery()
– Nhận câu lệnh SQL (select) làm đối số, trảlại đối
tượng ResultSet
• ResultSet rs = s.executeQuery(“SELECT *
FROM Books”);
----------------------- Page 232-----------------------
• Phương thức executeUpdate()
– Nhận các câu lệnh sql dạng cập nhật
– Trảlại sốnguyên biểu thịsốhàng được cập
nhật.
– UPDATE, INSERT, or DELETE.
• Phương thức execute()
– Được áp dụng cho trường hợp không rõ loại
sql nào được thựưc hiện.
– Được áp dụng cho trường hợp câu lệnh sql
đwocj tạo ra tựđộng bởi chương trình.
----------------------- Page 233-----------------------
ResultSet
• Chứa một hoặc nhiều hàng dữliệu từviệc thực
hiện câu lệnh truy vấn.
• Có thểlấy dữliệu từng hàng dữliệu một trong
ResultSet.
• Sửdụng phương thức next() đểdi chuyển đến
hàng dữliệu tiếp theo trong ResultSet.
• Hàm next() trảlại true chỉrằng hàng chứa dữ
liệu, trảlại false hàng cuối không chứa dữliệu.
• Thực hiện
while (rs.next()){
// examine a row from the results
}
----------------------- Page 234-----------------------
• Đểlấy dữliệu ởcác cột trên mỗi hàng
của ResultSet, ta dùng các phương
thức.
– get type(int | String)
• Đối sốlà chỉsốcột tính từ1.
• Áp dụng cho các cột có kiểu dữliệu là int, float,
Date.....
– Ví dụ:
• String isbn = rs.getString(1); // Column 1
• float price = rs.getDouble(“Price”);
----------------------- Page 235-----------------------
ResultSet Metadata
• Đối tượng này cho biết thông tin vềResultSet
• ResultSet rs = stmt.executeQuery(SQLString);
ResultSetMetaData rsmd = rs.getMetaData();
int numberOfColumns = rsmd.getColumnCount();
• getColumnName(int column)
----------------------- Page 236-----------------------
Prepared Statements
• To execute a Statement object many times, it
will reduce execution time to use
PreparedStatement object
• PreparedStatement object
– unlike a Statement object, it is given an SQL
statement when it is created.
– The advantage to this is that in most cases, this
SQL statement will be sent to the DBMS right
away, where it will be compiled.
– As a result, the PreparedStatement object
contains not just an SQL statement, but an SQL
statement that has been precompiled.
– This means that when the Pre aredStatement is
----------------------- Page 237-----------------------
Các đối tượng Statement khác
• Prepared Statements
• Callable Statement
----------------------- Page 238-----------------------
Database Metadata
• Đối tượng này cho biết thông tin vềcsdl.
----------------------- Page 239-----------------------
Chương trình m u
import java.sql.*;
class JDBCDemo1 {
public static void main(String[] args) {
try{
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
Connection con=DriverManager.getConnection("jdbc:odbc:Accserver");
Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery(args[0]);
ResultSetMetaData rsmd = rs.getMetaData();
int numberOfColumns = rsmd.getColumnCount();
for(int j=1; j<=numberOfColumns;j++) {
System.out.println(rsmd.getColumnLabel(j));
}
while(rs.next()) {
for(int i=1; i<=numberOfColumns;i++){
System.out.println(rs.getObject(i));
}}
rs.close();
stmt.close();
catch Exce tion e S stem.out. rintln "Error " + e
Bạn đang đọc truyện trên: Truyen2U.Pro