Giáo trình Lập trình nâng cao với Java (Advanced Java programming)

LẬP TRÌNH NÂNG CAO VỚI JAVA 
(Advanced Java programming) 
Bộ môn Công nghệ Phần mềm 
Đại học SPKT Hưng Yên 
Bài 1. Kế thừa và đa hình trong Java ............................................................................................................. 9 
1.1. Đối tượng trong Java ..................................................................................................................... 9 
1.2 Lớp trong Java ............................................................................................................................... 9 
1.3 Phương thức trong Java .............................................................................................................. 11 
1.4 Tạo một đối tượng trong Java .................................................................................................... 11 
1.5 Truy cập các biến instance và các phương thức trong Java ........................................................ 12 
1.6 Đối tượng vô danh (annonymous) trong Java ............................................................................ 16 
Bài 3: Xử lý ngoại lệ ..................................................................................................................................... 19 
3.1 Exception là gì? ................................................................................................................................. 19 
Cấp bậc exception trong Java ............................................................................................................. 20 
Các phương thức của lớp Exceptions trong Java ................................................................................ 21 
Các tình huống phổ biến mà Exception có thể xảy ra ......................................................................... 22 
Các từ khóa để Xử lý ngoại lệ trong Java ............................................................................................ 23 
3.2 Khối try trong Java ............................................................................................................................ 23 
Cú pháp của khối try-catch trong Java ................................................................................................ 23 
Cú pháp của khối try-finally trong Java ............................................................................................... 23 
Khối catch trong Java .......................................................................................................................... 23 
Vấn đề khi không có Exception Handling ............................................................................................ 23 
Xử lý vấn đề trên bởi Exception Handling trong Java ......................................................................... 24 
Chế độ làm việc nội tại của khối try-catch trong Java......................................................................... 24 
Nhiều khối catch trong Java ................................................................................................................ 25 
Lồng khối try trong Java ...................................................................................................................... 26 
Tại sao sử dụng các khối try lồng nhau trong Java ............................................................................. 26 
Ví dụ về các khối try lồng nhau trong Java .......................................................................................... 27 
3.3 Sự sử dụng khối finally trong Java .................................................................................................... 28 
Tình huống 1: ở đây exeption không xuất hiện .................................................................................. 28 
Tình huống 2: exception xuất hiện và không được xử lý. ................................................................... 28 
Tình huống 3: exception xảy ra và được xử lý. ................................................................................... 29 
3.6 Phân biệt final, finally, và finalize trong Java .................................................................................... 29 
Ví dụ final trong Java ........................................................................................................................... 30 
Ví dụ finally trong Java ........................................................................................................................ 30 
Ví dụ finalize trong Java ...................................................................................................................... 30 
3.4 Từ khóa throw trong Java ................................................................................................................ 31 
Ví dụ từ khóa throw trong Java ........................................................................................................... 31 
Quá trình lan truyền Exception trong Java ......................................................................................... 31 
3.5 Từ khóa throws trong Java ................................................................................................................ 32 
Cú pháp của từ khóa throws trong Java ............................................................................................. 33 
Ví dụ về throws trong Java .................................................................................................................. 33 
Trường hợp 1: Bạn xử lý exception..................................................................................................... 34 
Trường hợp 2: Bạn khai báo exception ............................................................................................... 35 
A. Chương trình ví dụ nếu exception không xuất hiện ....................................................................... 35 
B. Chương trình ví dụ nếu exception xuất hiện .................................................................................. 35 
Phân biệt throw và throws trong Java ................................................................................................ 36 
Ví dụ về throw trong Java ................................................................................................................... 37 
Ví dụ về throws trong Java .................................................................................................................. 37 
Ví dụ về throw và throws trong Java................................................................................................... 37 
3.6 ExceptionHandling và Ghi đè phương thức trong Java .................................................................... 37 
3.7. Custom Exception trong Java ........................................................................................................... 41 
Bài 5. String ................................................................................................................................................. 43 
5.1 String trong Java ................................................................................................................................ 43 
Chuỗi trong Java là gì ......................................................................................................................... 43 
Cách tạo đối tượng String trong Java .................................................................................................. 43 
Sử dụng từ khóa new .......................................................................................................................... 44 
Tạo các String được định dạng trong Java .......................................................................................... 45 
5.2 Immutable String trong Java ............................................................................................................. 46 
Tại sao đối tượng String là Immutable trong Java? ............................................................................ 47 
5.3. So sánh chuỗi trong Java .................................................................................................................. 47 
So sánh chuỗi bởi phương thức equals() trong Java ........................................................................... 47 
So sánh chuỗi với toán tử == trong Java ............................................................................................. 48 
So sánh chuỗi bởi phương thức compareTo() trong Java ................................................................... 49 
5.4 Nối chuỗi trong Java .......................................................................................................................... 49 
Nối chuỗi bởi toán tử + trong Java ...................................................................................................... 49 
Nối chuỗi bởi phương thức concat() trong Java .................................................................................. 50 
5.5 Chuỗi con trong Java ......................................................................................................................... 51 
Ví dụ về chuỗi con trong Java ............................................................................................................. 51 
5.6 Phương thức của lớp String trong Java ............................................................................................. 52 
Phương thức toUpperCase() và toLowerCase() của lớp String trong Java ......................................... 52 
Phương thức trim() của lớp String trong Java ..................................................................................... 53 
Phương thức startWith() và endsWith() của lớp String trong Java ..................................................... 53 
Phương thức charAt() của lớp String trong Java................................................................................. 53 
Phương thức length() của lớp String trong Java ................................................................................. 53 
Phương thức intern của lớp String trong Java ..................................................................................... 53 
Phương thức valueOf() của lớp String trong Java............................................................................... 54 
Phương thức replace() của lớp String trong Java ................................................................................ 54 
5.7 Lớp StringBuffer trong Java............................................................................................................... 54 
Các Constructor quan trọng của lớp StringBuffer trong Java ............................................................. 54 
Các phương thức quan trọng của lớp StringBuffer trong Java ........................................................... 55 
Chuỗi dạng mutable là gì? .................................................................................................................. 55 
Phương thức append() của lớp StringBuffer trong Java ..................................................................... 55 
Phương thức insert() của lớp StringBuffer trong Java ........................................................................ 56 
Phương thức replace() của lớp StringBuffer trong Java ..................................................................... 56 
Phương thức delete() của lớp StringBuffer trong Java ....................................................................... 57 
Phương thức reverse() của lớp StringBuffer trong Java ..................................................................... 57 
Phương thức capacity() của lớp StringBuffer trong Java .................................................................... 57 
Phương thức ensureCapacity() của lớp StringBuffer trong Java ........................................................ 58 
5.8 StringBuilder trong Java .................................................................................................................... 59 
Các Constructor quan trọng của lớp StringBuilder trong Java ........................................................... 59 
Các phương thức quan trọng của lớp StringBuffer trong Java ........................................................... 59 
Phương thức append() của lớp StringBuffer trong Java ..................................................................... 60 
Phương thức insert() của lớp StringBuffer trong Java ........................................................................ 61 
Phương thức replace() của lớp StringBuffer trong Java ..................................................................... 61 
Phương thức delete() của lớp StringBuffer trong Java ....................................................................... 61 
Phương thức reverse() của lớp StringBuffer trong Java ..................................................................... 62 
Phương thức capacity() của lớp StringBuffer trong Java .................................................................... 62 
Phương thức ensureCapacity() của lớp StringBuffer trong Java ........................................................ 63 
5.9 So sánh lớp String và StringBuffer trong Java ................................................................................... 64 
Kiểm tra hiệu suất của lớp String và StringBuffer trong Java ............................................................ 64 
Kiểm tra HashCode của lớp String và StringBuffer trong Java .......................................................... 66 
5.10 So sánh lớp StringBuffer và StringBuilder trong Java ..................................................................... 67 
Ví dụ về lớp StringBuffer trong Java .................................................................................................. 67 
Ví dụ về lớp StringBuilder trong Java ................................................................................................ 67 
Kiểm tra hiệu suất của lớp StringBuffer và StringBuilder trong Java ................................................ 68 
Bài 7. Bài tập và thảo luận về Case study ATM (1) ...................................................................................... 70 
7.1. Các yêu cầu của ATM ....................................................................................................................... 70 
7.2. Cách xây dựng lớp và đối tượng ...................................................................................................... 71 
1. Các thành phần trong bản vẽ Class ................................................................................................. 71 
2. Relationship (Quan hệ) ................................................................................................................... 72 
3. Cách xây dựng bản vẽ Class ........................................................................................................... 75 
7.2. Phân tích theo mô hình hướng đối ...  
import java.math.* ; // de ho tro BigDecimal va BigInteger 
Bước 2: Đăng ký JDBC driver 
Trước khi sử dụng bất kỳ driver nào, bạn cần đăng ký nó. Trong chương trình, bạn chỉ 
cần thực hiện một lần tiến trình đăng ký này, theo một trong hai cách sau: 
Sử dụng phương thức Class.forName() 
Sử dụng phương thức Class.forName() là hướng tiếp cận chung và phổ biến để đăng ký 
một driver. Dưới đây là cú pháp: 
public static void Class.forName(String ten_lop) throws ClassNotFoundException 
Ví dụ, để đăng ký Oracle driver, bạn sử dụng mẫu sau: 
try { 
 Class.forName("oracle.jdbc.driver.OracleDriver").newInstance(); 
} 
catch(ClassNotFoundException ex) { 
 System.out.println("Error: khong the tai lop Driver!"); 
 System.exit(1); 
catch(IllegalAccessException ex) { 
 System.out.println("Error: xuat hien van de truy cap trong khi tai!"); 
 System.exit(2); 
catch(InstantiationException ex) { 
 System.out.println("Error: khong the khoi tao Driver!"); 
 System.exit(3); 
} 
Sử dụng DriverManager.registerDriver() 
Nếu bạn đang sử dụng một JDK không tuân theo JVM (được cung cấp bởi Microsoft 
chẳng hạn), thì bạn nên sử dụng phương thức DriverManager.registerDriver() này. Ví dụ: 
try { 
 Driver myDriver = new oracle.jdbc.driver.OracleDriver(); 
 DriverManager.registerDriver( myDriver ); 
} 
catch(ClassNotFoundException ex) { 
 System.out.println("Error: khong the tai lop Driver!"); 
 System.exit(1); 
} 
Bước 3: Tạo địa chỉ Database URL chính xác 
Đây là địa chỉ trỏ tới cơ sở dữ liệu của bạn. Việc tạo một địa chỉ Database URL chính xác 
là rất quan trọng, và đây thường là bước hay xuất hiện lỗi trong khi thành lập một kết nối. 
Bảng dưới đây liệt kê một số tên JDBC driver và Database URL phổ biến: 
Trong đó, hostname là tên server mà cơ sở dữ liệu đang chạy (có thể là localhost hoặc địa 
chỉ IP của bạn); port Number là số hiệu cổng và databaseName là tên của cơ sở dữ liệu. 
RDBMS Tên JDBC Driver Định dạng URL 
MySQL com.mysql.jdbc.Driver jdbc:mysql://hostname/ databaseName 
ORACLE oracle.jdbc.driver.OracleDriver jdbc:oracle:thin:@hostname:port 
Number:databaseName 
DB2 COM.ibm.db2.jdbc.net.DB2Driver jdbc:db2:hostname:port Number/databaseName 
Sybase com.sybase.jdbc.SybDriver jdbc:sybase:Tds:hostname: port 
Number/databaseName 
Phần in đậm là phần bạn không nên thay đổi, bạn chỉ cần thay đổi phần còn lại theo yêu 
cầu của bạn. 
Bước 4: Tạo đối tượng Connection 
Sau khi đã tải driver, bạn có thể thiết lập một kết nối bởi sử dụng phương thức 
DriverManager.getConnection(). Phương thức này có ba mẫu: 
Mẫu 1: getConnection(String url) 
Mẫu phương thức này chỉ yêu cầu một Database URL. Tuy nhiên, trong trường hợp này, 
Database URL cũng đã bao cả username và password. 
Ví dụ: giả sử bạn đang sử dụng Thin driver của Oracle, với host name là vietjack, cổng là 
3306 và tên cơ sở dữ liệu là sinhvien, thì Database URL sẽ là: 
jdbc:oracle:thin:username/password@vietjack:3306:sinhvien 
Do đó, kết nối trên có thể được tạo như sau: 
String URL = "jdbc:oracle:thin:username/password@vietjack:3306:sinhvien"; 
Connection conn = DriverManager.getConnection(URL); 
Mẫu 2: getConnection(String url, Properties info) 
Mẫu phương thức này yêu cầu một Database URL và một đối tượng Properties. Một đối 
tượng Properties giữ một tập hợp các cặp key-value. Mẫu này được sử dụng để truyền các 
thuộc tính tới driver trong một lời gọi tới phương thức getConnection(). 
Để tạo kết nối như ví dụ trên, bạn sử dụng: 
import java.util.*; 
String URL = "jdbc:oracle:thin:@vietjack:3306:sinhvien"; 
Properties info = new Properties( ); 
info.put( "user", "username" ); 
info.put( "password", "password" ); 
Connection conn = DriverManager.getConnection(URL, info); 
Mẫu 3: getConnection(String url, String user, String password) 
Đây là mẫu được sử dụng phổ biến nhất. Bạn sử dụng phương thức này để truyền một 
Database URL, một username và một password. 
Cũng sử dụng ví dụ trên, bây giờ bạn phải gọi phương thức getConnection() này với 
username và password chính xác để nhận được một đối tượng Connection như sau: 
String URL = "jdbc:oracle:thin:@vietjack:3306:sinhvien"; 
String USER = "username"; 
String PASS = "password" 
Connection conn = DriverManager.getConnection(URL, USER, PASS); 
Đóng kết nối JDBC 
Garbage Collector của Java sẽ đóng kết nối khi nó thực hiện tiến trình xóa các đối tượng 
đã cũ. Tuy nhiên, sau khi đã thực hiện xong tác vụ với Database, bạn nên đóng tất cả kết 
nối tới cơ sở dữ liệu. Bước thực hành này là cần thiết và thực sự tốt, vì đôi khi việc quá 
tin tưởng vào trình dọn rác sẽ gây ra những hậu quả không mong muốn. 
Để bảo đảm rằng một kết nối đã được đóng, bạn có thể cung cấp một khối finally trong 
phần code. Khối finally luôn luôn được thực thi, nếu không thì một exception sẽ xuất 
hiện. 
Để đóng kết nối đã mở ở trên, bạn nên gọi phương thức close() có cú pháp như sau: 
public void conn.close() throws SQLException 
Bài 18. Bài tập và thảo luận về Case study 
ATM (3) 
18.1. Cài đặt các chức năng và giao diện 
18.2. Chạy và kiểm tra lỗi 
Bài 20. Bài tập và thảo luận tổng kết môn 
học 
20.1. Những ưu điểm của lập trình hướng đối tượng 
OOP giúp việc thiết kế, phát triển và bảo trì dễ dàng hơn trong khi với lập trình hướng 
thủ tục thì việc quản lý code là khá khó khăn nếu lượng code tăng lên. Điều này làm tăng 
hiệu quả có quá trình phát triển phần mềm. 
OOP cung cấp Data Hiding (ẩn dữ liệu) trong khi đó trong hướng thủ tục một dữ liệu 
toàn cục có thể được truy cập từ bất cứ đâu. 
OOP cung cấp cho bạn khả năng để mô phỏng các sự kiện trong thế giới thực một cách 
hiệu quả hơn. Chúng ta có thể cung cấp giải pháp cho các vấn đề trong thế giới thực nếu 
chúng ta sử dụng Lập trình hướng đối tượng. 
20.2. Phân tích bài toán theo mô hình hướng đối tượng 
Trong kỹ thuật lập trình hướng đối tượng, chúng ta thiết kế một chương trình bởi sử dụng 
các lớp và các đối tượng. 
Object - Đối tượng là thực thể mang tính vật lý cũng như mang tính logic, trong khi lớp 
chỉ là thực thể logic. Đối tượng có các trạng thái và các hành vi. Ví dụ: Một dog có trạng 
thái là color, name, breed (dòng dõi) và cũng có các hành vi: Wag (vẫy đuôi), bark (sủa), 
eat (ăn). Một đối tượng là một instance (ví dụ,trường hợp) của một lớp. 
Class - Một lớp là một nhóm các đối tượng mà có các thuộc tính chung. Lớp là một 
Template hoặc bản thiết kế từ đó đối tượng được tạo. 
Đối tượng trong Java 
Đó là một thực thể có trạng thái và hành vi, ví dụ như bàn, ghế, xe con, mèo,  Nó có 
thể mang tính vật lý hoặc logic. Ví dụ về logic đó là Banking system. 
Một đối tượng có ba đặc trưng sau: 
Trạng thái: biểu diễn dữ liệu (giá trị) của một đối tượng. 
Hành vi: biểu diễn hành vi (tính năng) của một đối tượng như gửi tiền vào, rút tiền ra,  
Nhận diện: việc nhận diện đối tượng được triển khai thông qua một ID duy nhất. Giá trị 
của ID là không thể nhìn thấy với người dùng bên ngoài. Nhưng nó được sử dụng nội tại 
bởi JVM để nhận diện mỗi đối tượng một cách duy nhất. 
Ví dụ: Bút là một đối tượng. Nó có tên là Thiên Long, có màu trắng,  được xem như là 
trạng thái của nó. Nó được sử dụng để viết, do đó viết là hành vi của nó. 
Đối tượng là sự thể hiện (Instance) của một lớp. Lớp là một Template hoặc bản thiết kế 
từ đó đối tượng được tạo. Vì thế đối tượng là Instance (kết quả) của một lớp. 
Lớp trong Java 
Một lớp là một nhóm các đối tượng mà có các thuộc tính chung. Lớp là một Template 
hoặc bản thiết kế từ đó đối tượng được tạo. Một lớp trong Java có thể bao gồm: 
Thành viên dữ liệu 
Phương thức 
Constructor 
Block 
Lớp và Interface 
Cú pháp để khai báo một lớp 
class ten_lop{ 
 thanh_vien_du_lieu; 
 phuong_thuc; 
} 
Ví dụ đơn giản về Lớp và Đối tượng trong Java 
Trong ví dụ này, chúng ta tạo một lớp Student có hai thành viên dữ liệu là id và name. 
Chúng ta đang tạo đối tượng của lớp Student bởi từ khóa new và in giá trị đối tượng. 
class Student1{ 
 int id; //thanh vien du lieu (cung la bien instance) 
 String name; //thanh vien du lieu (cung la bien instance) 
 public static void main(String args[]){ 
 Student1 s1=new Student1(); //tao mot doi tuong Student 
 System.out.println(s1.id); 
 System.out.println(s1.name); 
 } 
} 
Một lớp có thể chứa bất kỳ loại biến sau: 
Biến Local: Các biến được định nghĩa bên trong các phương thức, constructor hoặc 
block code được gọi là biến Local. Biến này sẽ được khai báo và khởi tạo bên trong 
phương thức và biến này sẽ bị hủy khi phương thức đã hoàn thành. 
Biến Instance: Các biến instance là các biến trong một lớp nhưng ở bên ngoài bất kỳ 
phương thức nào. Những biến này được khởi tạo khi lớp này được tải. Các biến instance 
có thể được truy cập từ bên trong bất kỳ phương thức, constructor hoặc khối nào của lớp 
cụ thể đó. 
Biến Class: Các biến class là các biến được khai báo với một lớp, bên ngoài bất kỳ 
phương thức nào, với từ khóa static. 
Phương thức trong Java 
Trong Java, một phương thức là khá giống hàm, được sử dụng để trưng bày hành vi của một đối tượng. 
Phương thức giúp code tăng tính tái sử dụng và tối ưu hóa code. 
Từ khóa new được sử dụng để cấp phát bộ nhớ tại runtime. 
Constructor trong Java: 
Khi bàn luận về các lớp, một trong những chủ đề quan trọng là các constructor. Mỗi lớp có một constructor. 
Nếu chúng ta không viết một constructor một cách rõ ràng cho một lớp thì bộ biên dịch Java xây dựng một 
constructor mặc định cho lớp đó. 
Mỗi khi một đối tượng mới được tạo ra, ít nhất một constructor sẽ được gọi. Quy tắc 
chính của các constructor là chúng có cùng tên như lớp đó. Một lớp có thể có nhiều hơn 
một constructor. 
Sau đây là ví dụ về một constructor: 
public class Xecon{ 
 public Xecon(){ 
 } 
 public Xecon(String ten){ 
 // Contructor nay co mot tham so la ten. 
 } 
} 
Java cũng hỗ trợ Lớp Singleton trong Java, ở đây bạn sẽ có thể tạo chỉ một instance của 
một lớp. 
Tạo một đối tượng trong Java: 
Như đã đề cập trước đó, một lớp cung cấp bản thiết kế cho các đối tượng. Vì thế, về cơ 
bản, một đối tượng được tạo từ một lớp. Trong Java, từ khóa new được sử dụng để tạo 
một đối tượng mới. 
Có ba bước khi tạo một đối tượng từ một lớp: 
Khai báo: Một khai báo biến với một tên biến với một loại đối tượng. 
Cài đặt: Từ khóa new được sử dụng để tạo đối tượng 
Khởi tạo: Từ khóa new được theo sau bởi một lời gọi một constructor. Gọi hàm này khởi 
tạo đối tượng mới. 
Dưới đây là ví dụ về tạo một đối tượng: 
public class Xecon{ 
 public Xecon(String ten){ 
 // Contructor nay co mot tham so la ten. 
 System.out.println("Ten xe la :" + ten ); 
 } 
 public static void main(String []args){ 
 // Lenh sau se tao mot doi tuong la Xecuatoi 
 Xecon Xecuatoi = new Xecon( "Toyota" ); 
 } 
} 
Nếu chúng ta biên dịch và chạy chương trình, nó sẽ cho kết quả sau: 
Ten xe la :Toyota 
Truy cập các biến instance và các phương thức trong Java 
Các biến instance và các phương thức được truy cập thông qua các đối tượng được tạo. 
Để truy cập một biến instance, path sẽ là như sau: 
/* Dau tien, ban tao mot doi tuong */ 
Doituongthamchieu = new Constructor(); 
/* Sau do ban goi mot bien nhu sau */ 
Doituongthamchieu.TenBien; 
/* Bay gio ban co the goi mot phuong thuc lop nhu sau */ 
Doituongthamchieu.TenPhuongThuc(); 
Ví dụ: 
Ví dụ này giải thích cách để truy cập các biến instance và các phương thức của một lớp: 
public class Xecon{ 
 int Giaxe; 
 public Xecon(String ten){ 
 // Contructor nay co mot tham so la ten. 
 System.out.println("Ten xe la :" + ten ); 
 } 
 public void setGia( int gia ){ 
 Giaxe = gia; 
 } 
 public int getGia( ){ 
 System.out.println("Gia mua xe la :" + Giaxe ); 
 return Giaxe; 
 } 
 public static void main(String []args){ 
 /* Tao doi tuong */ 
 Xecon Xecuatoi = new Xecon( "Toyota" ); 
 /* Goi mot phuong thuc lop de thiet lap gia xe */ 
 Xecuatoi.setGia( 1000000000 ); 
 /* Goi mot phuong thuc lop khac de lay gia xe */ 
 Xecuatoi.getGia( ); 
 /* Ban cung co the truy cap bien instance nhu sau */ 
 System.out.println("Gia tri bien :" + Xecuatoi.Giaxe ); 
 } 
} 
Biên dịch và thực thi chương trình sẽ cho kết quả sau: 
Ten xe la :Toyota 
Gia mua xe la :1000000000 
Gia tri bien :1000000000 
Ví dụ đối tượng và lớp mà duy trì bản ghi các sinh viên 
Trong ví dụ này, chúng ta tạo hai đối tượng của lớp Student và khởi tạo giá trị của các đối 
tượng này bằng việc triệu hồi phương thức insertRecord trên nó. Ở đây, chúng ta đang 
hiển thị trạng thái (dữ liệu) của các đối tượng bằng việc triệu hồi phương thức 
displayInformation. 
class Student2{ 
 int rollno; 
 String name; 
 void insertRecord(int r, String n){ //phuong thuc 
 rollno=r; 
 name=n; 
 } 
 void displayInformation(){System.out.println(rollno+" "+name);} //phuong thuc 
 public static void main(String args[]){ 
 Student2 s1=new Student2(); 
 Student2 s2=new Student2(); 
 s1.insertRecord(111,"HoangThanh"); 
 s2.insertRecord(222,"ThanhHuong"); 
 s1.displayInformation(); 
 s2.displayInformation(); 
 } 
} 
Ví dụ khác về lớp và đối tượng trong Java 
Ví dụ khác duy trì các bản ghi của lớp Rectangle. Phần giải thích tương tự như trên: 
class Rectangle{ 
 int length; 
 int width; 
 void insert(int l,int w){ 
 length=l; 
 width=w; 
 } 
 void calculateArea(){System.out.println(length*width);} 
 public static void main(String args[]){ 
 Rectangle r1=new Rectangle(); 
 Rectangle r2=new Rectangle(); 
 r1.insert(11,5); 
 r2.insert(3,15); 
 r1.calculateArea(); 
 r2.calculateArea(); 
} 
} 
Các cách khác nhau để tạo đối tượng trong Java? 
Có nhiều cách để tạo một đối tượng trong Java. Đó là: 
Bằng từ khóa new 
Bằng phương thức newInstance() 
Bằng phương thức clone(), . 
Bằng phương thức factory, ... 
Đối tượng vô danh (annonymous) trong Java 
Vô danh hiểu đơn giản là không có tên. Một đối tượng mà không có tham chiếu thì được 
xem như là đối tượng vô danh. Nếu bạn phải sử dụng một đối tượng chỉ một lần, thì đối 
tượng vô danh là một hướng tiếp cận tốt. 
class Calculation{ 
 void fact(int n){ 
 int fact=1; 
 for(int i=1;i<=n;i++){ 
 fact=fact*i; 
 } 
 System.out.println("factorial is "+fact); 
} 
public static void main(String args[]){ 
 new Calculation().fact(5); //Goi phuong thuc voi doi tuong vo danh (annonymous) 
} 
} 
Tạo nhiều đối tượng bởi chỉ một kiểu 
Chúng ta có thể tạo nhiều đối tượng bởi chỉ một kiểu như khi chúng ta thực hiện trong 
các kiểu gốc. Ví dụ: 
Rectangle r1=new Rectangle(),r2=new Rectangle(); //Tao hai doi tuong 
Ví dụ: 
class Rectangle{ 
 int length; 
 int width; 
 void insert(int l,int w){ 
 length=l; 
 width=w; 
 } 
 void calculateArea(){System.out.println(length*width);} 
 public static void main(String args[]){ 
 Rectangle r1=new Rectangle(),r2=new Rectangle(); //Tao hai doi tuong 
 r1.insert(11,5); 
 r2.insert(3,15); 
 r1.calculateArea(); 
 r2.calculateArea(); 
} 
} 
Kết quả là: 
Output:55 
 45 
20.3. Trao đổi: 
- So sánh Java với một vài ngôn ngữ lập trình hướng đối tượng khác? 
- Sau ngôn ngữ lập trình hướng đối tượng sẽ là thế hệ ngôn ngữ lập trình nào?