Trong phần này chúng
ta sẽ tìm hiểu về:
- Constructor trong Java là gì?
- Quy tắc tạo constructor
- Constructor overleading
- Constructor Chaining
Constructor là gì?
Constructor là một phương thức đặc biệt được sử dụng để khởi
tạo một đối tượng mới và được gọi ngay sau khi bộ nhớ được cấp phát cho đối tượng. Phương
thức khởi tạo còn được sử dụng để khởi tạo thuộc tính của đối tượng thành các
giá trị mong muốn hoặc mang giá trị mặc định tại thời điểm tạo đối tượng. Khi
tạo một lớp không bắt buộc phải viết mã tạo phương thức khởi tạo.
Nếu không có hàm tạo
nào được tạo, trình biên dịch gọi hàm tạo mặc định và khởi tạo các biến thành
viên theo các giá trị mặc định của nó.
- Với biến có kiểu
dữ liệu số giá trị mặc định khởi tạo là 0
- Với biến có kiểu
dữ liệu ký tự giá trị mặc định khởi tạo là null (‘\0’)
- Các biến tham
chiếu được khởi tạo là null
Các quy tắc để tạo Constructor
1.
Constructor phải có cùng tên với tên lớp của nó
2.
Constructor không có kiểu dữ liệu trả về (thậm chí
là kiểu dữ liệu void)
3.
Constructor được gọi
sử dụng toán tử new khi một đối
tượng được tạo.
Constructor đóng vai trò quan trọng trong việc khởi tạo đối tượng.
Ví dụ 1 - Tạo constructor đầu
tiên trong Java
Bước 1: Nhập mã sau vào
trình soạn thảo của bạn.
class Demo{
int value1;
int value2;
Demo(){
value1 = 10;
value2 = 20;
System.out.println("Inside Constructor");
}
public void display(){
System.out.println("Value1 === "+value1);
System.out.println("Value2 === "+value2);
}
public static void main(String args[]){
Demo d1 = new Demo();
d1.display();
}
}
Bước 2: Lưu, chạy và
biên dịch mã. Quan sát đầu ra.
Đầu ra:
Inside Constructor
Value1 === 10
Value2 === 20
Constructor Overloading (Nạp chồng constructor)
Constructor
Overloading là một kỹ thuật trong Java, trong đó một lớp có thể có nhiều hàm tạo
với các tham số đầu vào khác nhau. Trình biên dịch phân biệt các hàm tạo
này bằng cách tính đến số lượng tham số trong danh sách và kiểu của chúng.
Ví dụ về các hàm tạo hợp
lệ cho lớp Account
Account(int a);
Account (int a,int b);
Account (String a,int b);
Ví dụ 2 - Constructor
Overloading
Bước 1: Nhập mã vào
trình soạn thảo.
class Demo{
int value1;
int value2;
/*Demo(){
value1 = 10;
value2 = 20;
System.out.println("Inside 1st Constructor");
}*/
Demo(int a){
value1 = a;
System.out.println("Inside 2nd Constructor");
}
Demo(int a,int b){
value1 = a;
value2 = b;
System.out.println("Inside 3rd Constructor");
}
public void display(){
System.out.println("Value1 === "+value1);
System.out.println("Value2 === "+value2);
}
public static void main(String args[]){
Demo d1 = new Demo();
Demo d2 = new Demo(30);
Demo d3 = new Demo(30,40);
d1.display();
d2.display();
d3.display();
}
}
Bước 2: Lưu, biên dịch
và chạy mã.
Bước 3: Lỗi =
?. Hãy thử và gỡ lỗi trước khi tiếp tục bước tiếp theo.
Bước 4: Mỗi lớp có một constructor
mặc định. Constructor mặc định cho lớp Demo là Demo(). Trong
trường hợp bạn không cung cấp constructor mặc định, trình biên dịch sẽ tạo nó
cho bạn và khởi tạo các biến thành các giá trị mặc định. Bạn có thể chọn
ghi đè hàm tạo mặc định này và khởi tạo các biến thành các giá trị mong muốn của
bạn như trong Ví dụ 1.
Lưu ý: Nếu bạn chỉ định
một hàm tạo với tham số đầu vào như Demo (int a) và muốn sử dụng hàm tạo mặc định
Demo(), thì bắt buộc bạn phải tạo nó. Nói cách khác, trong trường hợp hàm tạo của
bạn bị ghi đè và bạn muốn sử dụng hàm tạo mặc định, thì nó cần phải được xây dựng
khi tạo lớp.
Bước 5: Bỏ chú thích ở
mã lệnh ở dòng # 4- 8. Lưu, biên dịch và chạy mã.
Constructor Chaining
Hãy xem xét một kịch bản
trong đó một lớp cơ sở được mở rộng bởi một lớp con. Bất cứ khi nào một đối
tượng của lớp con được tạo, hàm tạo của lớp cha được gọi trước tiên. Điều
này được gọi là Constructor Chaining.
Ví dụ 3 - Hiểu được
constructor chaining
Bước 1: Sao chép mã sau
vào trình soạn thảo.
class Demo{
int value1;
int value2;
Demo(){
value1 = 1;
value2 = 2;
System.out.println("Inside 1st Parent Constructor");
}
Demo(int a){
value1 = a;
System.out.println("Inside 2nd Parent Constructor");
}
public void display(){
System.out.println("Value1 === "+value1);
System.out.println("Value2 === "+value2);
}
public static void main(String args[]){
DemoChild d1 = new DemoChild();
d1.display();
}
}
class DemoChild extends Demo{
int value3;
int value4;
DemoChild(){
//super(5);
value3 = 3;
value4 = 4;
System.out.println("Inside the Constructor of Child");
}
public void display(){
System.out.println("Value1 === "+value1);
System.out.println("Value2 === "+value2);
System.out.println("Value1 === "+value3);
System.out.println("Value2 === "+value4);
}
}
Bước 2: Chạy mã. Khi
đối tượng của lớp con DemoChild được tạo, constructor Demo() của lớp cha được gọi
trước và sau đó hàm tạo DemoChild() của lớp con được tạo.
Kết quả dự kiến:
Inside 1st Parent Constructor
Inside the Constructor of Child
Value1 === 1
Value2 === 2
Value1 === 3
Value2 === 4
Bước 3: Bạn có thể quan
sát hàm tạo của lớp cha Demo bị ghi đè. Điều gì sẽ xảy ra nếu bạn muốn gọi
hàm tạo Demo(int a) thay vì hàm tạo mặc định Demo() khi đối tượng của lớp con
được tạo?
Trong các trường hợp
như vậy, bạn có thể sử dụng từ khóa "super" để gọi
các hàm tạo bị ghi đè của lớp cha.
Cú pháp:
super();
--or--
super(parameter list);
Ví dụ: Nếu hàm tạo của
bạn giống như Demo(String Name,int
a), bạn sẽ chỉ định super ("Java", 5) Nếu
được sử dụng, từ khóa super được đặt ở dòng mã đầu tiên trong hàm tạo
của lớp con.
Bước 4: Bỏ chú thích
dòng # 26 và chạy mã. Quan sát đầu ra.
Đầu ra:
Inside 2nd Parent Constructor
Inside the Constructor of Child
Value1 === 5
Value2 === 0
Value1 === 3
Value2 === 4
Đăng nhận xét