Bài giảng Lập trình hướng đối tượng với Java

LẬP TRÌNH HƯỚNG ĐỐI TƯỢNG VỚI JAVA 
(Object Oriented Programming with Java) 
Bộ môn Công nghệ Phần mềm 
Đại học SPKT Hưng Yên 
BÀI 1: Các khái niệm cơ bản về ................................................................................................................... 5 
lập trình hướng đối tượng ............................................................................................................................. 5 
1.1. Lịch sử phát triển của phương pháp lập trình ................................................................................... 5 
1.2 . Một số khái niệm trong lập trình hướng đối tượng .......................................................................... 7 
Thừa kế ............................................................................................................................................. 7 
Đa hình .............................................................................................................................................. 7 
Trừu tượng ........................................................................................................................................ 8 
Đóng .................................................................................................................................................. 8 
1.3 Các ưu điểm của lập trình hướng đối tượng bằng Java ....................................................................... 8 
Bài 3: Lớp và đối tượng (I) ......................................................................................................................... 12 
3.1. Khai báo lớp ..................................................................................................................................... 12 
3.2 Khai báo thuộc tính ........................................................................................................................... 14 
Bài 5: Lớp và đối tượng (II) ........................................................................................................................ 17 
5.1. Chi tiết về khai báo một phương thức .............................................................................................. 17 
5.2. Từ khoá this ..................................................................................................................................... 22 
5.3. Từ khoá super .................................................................................................................................. 23 
5.4. Sử dụng lớp ...................................................................................................................................... 24 
5.5. Điều khiển việc truy cập đến các thành viên của một lớp ................................................................ 24 
Bài 7: Bài tập và thảo luận về Lớp và Đối tượng........................................................................................ 28 
7.1. Lớp và đối tượng có ưu điểm gì? ..................................................................................................... 28 
7.2. Cách xây dựng lớp và đối tượng ...................................................................................................... 29 
1. Các thành phần trong bản vẽ Class ............................................................................................. 29 
2. Relationship (Quan hệ) ............................................................................................................... 30 
3. Cách xây dựng bản vẽ Class ....................................................................................................... 33 
4. Đặc tả Class ................................................................................................................................. 35 
5. Sử dụng bản vẽ Class .................................................................................................................. 35 
6. Kết luận ....................................................................................................................................... 36 
Bài 8: Gói trong java ................................................................................................................................... 37 
8.1. Vai trò của gói (package) trong lập trình ......................................................................................... 37 
8.2. Cách tạo gói trong Java .................................................................................................................... 37 
8.3. Truy suất gói trong Java ................................................................................................................... 39 
Bài 10: Kế thừa (I) ...................................................................................................................................... 45 
10.1. Lớp cơ sở và lớp dẫn xuất .............................................................................................................. 45 
10.2. Cách xây dựng lớp dẫn xuất ........................................................................................................... 45 
10.3. Thừa kế các thuộc tính ................................................................................................................... 45 
10.4 Thừa kế phương thức ...................................................................................................................... 45 
10.5 Khởi đầu lớp cơ sở .......................................................................................................................... 46 
Bài 12: Kế thừa (II) ..................................................................................................................................... 52 
12.1. Thành phần protected ..................................................................................................................... 52 
12.2. Từ khoá final .................................................................................................................................. 52 
Bài 14: Đa hình (I) ...................................................................................................................................... 55 
14.1. Giới thiệu chung về đa hình ........................................................................................................... 55 
14.2 Giao diện ....................................................................................................................................... 56 
Bài 15: Bài tập và thảo luận về Kế thừa...................................................................................................... 60 
15.1. Tại sao lại cần Kế thừa? ................................................................................................................. 60 
15.2. Các loại kế thừa trong Java ............................................................................................................ 61 
Ví dụ: .................................................................................................................................................... 62 
15.3 Quan hệ HAS-A trong Java ............................................................................................................ 62 
Bài 17 Đa hình (II) ...................................................................................................................................... 64 
17.1 Giới thiệu ........................................................................................................................................ 64 
17.2 Phương thức trừu tượng (abstract method) ..................................................................................... 64 
17.3 Một số quy tắc áp dụng cho lớp trừu tượng .................................................................................... 66 
17.4 Lớp trừu tượng (abstract class) và giao diện (interface) ................................................................. 67 
Bài 18: Bài tập và thảo luận về Đa hình ..................................................................................................... 69 
18.1. Tại sao lại cần Đa hình? ................................................................................................................. 69 
18.2. Cách sử dụng Đa hình trong lập trình hướng đối tượng ................................................................ 69 
Đa hình tại runtime trong Java ...................................................................................................................... 69 
Upcasting là gì? ........................................................................................................................................ 70 
Ví dụ về đa hình tại runtime trong Java ........................................................................................................... 70 
18.3. Case study: Đa hình tại runtime trong Java với thành viên dữ liệu ............................................... 71 
Đa hình tại runtime trong Java với kế thừa nhiều tầng (Multilevel) .......................................................................... 71 
Bài 20: Bài tập và thảo luận tổng kết môn học ........................................................................................... 74 
20.1. Những ưu điểm của lập trình hướng đối tượng .............................................................................. 74 
20.2. Tóm tắt lập trình HĐT ................................................................................................................... 74 
20.3. Trao đổi: ......................................................................................................................................... 84 
BÀI 1: Các khái niệm cơ bản về 
lập trình hướng đối tượng 
1.1. Lịch sử phát triển của phương pháp lập trình 
Ngôn ngữ lập trình là một tập con của ngôn ngữ máy tính, được thiết kế và chuẩn 
hóa để truyền các chỉ thị cho các máy có bộ xử lý (CPU), nói riêng là máy tính. Ngôn 
ngữ lập trình được dùng để lập trình máy tính, tạo ra các chương trình máy nhằm mục 
đích điều khiển máy tính hoặc mô tả các thuật toán để người khác đọc hiểu. 
Trước hết dạng chương trình duy nhất mà máy tính có thể thực thi trực tiếp là ngôn ngữ 
máy hay mã máy. Nó có dạng dãy các số nhị phân, thường được ghép nhóm 
thành byte 8 bit cho các hệ xử lý 8/16/32/64 bit [note 1]. Nội dung byte thường biểu diễn 
bằng đôi số hex. Để có được bộ mã này ngày nay người ta dùng ngôn ngữ lập trình để 
viết ra chương trình ở dạng văn bản và dùng trình dịch để chuyển sang mã máy [1]. 
Khi kỹ thuật điện toán ra đời chưa có ngôn ngữ lập trình dạng đại diện nào, thì phải lập 
trình trực tiếp bằng mã máy. Dãy byte viết ra được đục lỗ lên phiếu đục lỗ (punched card) 
và nhập qua máy đọc phiếu tới máy tính [2]. Sau đó chương trình có thể được ghi vào 
băng/đĩa từ để sau này nhập nhanh vào máy tính. Ngôn ngữ máy được gọi là "ngôn ngữ 
lập trình thế hệ 1" (1GL, first-generation programming languages) [3]. 
Sau đó các mã lệnh được thay thế bằng các tên gợi nhớ và trình được lập ở dạng văn bản 
(text) rồi dịch sang mã máy. Hợp ngữ (assembly languages) ra đời, là "ngôn ngữ lập trình 
thế hệ 2" (2GL, second-generation programming languages). Lập trình thuận lợi hơn, khi 
dịch có thể liên kết với thư viện chương trình con ở cả dạng macro (đoạn chưa dịch) và 
lẫn mã đã dịch. Hợp ngữ hiện được dùng là ngôn ngữ bậc thấp (low-level programming 
languages) để tinh chỉnh ngôn ngữ bậc cao thực hiện truy nhập trực tiếp phần cứng cụ thể 
trong việc lập trình hệ thống, tạo các hiệu ứng đặc biệt cho chương trình. 
Ngôn ngữ bậc cao (high-level programming languages) hay "ngôn ngữ lập trình thế hệ 
3" (3GL, third-generation programming languages) ra đời vào những năm 1950. Đây là 
các ngôn ngữ hình thức, dùng trong lập trình máy điện toán và không lệ thuộc vào 
hệ máy tính cụ thể nào. Nó giải phóng người lập trình ứng dụng làm việc trong hệ điều 
hành xác định mà không phải quan tâm đến phần cứng cụ thể. Các ngôn ngữ được phát 
triển liên tục với các dạng và biến thể mới, theo bước phát triển của kỹ thuật điện toán [4]. 
Đối với ngôn ngữ bậc cao thì định nghĩa ngôn ngữ lập trình theo [Loud 94], T.3 là: 
Ngôn ngữ lập trình là một hệ thống được ký hiệu hóa để miêu tả những tính toán 
(qua máy tính) trong một dạng mà cả con người và máy đều có thể đọc và hiểu 
được. 
Theo định nghĩa ở trên thì một ngôn ngữ lập trình phải thỏa mãn được hai điều kiện 
cơ bản sau: 
1. Dễ hiểu và dễ sử dụng đối với người lập trình, để có thể dùng để giải quyết 
nhiều bài toán khác nhau. 
2. Miêu tả một cách đầy đủ và rõ ràng các tiến trình (tiếng Anh: process), để 
chạy được trên các hệ máy tính khác nhau. 
Một tập hợp các chỉ thị được biểu thị qua ngôn ngữ lập trình nhằm mục đích thực 
hiện các thao tác máy tính nào đó được gọi là một chương trình. Khái niệm này còn 
có những tên khác như chương trình máy tính hay chương trình điện toán. 
Lưu ý: chương trình được viết cho máy vi tính thường được gọi là phần mềm máy 
tính. Ví dụ: chương trình Microsoft Word là một cách gọi chung chung; cách 
gọi phần mềm Microsoft Word chỉ rõ hơn nó là một chương trình ứng dụng. 
Khái niệm lập trình dùng để chỉ quá trình con người tạo ra chương trình máy 
tính thông qua ngôn ngữ lập trình. Người ta còn gọi đó là quá trình mã hoá thông tin 
tự nhiên thành ngôn ngữ máy. Từ viết mã cũng được dùng trong nhiều trường hợp để 
chỉ cùng một ý. 
Như vậy, theo định nghĩa, mỗi ngôn ngữ lập trình cũng chính là một chương trình, 
nhưng nó có thể được dùng để tạo nên các chương trình khác. Văn bản được viết bằng 
ngôn ngữ lập trình để tạo nên chương trình được gọi là mã nguồn. 
Thao tác chuyển đổi từ mã nguồn thành chuỗi các chỉ thị máy tính được thực hiện 
tương tự như việc chuyển đổi qua lại giữa các ngôn ngữ tự nhiên của con người. Các 
thao tác này gọi là biên dịch, hay ngắn gọn hơn là dịch. Nếu quá trình dịch diễn ra 
đồng thời với quá trình thực thi, ta gọi đó là thông dịch; nếu diễn ra trước, ta gọi đó 
là biên dịch. Phần mềm dịch tương ứng được gọi là phần mềm thông dịch và phần 
mềm biên dịch. 
1. Một phần mềm thông dịch là một phần mềm có khả năng đọc, chuyển mã 
nguồn của một ngôn ngữ và ra lệnh cho máy tính tiến hành các tính toán dựa 
theo cú pháp của ngôn ngữ. 
2. Một phần mềm biên dịch hay ngắn gọn hơn trình biên dịch là phần mềm có 
khả năng chuyển mã nguồn của một ngôn ngữ ban đầu sang dạng mã mới 
thường là một ngôn ngữ cấp thấp hơn. 
Ngôn ngữ cấp thấp nhất là một chuỗi các chỉ thị máy tính mà có thể được thực 
thi trực tiếp bởi máy tính (thông qua các theo tác trên vùng nhớ). Trước đây, 
hầu hết các trình biên dịch cũ phải dịch từ mã nguồn sang bộ mã phụ (các tệp 
có dang *.obj) rồi mới tạo ra tập tin thực thi. Ngày nay, hầu hết các trình biên 
dịch đều có khả năng dịch mã nguồn trực tiếp thành các tập tin thực thi hay 
thành các dạng mã khác thấp hơn, tuỳ theo yêu cầu của người lập trình. 
Điểm khác nhau giữa thông dịch và biên dịch là: trình thông dịch dịch từng câu lệnh 
theo yêu cầu thực thi và chương trình đích vừa tạo ra sẽ không được lưu lại; tro ... virtual. 
// Khai báo sai 
abstract class Window 
{ 
 private abstract virtual void DrawWindow(); 
} 
– Một phương thức trừu tượng không thể là phương thức static. 
// Khai báo sai 
abstract class Window 
{ 
 private abstract static void DrawWindow(); 
} 
17.4 Lớp trừu tượng (abstract class) và giao diện (interface) 
Trong lớp trừu tượng chứa cả phương thức trừu tượng lẫn phương thức thành viên. 
Nhưng trong interface thì chỉ chứa phương thức trừu tượng và lớp con khi thừa kế từ 
interface cần phải ghi đè (override) lên các phương thức này. 
interface IFile 
{ 
 void Save(); 
 void Load(); 
} 
 Các phương thức trừu tượng khai báo trong interface không sử dụng chỉ định từ truy xuất, 
mặc định sẽ là public. 
Một lớp chỉ có thể thừa kế từ một lớp cha, nhưng có thể thừa kế từ nhiều interface. 
Bài 18: Bài tập và thảo luận về Đa hình 
18.1. Tại sao lại cần Đa hình? 
Tính đa hình trong Java là một khái niệm mà từ đó chúng ta có thể thực hiện một hành 
động đơn theo nhiều cách khác nhau. Tính đa hình được suy ra từ hai từ Hy Lạp là Poly 
và Morphs. Poly nghĩa là nhiều và morphs nghĩa là hình, dạng. Có hai kiểu đa hình trong 
Java: Đa hình tại compile time và đa hình runtime. Chúng ta có thể thực hiện tính đa 
hình trong Java bởi nạp chồng phương thức và ghi đè phương thức. 
Nếu bạn nạp chồng phương thức static trong Java, thì đó là ví dụ về đa hình tại compile 
time. Ở chương này chúng sẽ tập trung vào đa hình tại runtime trong Java. 
Điều quan trọng để biết là có cách nào truy cập một đối tượng qua các biến tham chiếu. 
Một biến tham chiếu có thể chỉ là một kiểu. Khi được khai báo, kiểu của biến tham chiếu 
này không thể thay đổi. 
Biến tham chiếu có thể được gán cho những đối tượng khác được cung cấp mà không 
được khai báo final. Kiểu của biến tham chiếu sẽ xác định phương thức mà có thể được 
triệu hồi trên đối tượng. 
Một biến tham chiếu có thể được hướng đến bất kì đối tượng với kiểu khai báo hoặc bất 
kì kiểu con nào của kiểu khai báo. Một biến tham chiếu có thể được khai báo như là một 
class hoặc một interface. 
18.2. Cách sử dụng Đa hình trong lập trình hướng đối tượng 
Đa hình tại runtime trong Java 
Đa hình tại runtime là một tiến trình mà trong đó một lời gọi tới một phương thức được 
ghi đè được xử lý tại runtime thay vì tại compile time. Trong tiến trình này, một phương 
thức được ghi đè được gọi thông qua biến tham chiếu của một lớp cha. Việc quyết định 
phương thức được gọi là dựa trên đối tượng nào đang được tham chiếu bởi biến tham 
chiếu. 
Trước khi tìm hiểu về đa hình tại runtime, chúng ta cùng tìm hiểu về Upcasting. 
Upcasting là gì? 
Khi biến tham chiếu của lớp cha tham chiếu tới đối tượng của lớp con, thì đó là 
Upcasting. Ví dụ: 
class A{} 
class B extends A{} 
A a=new B();//day la upcasting 
Ví dụ về đa hình tại runtime trong Java 
Trong ví dụ, chúng ta tạo hai lớp Bike và Splendar. Lớp Splendar kế thừa lớp Bike và 
ghi đè phương thức run() của nó. Chúng ta gọi phương thức run bởi biến tham chiếu của 
lớp cha. Khi nó tham chiếu tới đối tượng của lớp con và phương thức lớp con ghi đè 
phương thức của lớp cha, phương thức lớp con được triệu hồi tại runtime. 
Khi việc gọi phương thức được quyết định bởi JVM chứ không phải Compiler, vì thế đó 
là đa hình tại runtime. 
class Bike{ 
 void run(){System.out.println("dang chay");} 
} 
class Splender extends Bike{ 
 void run(){System.out.println("chay an toan voi 60km");} 
 public static void main(String args[]){ 
 Bike b = new Splender();//day la upcasting 
 b.run(); 
 } 
} 
18.3. Case study: Đa hình tại runtime trong Java với thành viên dữ liệu 
Phương thức bị ghi đè không là thành viên dữ liệu, vì thế đa hình tại runtime không thể 
có được bởi thành viên dữ liệu. Trong ví dụ sau đây, cả hai lớp có một thành viên dữ 
liệu là speedlimit, chúng ta truy cập thành viên dữ liệu bởi biến tham chiếu của lớp cha 
mà tham chiếu tới đối tượng lớp con. Khi chúng ta truy cập thành viên dữ liệu mà không 
bị ghi đè, thì nó sẽ luôn luôn truy cập thành viên dữ liệu của lớp cha. 
Qui tắc: Đa hình tại runtime không thể có được bởi thành viên dữ liệu. 
class Bike{ 
 int speedlimit=90; 
} 
class Honda3 extends Bike{ 
 int speedlimit=150; 
 public static void main(String args[]){ 
 Bike obj=new Honda3(); 
 System.out.println(obj.speedlimit);//90 
} 
Đa hình tại runtime trong Java với kế thừa nhiều tầng (Multilevel) 
Bạn theo dõi ví dụ sau: 
class Animal{ 
void eat(){System.out.println("an");} 
} 
class Dog extends Animal{ 
void eat(){System.out.println("an hoa qua");} 
} 
class BabyDog extends Dog{ 
void eat(){System.out.println("uong sua");} 
public static void main(String args[]){ 
Animal a1,a2,a3; 
a1=new Animal(); 
a2=new Dog(); 
a3=new BabyDog(); 
a1.eat(); 
a2.eat(); 
a3.eat(); 
} 
} 
Và: 
class Animal{ 
void eat(){System.out.println("animao dang an...");} 
} 
class Dog extends Animal{ 
void eat(){System.out.println("dog dang an...");} 
} 
class BabyDog1 extends Dog{ 
public static void main(String args[]){ 
Animal a=new BabyDog1(); 
a.eat(); 
}} 
Vì, BabyDog không ghi đè phương thức eat(), do đó phương thức eat() của lớp Dog() 
được triệu hồ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. Tóm tắt lập trình HĐT 
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?