Bài báo
Bắt đầu
Bắt đầu học
JavaRush /Blog Java /Random-VI /Các nhà xây dựng lớp. Java JDK 1.5
articles
Mức độ

Các nhà xây dựng lớp. Java JDK 1.5

Xuất bản trong nhóm
Các nhà xây dựng lớp. Java JDK 1.5 - 1

Thông tin chung về constructor

Конструкторlà một cấu trúc tương tự như một phương thức, mục đích của nó là tạo ra một thể hiện của một lớp. Đặc điểm của nhà thiết kế:
  • Tên của hàm tạo phải trùng với tên của lớp (theo quy ước, chữ cái đầu tiên được viết hoa, thường là danh từ);
  • Có một hàm tạo trong bất kỳ lớp nào. Ngay cả khi bạn không viết nó, trình biên dịch Java sẽ tạo một hàm tạo mặc định, hàm tạo này sẽ trống và không làm gì khác ngoài việc gọi hàm tạo của siêu lớp.
  • Hàm tạo tương tự như một phương thức, nhưng nó không phải là một phương thức, nó thậm chí không được coi là thành viên của lớp. Vì vậy, nó không thể được kế thừa hoặc ghi đè trong một lớp con;
  • Các nhà xây dựng không được kế thừa;
  • Có thể có nhiều hàm tạo trong một lớp. Trong trường hợp này, các hàm tạo được cho là bị quá tải;
  • Nếu một lớp không xác định hàm tạo, trình biên dịch sẽ tự động thêm hàm tạo không tham số vào mã;
  • Một hàm tạo không có kiểu trả về; nó thậm chí không thể là một kiểu void; nếu một kiểu được trả về voidthì nó không còn là hàm tạo nữa mà là một phương thức, mặc dù trùng khớp với tên lớp.
  • Toán tử được phép trong hàm tạo return, nhưng chỉ trống, không có bất kỳ giá trị trả về nào;
  • Hàm tạo cho phép sử dụng các công cụ sửa đổi truy cập; bạn có thể đặt một trong các công cụ sửa đổi: public, protectedhoặc privatekhông có công cụ sửa đổi.
  • Một hàm tạo không thể có các từ bổ nghĩa abstract, final, nativehoặc static;synchronized
  • Từ khóa thisđề cập đến một hàm tạo khác trong cùng một lớp. Nếu được sử dụng, lệnh gọi nó phải là dòng đầu tiên của hàm tạo;
  • Từ khóa supergọi hàm tạo của lớp cha. Nếu được sử dụng, tham chiếu đến nó phải là dòng đầu tiên của hàm tạo;
  • Nếu hàm tạo không thực hiện lệnh gọi superhàm tạo của lớp tổ tiên (có hoặc không có đối số), trình biên dịch sẽ tự động thêm mã để gọi hàm tạo của lớp tổ tiên mà không có đối số;

Nhà xây dựng mặc định

Có một hàm tạo trong bất kỳ lớp nào. Ngay cả khi bạn không viết nó, trình biên dịch Java sẽ tạo một hàm tạo mặc định. Hàm tạo này trống và không làm gì khác ngoài việc gọi hàm tạo của siêu lớp. Những thứ kia. nếu bạn viết: 
public class Example {}
thì điều này tương đương với việc viết: 
public class Example
{
     Example()
     {
          super;
     }
}
Trong trường hợp này, lớp tổ tiên không được chỉ định rõ ràng và theo mặc định, tất cả các lớp Java đều kế thừa lớp đó, Objectdo đó hàm tạo của lớp được gọi Object. Nếu một lớp định nghĩa một hàm tạo có tham số, nhưng không có hàm tạo nào bị quá tải mà không có tham số, thì việc gọi hàm tạo mà không có tham số là một lỗi. Tuy nhiên, trong Java kể từ phiên bản 1.5, có thể sử dụng hàm tạo với các đối số có độ dài thay đổi. Và nếu có một hàm tạo có đối số có độ dài thay đổi thì việc gọi hàm tạo mặc định sẽ không có lỗi. Điều đó sẽ không xảy ra vì đối số có độ dài thay đổi có thể trống. Ví dụ: ví dụ sau sẽ không biên dịch, nhưng nếu bạn bỏ ghi chú hàm tạo với đối số có độ dài thay đổi, nó sẽ biên dịch và chạy thành công và dẫn đến một dòng mã đang chạy DefaultDemo dd = new DefaultDemo(); hàm tạo sẽ được gọi DefaultDemo(int ... v). Đương nhiên, trong trường hợp này cần phải sử dụng JSDK 1.5. Tài liệuDefaultDemo.java 
class DefaultDemo
{
 DefaultDemo(String s)
 {
  System.out.print("DefaultDemo(String)");
 }
 /*
 DefaultDemo(int ... v)
 {
  System.out.println("DefaultDemo(int ...)");
 }
 */

 public static void main(String args[])
 {
  DefaultDemo dd = new DefaultDemo();
 }
}
Kết quả đầu ra của chương trình với hàm tạo không được chú thích: 
DefaultDemo(int ...)
Tuy nhiên, trong trường hợp phổ biến khi lớp không định nghĩa bất kỳ hàm tạo nào, việc gọi hàm tạo mặc định (không có tham số) sẽ là cần thiết, vì việc thay thế hàm tạo mặc định diễn ra tự động.

Tạo đối tượng và hàm tạo

Khi tạo một đối tượng, các hành động sau được thực hiện tuần tự:
  • Lớp đối tượng được tìm kiếm trong số các lớp đã được sử dụng trong chương trình. Nếu nó không có ở đó thì nó sẽ được tìm kiếm trong tất cả các danh mục và thư viện có sẵn cho chương trình. Khi một lớp được phát hiện trong một thư mục hoặc thư viện, các trường tĩnh của lớp đó sẽ được tạo và khởi tạo. Những thứ kia. Đối với mỗi lớp, các trường tĩnh chỉ được khởi tạo một lần.
  • Bộ nhớ được phân bổ cho đối tượng.
  • Các trường lớp đang được khởi tạo.
  • Trình xây dựng lớp thực thi.
  • Một liên kết đến đối tượng được tạo và khởi tạo được hình thành. Tham chiếu này là giá trị của biểu thức tạo ra đối tượng. Một đối tượng cũng có thể được tạo bằng cách gọi một phương thức newInstance()lớp java.lang.Class. Trong trường hợp này, một hàm tạo không có danh sách tham số sẽ được sử dụng.

Quá tải hàm tạo

Các hàm tạo của cùng một lớp có thể có cùng tên và chữ ký khác nhau. Thuộc tính này được gọi là sự kết hợp hoặc quá tải. Nếu một lớp có nhiều hàm tạo thì sẽ xảy ra hiện tượng nạp chồng hàm tạo.
Java-университет

Trình xây dựng tham số

Chữ ký của hàm tạo là số lượng và loại tham số, cũng như thứ tự các loại của chúng trong danh sách tham số của hàm tạo. Kiểu trả về không được tính đến. Hàm tạo không trả về bất kỳ tham số nào. Theo một nghĩa nào đó, câu lệnh này giải thích cách Java phân biệt giữa các hàm tạo hoặc phương thức bị quá tải. Java phân biệt các phương thức nạp chồng không phải bằng kiểu trả về của chúng mà bằng số lượng, kiểu và trình tự các kiểu tham số đầu vào. Một hàm tạo thậm chí không thể trả về một kiểu void, nếu không nó sẽ biến thành một phương thức thông thường, mặc dù nó giống với tên lớp. Ví dụ sau đây chứng minh điều này. Tài liệuVoidDemo.java 
class VoidDemo
{
 /**
  * Это конструктор
  */
 VoidDemo()
 {
  System.out.println("Constructor");
 }

 /**
  * А это уже обычный метод, даже не смотря на сходство с
  * именем класса, поскольку имеется возвращаемый тип void
  */
 void VoidDemo()
 {
  System.out.println("Method");
 }

 public static void main(String s[])
 {
  VoidDemo m = new VoidDemo();
 }
}
Kết quả chương trình sẽ xuất ra: 
Constructor
Điều này một lần nữa chứng minh rằng hàm tạo là một phương thức không có tham số trả về. Tuy nhiên, hàm tạo có thể được cung cấp một trong ba công cụ sửa đổi public, privatehoặc protected. Và ví dụ bây giờ sẽ như thế này: FileVoidDemo2.java 
class VoidDemo2
{
 /**
  * Это конструктор
  */
 public VoidDemo2()
 {
  System.out.println("Constructor");
 }

 /**
  * А это уже обычный метод, даже не смотря на сходство с
  * именем класса, поскольку имеется возвращаемый тип void
  */
 private void VoidDemo2()
 {
  System.out.println("Method");
 }

 public static void main(String s[])
 {
  VoidDemo2 m = new VoidDemo2();
 }
}
Được phép viết một toán tử trong hàm tạo return, nhưng chỉ là một toán tử trống, không có bất kỳ giá trị trả về nào. Tài liệuReturnDemo.java 
class ReturnDemo
{
 /**
  * В конструкторе допускается использование оператора
  * return без параметров.
  */
 public ReturnDemo()
 {
  System.out.println("Constructor");
  return;
 }

 public static void main(String s[])
 {
  ReturnDemo r = new ReturnDemo();
 }
}

Các hàm tạo được tham số hóa với các đối số có độ dài thay đổi

Java SDK 1.5 đã giới thiệu một công cụ được chờ đợi từ lâu - các đối số có độ dài thay đổi cho hàm tạo và phương thức. Trước đây, một số lượng lớn tài liệu được xử lý theo hai cách bất tiện. Đầu tiên trong số chúng được thiết kế để đảm bảo rằng số lượng đối số tối đa được giới hạn ở một số lượng nhỏ và được biết trước. Trong trường hợp này, có thể tạo các phiên bản nạp chồng của phương thức, một phiên bản cho mỗi phiên bản của danh sách các đối số được truyền cho phương thức. Phương pháp thứ hai được thiết kế cho những điều chưa biết trước và một số lượng lớn đối số. Trong trường hợp này, các đối số được đặt trong một mảng và mảng này được truyền cho phương thức. Các đối số có độ dài thay đổi thường liên quan nhiều nhất đến các thao tác tiếp theo với các khởi tạo thay đổi. Thật thuận tiện khi thay thế sự vắng mặt của một số đối số phương thức hoặc hàm tạo được mong đợi bằng các giá trị mặc định. Đối số có độ dài thay đổi là một mảng và được coi là một mảng. Ví dụ: hàm tạo của một lớp Checkingcó số lượng đối số thay đổi sẽ trông như thế này: 
class Checking
{
 public Checking(int ... n)
 {
 }
}
Tổ hợp ký tự ... cho trình biên dịch biết rằng một số lượng đối số thay đổi sẽ được sử dụng và các đối số này sẽ được lưu trữ trong một mảng có giá trị tham chiếu được chứa trong biến n. Hàm tạo có thể được gọi với số lượng đối số khác nhau, bao gồm cả không có đối số nào cả. Các đối số được tự động đặt vào một mảng và được chuyển qua n. Nếu không có đối số thì độ dài của mảng là 0. Danh sách các tham số, cùng với các đối số có độ dài thay đổi, cũng có thể bao gồm các tham số bắt buộc. Trong trường hợp này, tham số chứa số lượng đối số thay đổi phải là tham số cuối cùng trong danh sách tham số. Ví dụ: 
class Checking
{
 public Checking(String s, int ... n)
 {
 }
}
Một hạn chế rất rõ ràng liên quan đến số lượng tham số có độ dài thay đổi. Chỉ được có một tham số có độ dài thay đổi trong danh sách tham số. Với hai tham số có độ dài thay đổi, trình biên dịch không thể xác định nơi một tham số kết thúc và tham số kia bắt đầu. Ví dụ: 
class Checking
{
 public Checking(String s, int ... n, double ... d) //ОШИБКА!
 {
 }
}
Tệp Checking.java Ví dụ: có thiết bị có khả năng nhận dạng biển số ô tô và ghi nhớ số ô vuông của khu vực mà mỗi ô tô đã ghé thăm trong ngày. Cần phải chọn từ tổng số ô tô được ghi lại những ô tô đã ghé thăm hai ô vuông nhất định trong ngày, chẳng hạn như 22 và 15, theo bản đồ khu vực. Điều khá tự nhiên là ô tô có thể ghé thăm nhiều quảng trường trong ngày, hoặc có thể chỉ một quảng trường. Rõ ràng, số ô vuông được ghé thăm bị giới hạn bởi tốc độ vật lý của ô tô. Chúng ta hãy tạo một chương trình nhỏ trong đó hàm tạo của lớp sẽ lấy số ô tô làm tham số bắt buộc và số ô vuông đã truy cập của khu vực làm đối số, số lượng ô có thể thay đổi. Người xây dựng sẽ kiểm tra xem một chiếc ô tô có xuất hiện ở hai ô vuông hay không, nếu có thì hiển thị số của nó lên màn hình.

Truyền tham số cho hàm tạo

Chủ yếu có hai loại tham số trong ngôn ngữ lập trình:
  • các loại cơ bản (nguyên thủy);
  • tham chiếu đến các đối tượng.
Thuật ngữ gọi theo giá trị có nghĩa là hàm tạo nhận được giá trị được mô-đun gọi chuyển đến nó. Ngược lại, gọi bằng tham chiếu có nghĩa là hàm tạo nhận địa chỉ của biến từ người gọi. Java chỉ sử dụng lệnh gọi theo giá trị. Theo giá trị tham số và theo giá trị liên kết tham số. Java không sử dụng lệnh gọi theo tham chiếu cho các đối tượng (mặc dù nhiều lập trình viên và tác giả của một số cuốn sách khẳng định điều này). Khi truyền đối tượng sang Java, các tham số được truyền không phải bằng tham chiếu mà bằng giá trị của tham chiếu đối tượng ! Trong cả hai trường hợp, hàm tạo sẽ nhận được bản sao giá trị của tất cả các tham số. Hàm tạo không thể thực hiện với các tham số đầu vào của nó:
  • hàm tạo không thể thay đổi giá trị của các tham số đầu vào của các loại chính (nguyên thủy);
  • hàm tạo không thể thay đổi tham chiếu tham số đầu vào;
  • hàm tạo không thể gán lại tham chiếu tham số đầu vào cho các đối tượng mới.
Hàm tạo có thể thực hiện với các tham số đầu vào của nó:
  • thay đổi trạng thái của đối tượng được truyền dưới dạng tham số đầu vào.
Ví dụ sau chứng minh rằng trong Java, các tham số đầu vào của hàm tạo được truyền bằng giá trị tham chiếu đối tượng. Ví dụ này cũng phản ánh rằng hàm tạo không thể thay đổi tham chiếu của tham số đầu vào, nhưng thực tế là thay đổi tham chiếu của bản sao của tham số đầu vào. Tài liệuEmpoyee.java 
class Employee
{
 Employee(String x, String y)
 {
  String temp = x;
  x = y;
  y = temp;
 }
 public static void main(String args[])
 {
  String name1 = new String("Alice");
  String name2 = new String("Mary");
  Employee a = new Employee(name1, name2);
  System.out.println("name1="+name1);
  System.out.println("name2="+name2);
 }
}
Đầu ra của chương trình là: 
name1=Alice
name2=Mary
Nếu Java sử dụng lệnh gọi theo tham chiếu để truyền các đối tượng làm tham số, thì hàm tạo sẽ hoán đổi name1và trong ví dụ này name2. Hàm tạo sẽ không thực sự trao đổi các tham chiếu đối tượng được lưu trữ trong các biến name1và name2. Điều này gợi ý rằng các tham số của hàm tạo được khởi tạo bằng các bản sao của các tham chiếu này. Sau đó, hàm tạo hoán đổi các bản sao. Khi hàm tạo hoàn thành công việc của nó, các biến x và y sẽ bị hủy và các biến ban đầu name1tiếp tục name2tham chiếu đến các đối tượng trước đó.

Thay đổi các tham số được truyền cho hàm tạo.

Hàm tạo không thể sửa đổi các tham số đã truyền của các loại cơ bản. Tuy nhiên, hàm tạo có thể sửa đổi trạng thái của đối tượng được truyền dưới dạng tham số. Ví dụ, hãy xem xét chương trình sau: FileSalary1.java 
class Salary1
{
 Salary1(int x)
 {
  x = x * 3;
  System.out.println("x="+x);
 }
 public static void main(String args[])
 {
  int value = 1000;
  Salary1 s1 = new Salary1(value);
  System.out.println("value="+value);
 }
}
Đầu ra của chương trình là: 
x=3000
value=1000
Rõ ràng, phương pháp này sẽ không thay đổi tham số kiểu chính. Vì vậy, sau khi gọi hàm tạo, giá trị của biến valuevẫn bằng 1000. Về cơ bản có ba điều xảy ra:
  1. Biến xđược khởi tạo bằng một bản sao của giá trị tham số value(tức là một số 1000).
  2. Giá trị của biến xđược nhân ba - bây giờ nó bằng 3000. Tuy nhiên, giá trị của biến valuevẫn bằng 1000.
  3. Hàm tạo kết thúc và biến xkhông còn được sử dụng nữa.
Trong ví dụ sau, lương của nhân viên được tăng gấp ba lần thành công vì giá trị của một tham chiếu đối tượng được truyền dưới dạng tham số cho phương thức. Tài liệuSalary2.java 
class Salary2
{
 int value = 1000;
 Salary2()
 {
 }
 Salary2(Salary2 x)
 {
  x.value = x.value * 3;
 }
 public static void main(String args[])
 {
  Salary2 s1 = new Salary2();
  Salary2 s2 = new Salary2(s1);
  System.out.println("s1.value=" +s1.value);
  System.out.println("s2.value="+s2.value);
 }
}
Đầu ra của chương trình là: 
s1.value=3000
s2.value=1000
Giá trị của tham chiếu đối tượng được sử dụng làm tham số. Khi thực hiện dòng Salary2 s2 = new Salary2(s1); hàm tạo Salary2(Salary x)sẽ được truyền giá trị của một tham chiếu đến đối tượng biến s1và hàm tạo sẽ tăng lương gấp ba một cách hiệu quả cho s1.valuevì ngay cả bản sao (Salary x)được tạo bên trong hàm tạo cũng trỏ đến đối tượng biến s1.

Các nhà xây dựng được tham số hóa bởi các nguyên thủy.

Nếu các tham số của hàm tạo quá tải sử dụng một kiểu nguyên thủy có thể được thu hẹp (ví dụ int <- double), thì có thể gọi một phương thức có giá trị được thu hẹp, mặc dù thực tế là không có phương thức nào bị quá tải với tham số như vậy. Ví dụ: Tập tinPrimitive.java 
class Primitive
{
 Primitive(double d)
 {
  d = d + 10;
  System.out.println("d="+d);
 }
 public static void main(String args[])
 {
  int i = 20;
  Primitive s1 = new Primitive(i);
 }
}
Đầu ra của chương trình là: 
d=30.0
Mặc dù thực tế là lớp Primitivekhông có hàm tạo có tham số kiểu int, nhưng hàm tạo có tham số đầu vào sẽ hoạt động double. Trước khi hàm tạo được gọi, biến isẽ được mở rộng từ loại này intsang loại khác double. Tùy chọn ngược lại, khi biến ithuộc loại doublevà hàm tạo sẽ chỉ có một tham số int, trong tình huống này sẽ dẫn đến lỗi biên dịch.

Cuộc gọi và toán tử xây dựngnew

Hàm tạo luôn được gọi bởi toán tử new. Khi một hàm tạo được gọi với toán tử new, hàm tạo đó luôn tạo một tham chiếu đến một đối tượng mới. Không thể buộc hàm tạo tạo một tham chiếu đến một đối tượng đã tồn tại thay vì tham chiếu đến một đối tượng mới, ngoại trừ bằng cách thay thế đối tượng đang được giải tuần tự hóa. Và với toán tử mới, thay vì tham chiếu đến một đối tượng mới, không thể tạo tham chiếu đến một đối tượng đã tồn tại. Ví dụ: Tập tinSalary3.java 
class Salary3
{
 int value = 1000;
 Salary3()
 {
 }
 Salary3(Salary3 x)
 {
  x.value = x.value * 3;
 }
 public static void main(String args[])
 {
  Salary3 s1 = new Salary3();
  System.out.println("First object creation: "+s1.value);

  Salary3 s2 = new Salary3(s1);
  System.out.println("Second object creation: "+s2.value);
  System.out.println("What's happend with first object?:"+s1.value);

  Salary3 s3 = new Salary3(s1);
  System.out.println("Third object creation: "+s3.value);
  System.out.println("What's happend with first object?:"+s1.value);
 }
}
Đầu ra của chương trình là: 
First object creation: 1000
Second object creation: 1000
What's happend with first object?: 3000
Third object creation: 1000
What's happend with first object?: 9000
Đầu tiên, sử dụng dòng Salary3 s1 = new Salary3(); một đối tượng mới được tạo ra. Tiếp theo, nếu sử dụng dòng Salary3 s2 = new Salary3(s1); hoặc dây Salary3 s3 = new Salary3(s1); có thể tạo một liên kết đến một đối tượng đã tồn tại, sau đó s1.value s2.valuechúng s3.valuesẽ lưu trữ cùng một giá trị 1000. Trên thực tế trong dòng Salary3 s2 = new Salary3(s1); một đối tượng mới cho biến sẽ được tạo s2và trạng thái của đối tượng cho biến đó sẽ thay đổi s1bằng cách chuyển giá trị tham chiếu của nó cho đối tượng trong tham số hàm tạo. Điều này có thể được xác minh bằng kết quả đầu ra. Và khi thực hiện dòng Salary3 s3 = new Salary3(s1); một đối tượng MỚI cho biến sẽ được tạo s3và trạng thái của đối tượng cho biến đó sẽ lại thay đổi s1.

Hàm tạo và khối khởi tạo, chuỗi hành động khi gọi hàm tạo

Phần Tạo Đối tượng và Trình xây dựng liệt kê các hành động chung được thực hiện khi tạo đối tượng. Trong số đó có các quá trình khởi tạo các trường lớp và xây dựng hàm tạo của lớp, do đó cũng có một trật tự nội bộ:
  1. Tất cả các trường dữ liệu được khởi tạo về giá trị mặc định (0, false hoặc null).
  2. Tất cả các khối khởi tạo trường và khối khởi tạo được thực thi theo thứ tự chúng được liệt kê trong khai báo lớp.
  3. Nếu một hàm tạo khác được gọi ở dòng đầu tiên của hàm tạo thì hàm tạo được gọi sẽ được thực thi.
  4. Phần thân của hàm tạo được thực thi.
Hàm tạo có liên quan đến việc khởi tạo vì trong Java có ba cách để khởi tạo một trường trong một lớp:
  • gán một giá trị trong khai báo;
  • gán giá trị trong khối khởi tạo;
  • đặt giá trị của nó trong hàm tạo.
Đương nhiên, bạn cần sắp xếp mã khởi tạo sao cho dễ hiểu. Lớp sau đây được đưa ra làm ví dụ: 
class Initialization
{
 int i;
 short z = 10;
 static int x;
 static float y;
 static
 {
  x = 2000;
  y = 3.141;
 }
 Initialization()
 {
  System.out.println("i="+i);
  System.out.println("z="+z);
  z = 20;
  System.out.println("z="+z);
 }
}
Trong ví dụ trên, các biến được khởi tạo theo thứ tự sau: biến tĩnh được khởi tạo trước xvới ygiá trị mặc định. Tiếp theo, khối khởi tạo tĩnh được thực thi. Sau đó biến được khởi tạo ivề giá trị mặc định và biến được khởi tạo z. Tiếp theo, nhà thiết kế bắt tay vào làm việc. Việc gọi các hàm tạo của lớp không nên phụ thuộc vào thứ tự các trường được khai báo. Điều này có thể dẫn đến sai sót.

Trình xây dựng và kế thừa

Các nhà xây dựng không được kế thừa. Ví dụ: 
public class Example
{
 Example()
 {
 }
 public void sayHi()
 {
  system.out.println("Hi");
 }
}

public class SubClass extends Example
{
}
Lớp này SubClasstự động kế thừa phương thức sayHi()được định nghĩa trong lớp cha. Đồng thời, hàm tạo Example()của lớp cha không được kế thừa bởi lớp con của nó SubClass.

Từ khóa thistrong hàm tạo

Các hàm tạo được sử dụng thisđể tham chiếu đến một hàm tạo khác trong cùng một lớp, nhưng có danh sách tham số khác. Nếu hàm tạo sử dụng từ khóa this, thì nó phải nằm ở dòng đầu tiên; bỏ qua quy tắc này sẽ dẫn đến lỗi trình biên dịch. Ví dụ: Tập tinThisDemo.java 
public class ThisDemo
{
 String name;
 ThisDemo(String s)
 {
  name = s;
     System.out.println(name);
 }
 ThisDemo()
 {
  this("John");
 }
 public static void main(String args[])
 {
  ThisDemo td1 = new ThisDemo("Mary");
  ThisDemo td2 = new ThisDemo();
 }
}
Đầu ra của chương trình là: 
Mary
John
Trong ví dụ này có hai hàm tạo. Cái đầu tiên nhận được một đối số chuỗi. Cái thứ hai không nhận bất kỳ đối số nào, nó chỉ gọi hàm tạo đầu tiên bằng tên mặc định "John". Do đó, bạn có thể sử dụng hàm tạo để khởi tạo các giá trị trường một cách rõ ràng và theo mặc định, điều này thường cần thiết trong các chương trình.

Từ khóa supertrong hàm tạo

Các hàm tạo được sử dụng superđể gọi hàm tạo của siêu lớp. Nếu hàm tạo sử dụng super, thì lệnh gọi này phải ở dòng đầu tiên, nếu không trình biên dịch sẽ báo lỗi. Dưới đây là một ví dụ: TệpSuperClassDemo.java 
public class SuperClassDemo
{
 SuperClassDemo()
 {
 }
}

class Child extends SuperClassDemo
{
 Child()
 {
  super();
 }
}
Trong ví dụ đơn giản này, hàm tạo Child()chứa lệnh gọi super()tạo một thể hiện của lớp SuperClassDemo, ngoài lớp Child. Vì supernó phải là câu lệnh đầu tiên được thực thi trong hàm tạo của lớp con nên thứ tự này luôn giống nhau và không phụ thuộc vào việc có hay không super(). Nếu nó không được sử dụng thì hàm tạo mặc định (không có tham số) của mỗi siêu lớp, bắt đầu từ lớp cơ sở, sẽ được thực thi trước tiên. Chương trình sau đây minh họa khi nào các hàm tạo được thực thi. Tài liệuCall.java 
//Создать суперкласс A
class A
{
 A()
 {
  System.out.println("Inside A constructor.");
 }
}

//Создать подкласс B, расширяющий класс A
class B extends A
{
 B()
 {
  System.out.println("Inside B constructor.");
 }
}

//Создать класс (C), расширяющий класс В
class C extends B
{
 C()
 {
  System.out.println("Inside C constructor.");
 }
}

class Call
{
 public static void main(String args[])
 {
  C c = new C();
 }
}
Đầu ra từ chương trình này: 
Inside A constructor.
Inside B constructor.
Inside C constructor.
Các nhà xây dựng được gọi theo thứ tự phụ thuộc của lớp. Điều này có ý nghĩa nào đó. Vì siêu lớp không có kiến ​​thức về bất kỳ lớp con nào nên mọi khởi tạo mà nó cần thực hiện đều riêng biệt. Nếu có thể, nó nên đi trước bất kỳ sự khởi tạo nào được thực hiện bởi lớp con. Đó là lý do tại sao nó nên được thực hiện đầu tiên.

Các nhà xây dựng có thể tùy chỉnh

Cơ chế nhận dạng kiểu thời gian chạy là một trong những nguyên tắc cốt lõi mạnh mẽ của ngôn ngữ Java triển khai tính đa hình. Tuy nhiên, cơ chế như vậy không bảo vệ nhà phát triển khỏi việc truyền kiểu không tương thích trong một số trường hợp. Trường hợp phổ biến nhất là thao tác với một nhóm đối tượng, các loại đối tượng khác nhau không được biết trước và được xác định trong thời gian chạy. Vì các lỗi liên quan đến tính không tương thích về loại chỉ có thể xuất hiện ở giai đoạn chạy, điều này khiến chúng khó tìm và loại bỏ. Việc giới thiệu các kiểu tùy chỉnh trong Java 2 5.0 sẽ chuyển một số lỗi này từ thời gian chạy sang thời gian biên dịch và cung cấp một số tính năng an toàn cho kiểu còn thiếu. Không cần phải ép kiểu rõ ràng khi chuyển từ kiểu này Objectsang kiểu cụ thể. Cần lưu ý rằng các công cụ tùy chỉnh kiểu chỉ hoạt động với các đối tượng và không áp dụng cho các kiểu dữ liệu nguyên thủy nằm bên ngoài cây kế thừa lớp. Với các loại tùy chỉnh, tất cả các diễn viên được thực hiện tự động và ở hậu trường. Điều này cho phép bạn bảo vệ khỏi các kiểu không khớp và sử dụng lại mã thường xuyên hơn. Các loại tùy chỉnh có thể được sử dụng trong các hàm tạo. Trình xây dựng có thể được tùy chỉnh ngay cả khi lớp của chúng không phải là loại tùy chỉnh. Ví dụ: 
class GenConstructor
{
 private double val;
 <T extends Number> GenConstructor(T arg)
 {
   val = arg.doubleValue();
 }

 void printValue()
 {
  System.out.println("val: "+val);
 }
}

class GenConstructorDemo
{
 public static void main(String args[])
 {
  GenConstructor gc1 = new GenConstructor(100);
  GenConstructor gc2 = new GenConstructor(123.5F);

  gc1.printValue();
  gc2.printValue();
 }
}
Bởi vì hàm tạo GenConstructorchỉ định một tham số kiểu tùy chỉnh phải là lớp dẫn xuất từ ​​lớp Number, nên nó có thể được gọi từ bất kỳ lớp nào.
Bình luận
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION