Trong lập trình hướng đối tượng, dựa trên lớp, một hàm tạo (viết tắt. ctor) là một loại chương trình con đặc biệt được gọi để tạo một đối tượng. Nó chuẩn bị đối tượng mới để sử dụng, thường chấp nhận các đối số mà hàm tạo sử dụng để đặt các biến thành viên cần thiết Show
Một hàm tạo giống như một phương thức thể hiện, nhưng nó khác với một phương thức ở chỗ nó không có kiểu trả về rõ ràng, nó không được kế thừa hoàn toàn và nó thường có các quy tắc khác nhau cho các công cụ sửa đổi phạm vi. Constructor thường có cùng tên với lớp khai báo. Chúng có nhiệm vụ khởi tạo các thành viên dữ liệu của đối tượng và thiết lập bất biến của lớp, thất bại nếu bất biến không hợp lệ. Một hàm tạo được viết đúng để đối tượng kết quả ở trạng thái hợp lệ. Các đối tượng bất biến phải được khởi tạo trong một hàm tạo Hầu hết các ngôn ngữ cho phép quá tải hàm tạo trong đó có thể có nhiều hơn một hàm tạo cho một lớp, với các tham số khác nhau. Một số ngôn ngữ xem xét một số loại hàm tạo đặc biệt. Các hàm tạo, cụ thể sử dụng một lớp duy nhất để tạo các đối tượng và trả về một thể hiện mới của lớp, được trừu tượng hóa bởi các nhà máy, cũng tạo ra các đối tượng nhưng có thể làm như vậy theo nhiều cách khác nhau, sử dụng nhiều lớp hoặc các sơ đồ phân bổ khác nhau, chẳng hạn như nhóm đối tượng Các hàm tạo được tham số hóa[sửa]Các hàm tạo có thể nhận ít nhất một đối số được gọi là các hàm tạo được tham số hóa. Khi một đối tượng được khai báo trong hàm tạo được tham số hóa, các giá trị ban đầu phải được truyền dưới dạng đối số cho hàm tạo. Cách khai báo đối tượng thông thường có thể không hoạt động. Các hàm tạo có thể được gọi rõ ràng hoặc ngầm định. Phương thức gọi hàm tạo ngầm định còn được gọi là phương thức tốc ký class Example {
public:
Example();
Example(int a, int b); // Parameterized constructor.
private:
int x_;
int y_;
};
Example::Example() = default;
Example::Example(int x, int y) : x_(x), y_(y) {}
Example e = Example(0, 50); // Explicit call. Example e2(0, 50); // Implicit call. Hàm tạo mặc định[sửa]Nếu lập trình viên không cung cấp hàm tạo cho lớp có thể khởi tạo, trình biên dịch Java sẽ thay mặt bạn chèn hàm tạo mặc định vào mã của bạn. Hàm tạo này được gọi là hàm tạo mặc định. Bạn sẽ không tìm thấy nó trong mã nguồn của mình (tệp java) vì nó sẽ được chèn vào mã trong quá trình biên dịch và tồn tại trong. tập tin lớp. Hành vi của hàm tạo mặc định phụ thuộc vào ngôn ngữ. Nó có thể khởi tạo các thành viên dữ liệu thành 0 hoặc các giá trị tương tự khác hoặc có thể không làm gì cả. Trong Java, một "hàm tạo mặc định" đề cập đến một hàm tạo rỗng được trình biên dịch tự động tạo ra nếu không có hàm tạo nào được định nghĩa cho lớp hoặc trong trường hợp không có bất kỳ hàm tạo nào do lập trình viên định nghĩa (e. g. trong Java, hàm tạo mặc định gọi ngầm hàm tạo nullary của siêu lớp, sau đó thực thi một phần thân trống). Tất cả các trường được để nguyên ở giá trị ban đầu là 0 (kiểu số nguyên), 0. 0 (kiểu dấu phẩy động), false (kiểu boolean) hoặc null (kiểu tham chiếu) #include
class Student {
public:
Student(int a = 0, int b = 0); // Default constructor.
int a;
int b;
};
Sao chép hàm tạo[sửa]Giống như C++, Java cũng hỗ trợ "Copy Constructor". Tuy nhiên, không giống như C++, Java không tạo một hàm tạo sao chép mặc định nếu bạn không tự viết. Copy constructor xác định các hành động được thực hiện bởi trình biên dịch khi sao chép các đối tượng lớp. Hàm tạo Sao chép có một tham số chính thức là loại của lớp (tham số có thể là tham chiếu đến một đối tượng). Nó được sử dụng để tạo một bản sao của một đối tượng hiện có của cùng một lớp. Mặc dù cả hai lớp đều giống nhau, nhưng nó được tính là hàm tạo chuyển đổi. Mặc dù các hàm tạo sao chép thường được viết tắt là copy ctor hoặc cctor, nhưng chúng không liên quan gì đến các hàm tạo của lớp được sử dụng trong. NET sử dụng cùng một từ viết tắt Hàm tạo chuyển đổi[sửa]Các hàm tạo chuyển đổi cung cấp một phương tiện để trình biên dịch tạo hoàn toàn một đối tượng thuộc về một lớp dựa trên một đối tượng thuộc loại khác. Các hàm tạo này thường được gọi ngầm để chuyển đổi các đối số hoặc toán hạng thành một kiểu thích hợp, nhưng chúng cũng có thể được gọi một cách rõ ràng Di chuyển các hàm tạo[sửa]Trong C++, các hàm tạo di chuyển lấy một tham chiếu Rvalue tới một đối tượng của lớp và được sử dụng để thực hiện chuyển quyền sở hữu các tài nguyên của đối tượng tham số
Tổ chức bộ nhớ[sửa]Trong Java, C# và VB. NET, hàm tạo tạo các đối tượng kiểu tham chiếu trong một cấu trúc bộ nhớ đặc biệt được gọi là "đống". Các loại giá trị (chẳng hạn như int, double, v.v. ) được tạo theo cấu trúc tuần tự gọi là "ngăn xếp". VB. NET và C# cũng cho phép sử dụng toán tử new để tạo các đối tượng kiểu giá trị, nhưng các đối tượng kiểu giá trị này được tạo trên ngăn xếp bất kể toán tử có được sử dụng hay không Trong C++, các đối tượng được tạo trên ngăn xếp khi hàm tạo được gọi mà không có toán tử new và được tạo trên heap khi hàm tạo được gọi với toán tử mới. Các đối tượng ngăn xếp bị xóa hoàn toàn khi chúng vượt quá phạm vi, trong khi các đối tượng heap phải được xóa hoàn toàn bằng hàm hủy hoặc rõ ràng bằng cách sử dụng toán tử xóa Chi tiết ngôn ngữ[sửa | sửa mã nguồn]Trong C++, tên của hàm tạo là tên của lớp. Nó không trả lại gì. Nó có thể có các tham số giống như bất kỳ hàm thành viên nào. Hàm xây dựng thường được khai báo trong phần chung, nhưng cũng có thể được khai báo trong phần được bảo vệ và riêng tư, nếu người dùng muốn hạn chế quyền truy cập vào chúng Hàm tạo có hai phần. Đầu tiên là danh sách trình khởi tạo theo sau danh sách tham số và trước thân phương thức. Nó bắt đầu bằng dấu hai chấm và các mục được phân tách bằng dấu phẩy. Danh sách trình khởi tạo không bắt buộc, nhưng tạo cơ hội cung cấp giá trị cho các thành viên dữ liệu và tránh các câu lệnh gán riêng biệt. Danh sách trình khởi tạo là bắt buộc nếu bạn có các thành viên dữ liệu kiểu const hoặc kiểu tham chiếu hoặc các thành viên không có logic hàm tạo không tham số. Việc gán xảy ra theo thứ tự khai báo các thành viên dữ liệu (ngay cả khi thứ tự trong danh sách trình khởi tạo là khác). Phần thứ hai là phần thân, là phần thân của phương thức bình thường được đặt trong dấu ngoặc nhọn C++ cho phép nhiều hơn một hàm tạo. Các hàm tạo khác phải có các tham số khác nhau. Ngoài ra, các hàm tạo có chứa tham số được cung cấp giá trị mặc định, phải tuân thủ hạn chế rằng không phải tất cả tham số đều được cung cấp giá trị mặc định. Đây là một tình huống chỉ quan trọng nếu có một hàm tạo mặc định. Hàm tạo của một lớp cơ sở (hoặc các lớp cơ sở) cũng có thể được gọi bởi một lớp dẫn xuất. Hàm xây dựng không được kế thừa và địa chỉ của chúng không thể được tham chiếu. Khi cấp phát bộ nhớ được yêu cầu, các toán tử mới và xóa được gọi ngầm Hàm tạo bản sao có tham số cùng loại được truyền dưới dạng tham chiếu const, ví dụ: Vector(const Vector& rhs). Nếu nó không được cung cấp rõ ràng, trình biên dịch sẽ sử dụng hàm tạo sao chép cho từng biến thành viên hoặc chỉ sao chép các giá trị trong trường hợp các kiểu nguyên thủy. Việc triển khai mặc định sẽ không hiệu quả nếu lớp có các thành viên được phân bổ động (hoặc xử lý các tài nguyên khác), bởi vì nó có thể dẫn đến các cuộc gọi kép để xóa (hoặc giải phóng tài nguyên hai lần) khi hủy class Foobar {
public:
Foobar(double r = 1.0,
double alpha = 0.0) // Constructor, parameters with default values.
: x_(r * cos(alpha)) // <- Initializer list
{
y_ = r * sin(alpha); // <- Normal assignment
}
private:
double x_;
double y_;
};
lời gọi ví dụ ________số 8 Khi trả về các đối tượng từ các hàm hoặc truyền các đối tượng theo giá trị, hàm tạo sao chép đối tượng sẽ được gọi ngầm, trừ khi áp dụng tối ưu hóa giá trị trả về C++ tạo ngầm định một hàm tạo sao chép mặc định sẽ gọi hàm tạo sao chép cho tất cả các lớp cơ sở và tất cả các biến thành viên trừ khi lập trình viên cung cấp một, xóa rõ ràng hàm tạo sao chép (để ngăn sao chép) hoặc một trong các lớp cơ sở hoặc hàm tạo sao chép biến thành viên bị xóa . Hầu hết các trường hợp yêu cầu một trình tạo bản sao tùy chỉnh (e. g. đếm tham chiếu, bản sao sâu của con trỏ) cũng yêu cầu tùy chỉnh hàm hủy và toán tử gán bản sao. Điều này thường được gọi là Quy tắc ba Ví dụ hàm tạo C# Example e = Example(0, 50); // Explicit call. Example e2(0, 50); // Implicit call.9 #include
class Student {
public:
Student(int a = 0, int b = 0); // Default constructor.
int a;
int b;
};
5Hàm tạo tĩnh C#[sửa]Trong C#, hàm tạo tĩnh là trình khởi tạo dữ liệu tĩnh. Hàm tạo tĩnh còn được gọi là hàm tạo lớp. Vì phương thức thực tế được tạo có tên. cctor chúng thường được gọi là "ccctor" Các hàm tạo tĩnh cho phép khởi tạo biến tĩnh phức tạp. Các hàm tạo tĩnh được gọi ngầm khi lớp được truy cập lần đầu tiên. Bất kỳ cuộc gọi nào đến một lớp (cuộc gọi tĩnh hoặc hàm tạo), sẽ kích hoạt thực thi hàm tạo tĩnh. Các hàm tạo tĩnh là luồng an toàn và triển khai một mẫu đơn. Khi được sử dụng trong một lớp lập trình chung, các hàm tạo tĩnh được gọi ở mỗi lần khởi tạo chung mới cho mỗi loại. Các biến tĩnh cũng được khởi tạo #include
class Student {
public:
Student(int a = 0, int b = 0); // Default constructor.
int a;
int b;
};
6#include
class Student {
public:
Student(int a = 0, int b = 0); // Default constructor.
int a;
int b;
};
7CFML sử dụng phương thức có tên ' Foobar a,
b(3),
c(5, M_PI/4);
8' làm phương thức khởi tạoPhô mai. cfc #include
class Student {
public:
Student(int a = 0, int b = 0); // Default constructor.
int a;
int b;
};
9Tạo ví dụ về pho mát Example e = Example(0, 50); // Explicit call. Example e2(0, 50); // Implicit call.0 Kể từ ColdFusion 10, CFML cũng đã hỗ trợ chỉ định tên của phương thức khởi tạo Example e = Example(0, 50); // Explicit call. Example e2(0, 50); // Implicit call.1 Ở Eiffel, thủ tục khởi tạo đối tượng mới được gọi là thủ tục tạo. Quy trình sáng tạo có các đặc điểm sau
Mặc dù việc tạo đối tượng liên quan đến một số sự tinh tế, nhưng việc tạo một thuộc tính với một khai báo điển hình Example e = Example(0, 50); // Explicit call. Example e2(0, 50); // Implicit call.95 như được thể hiện trong hướng dẫn tạo Example e = Example(0, 50); // Explicit call. Example e2(0, 50); // Implicit call.96 bao gồm trình tự các bước sau
Trong đoạn mã đầu tiên bên dưới, lớp #include
class Student {
public:
Student(int a = 0, int b = 0); // Default constructor.
int a;
int b;
};
50 được định nghĩa. Thủ tục Example e = Example(0, 50); // Explicit call. Example e2(0, 50); // Implicit call.98 được mã hóa sau từ khóa #include
class Student {
public:
Student(int a = 0, int b = 0); // Default constructor.
int a;
int b;
};
52Từ khóa #include
class Student {
public:
Student(int a = 0, int b = 0); // Default constructor.
int a;
int b;
};
53 giới thiệu một danh sách các thủ tục có thể được sử dụng để khởi tạo các phiên bản. Trong trường hợp này, danh sách bao gồm #include
class Student {
public:
Student(int a = 0, int b = 0); // Default constructor.
int a;
int b;
};
54, một thủ tục có triển khai trống được kế thừa từ lớp #include
class Student {
public:
Student(int a = 0, int b = 0); // Default constructor.
int a;
int b;
};
55 và thủ tục Example e = Example(0, 50); // Explicit call. Example e2(0, 50); // Implicit call.98 được mã hóa trong lớp Example e = Example(0, 50); // Explicit call. Example e2(0, 50); // Implicit call.2 Trong đoạn mã thứ hai, một lớp là khách hàng của #include
class Student {
public:
Student(int a = 0, int b = 0); // Default constructor.
int a;
int b;
};
50 có khai báo #include
class Student {
public:
Student(int a = 0, int b = 0); // Default constructor.
int a;
int b;
};
58 và #include
class Student {
public:
Student(int a = 0, int b = 0); // Default constructor.
int a;
int b;
};
59 thuộc loại #include
class Student {
public:
Student(int a = 0, int b = 0); // Default constructor.
int a;
int b;
};
50Trong mã thủ tục, #include
class Student {
public:
Student(int a = 0, int b = 0); // Default constructor.
int a;
int b;
};
58 được tạo làm nguồn gốc (0. 0, 0. 0). Bởi vì không có quy trình tạo nào được chỉ định, nên quy trình #include
class Student {
public:
Student(int a = 0, int b = 0); // Default constructor.
int a;
int b;
};
54 kế thừa từ lớp #include
class Student {
public:
Student(int a = 0, int b = 0); // Default constructor.
int a;
int b;
};
55 được sử dụng. Dòng này có thể đã được mã hóa #include
class Student {
public:
Student(int a = 0, int b = 0); // Default constructor.
int a;
int b;
};
64. Chỉ các thủ tục có tên là thủ tục tạo mới có thể được sử dụng trong một lệnh với từ khóa #include
class Student {
public:
Student(int a = 0, int b = 0); // Default constructor.
int a;
int b;
};
53. Tiếp theo là hướng dẫn tạo cho #include
class Student {
public:
Student(int a = 0, int b = 0); // Default constructor.
int a;
int b;
};
59, cung cấp các giá trị ban đầu cho tọa độ của #include
class Student {
public:
Student(int a = 0, int b = 0); // Default constructor.
int a;
int b;
};
59. Lệnh thứ ba thực hiện một cuộc gọi phiên bản thông thường đến thủ tục Example e = Example(0, 50); // Explicit call. Example e2(0, 50); // Implicit call.98 để khởi tạo lại phiên bản được đính kèm với #include
class Student {
public:
Student(int a = 0, int b = 0); // Default constructor.
int a;
int b;
};
59 với các giá trị khác nhauExample e = Example(0, 50); // Explicit call. Example e2(0, 50); // Implicit call.3 Trong F#, hàm tạo có thể bao gồm bất kỳ câu lệnh #include
class Student {
public:
Student(int a = 0, int b = 0); // Default constructor.
int a;
int b;
};
70 hoặc #include
class Student {
public:
Student(int a = 0, int b = 0); // Default constructor.
int a;
int b;
};
71 nào được định nghĩa trong một lớp. Câu lệnh #include
class Student {
public:
Student(int a = 0, int b = 0); // Default constructor.
int a;
int b;
};
70 xác định trường riêng và câu lệnh #include
class Student {
public:
Student(int a = 0, int b = 0); // Default constructor.
int a;
int b;
};
71 thực thi mã. Các hàm tạo bổ sung có thể được xác định bằng từ khóa Example e = Example(0, 50); // Explicit call. Example e2(0, 50); // Implicit call.91 Example e = Example(0, 50); // Explicit call. Example e2(0, 50); // Implicit call.4 Example e = Example(0, 50); // Explicit call. Example e2(0, 50); // Implicit call.5 Trong Java, hàm tạo khác với các phương thức khác ở chỗ
Các hàm tạo Java thực hiện các tác vụ sau theo thứ tự sau
Java cho phép người dùng gọi một hàm tạo trong một hàm tạo khác bằng cách sử dụng từ khóa #include
class Student {
public:
Student(int a = 0, int b = 0); // Default constructor.
int a;
int b;
};
76. Nhưng #include
class Student {
public:
Student(int a = 0, int b = 0); // Default constructor.
int a;
int b;
};
76 phải là câu lệnh đầu tiên. Example e = Example(0, 50); // Explicit call. Example e2(0, 50); // Implicit call.6 Java cung cấp quyền truy cập vào hàm tạo của lớp cha thông qua từ khóa #include
class Student {
public:
Student(int a = 0, int b = 0); // Default constructor.
int a;
int b;
};
78Example e = Example(0, 50); // Explicit call. Example e2(0, 50); // Implicit call.7 Example e = Example(0, 50); // Explicit call. Example e2(0, 50); // Implicit call.8 Hàm tạo nhận số đối số bằng 0 được gọi là hàm tạo "không có đối số" hoặc "không có đối số" JavaScript[sửa]Kể từ ES6, JavaScript có các hàm tạo trực tiếp như nhiều ngôn ngữ lập trình khác. Chúng được viết như vậy Example e = Example(0, 50); // Explicit call. Example e2(0, 50); // Implicit call.9 Điều này có thể được khởi tạo như vậy Tương đương với điều này trước ES6, là tạo một hàm khởi tạo một đối tượng như vậy #include
class Student {
public:
Student(int a = 0, int b = 0); // Default constructor.
int a;
int b;
};
0Điều này được khởi tạo theo cách tương tự như trên Đối tượng Pascal[sửa]Trong Object Pascal, hàm tạo tương tự như một phương thức xuất xưởng. Sự khác biệt duy nhất về cú pháp đối với các phương thức thông thường là từ khóa Foobar a,
b(3),
c(5, M_PI/4);
5 ở phía trước tên (thay vì #include
class Student {
public:
Student(int a = 0, int b = 0); // Default constructor.
int a;
int b;
};
90 hoặc #include
class Student {
public:
Student(int a = 0, int b = 0); // Default constructor.
int a;
int b;
};
91). Nó có thể có bất kỳ tên nào, mặc dù quy ước là có tiền tố Foobar a,
b(3),
c(5, M_PI/4);
6, chẳng hạn như trong #include
class Student {
public:
Student(int a = 0, int b = 0); // Default constructor.
int a;
int b;
};
93. Tạo một thể hiện của một lớp hoạt động giống như gọi một phương thức tĩnh của một lớp. #include
class Student {
public:
Student(int a = 0, int b = 0); // Default constructor.
int a;
int b;
};
94#include
class Student {
public:
Student(int a = 0, int b = 0); // Default constructor.
int a;
int b;
};
1Trong OCaml, có một hàm tạo. Các tham số được định nghĩa ngay sau tên lớp. Chúng có thể được sử dụng để khởi tạo các biến thể hiện và có thể truy cập được trong toàn bộ lớp. Một phương thức ẩn danh có tên là #include
class Student {
public:
Student(int a = 0, int b = 0); // Default constructor.
int a;
int b;
};
95 cho phép đánh giá một biểu thức ngay sau khi đối tượng được tạo. #include
class Student {
public:
Student(int a = 0, int b = 0); // Default constructor.
int a;
int b;
};
2Trong PHP phiên bản 5 trở lên, hàm tạo là một phương thức có tên là #include
class Student {
public:
Student(int a = 0, int b = 0); // Default constructor.
int a;
int b;
};
96 (lưu ý rằng đó là dấu gạch dưới kép), mà từ khóa Example e = Example(0, 50); // Explicit call. Example e2(0, 50); // Implicit call.91 sẽ tự động gọi sau khi tạo đối tượng. Nó thường được sử dụng để tự động thực hiện khởi tạo chẳng hạn như khởi tạo thuộc tính. Các hàm tạo cũng có thể chấp nhận các đối số, trong trường hợp đó, khi câu lệnh Example e = Example(0, 50); // Explicit call. Example e2(0, 50); // Implicit call.91 được viết, bạn cũng cần gửi các đối số hàm tạo cho các tham số #include
class Student {
public:
Student(int a = 0, int b = 0); // Default constructor.
int a;
int b;
};
3Trong PHP, một lớp chỉ được phép khai báo tối đa một phương thức khởi tạo. Các phương thức tĩnh, các lớp xuất xưởng hoặc các đối số hàm tạo tùy chọn là một số cách để tạo điều kiện thuận lợi cho nhiều cách tạo đối tượng của một lớp PHP Trong ngôn ngữ lập trình Perl phiên bản 5, theo mặc định, các hàm tạo là các phương thức xuất xưởng, nghĩa là các phương thức tạo và trả về đối tượng, cụ thể là tạo và trả về một tham chiếu may mắn. Một đối tượng điển hình là tham chiếu đến hàm băm, mặc dù hiếm khi tham chiếu đến các loại khác cũng được sử dụng. Theo quy ước, hàm tạo duy nhất được đặt tên mới, mặc dù nó được phép đặt tên khác hoặc có nhiều hàm tạo. Ví dụ: một lớp Person có thể có một hàm tạo có tên new cũng như một hàm tạo new_from_file đọc tệp cho các thuộc tính Person và new_from_person sử dụng một đối tượng Person khác làm mẫu #include
class Student {
public:
Student(int a = 0, int b = 0); // Default constructor.
int a;
int b;
};
4Perl 5 với Moose[sửa]Với hệ thống đối tượng Moose cho Perl, hầu hết bản soạn sẵn này có thể được bỏ đi, một cái mới mặc định được tạo, các thuộc tính có thể được chỉ định, cũng như liệu chúng có thể được đặt, đặt lại hoặc được yêu cầu hay không. Ngoài ra, bất kỳ chức năng xây dựng bổ sung nào cũng có thể được bao gồm trong phương thức BUILD mà hàm tạo do Moose tạo sẽ gọi, sau khi nó đã kiểm tra các đối số. Một phương thức BUILDARGS có thể được chỉ định để xử lý các đối số của hàm tạo không ở dạng hashref/key => value #include
class Student {
public:
Student(int a = 0, int b = 0); // Default constructor.
int a;
int b;
};
5Trong cả hai trường hợp, lớp Person được khởi tạo như thế này #include
class Student {
public:
Student(int a = 0, int b = 0); // Default constructor.
int a;
int b;
};
6Trong Python, hàm tạo được xác định bởi một hoặc cả hai phương thức class Foobar {
public:
Foobar(double r = 1.0,
double alpha = 0.0) // Constructor, parameters with default values.
: x_(r * cos(alpha)) // <- Initializer list
{
y_ = r * sin(alpha); // <- Normal assignment
}
private:
double x_;
double y_;
};
9 và Foobar a,
b(3),
c(5, M_PI/4);
0. Một thể hiện mới được tạo bằng cách gọi lớp như thể nó là một hàm, gọi các phương thức class Foobar {
public:
Foobar(double r = 1.0,
double alpha = 0.0) // Constructor, parameters with default values.
: x_(r * cos(alpha)) // <- Initializer list
{
y_ = r * sin(alpha); // <- Normal assignment
}
private:
double x_;
double y_;
};
9 và Foobar a,
b(3),
c(5, M_PI/4);
0. Nếu một phương thức khởi tạo không được định nghĩa trong lớp, thì phương thức tiếp theo được tìm thấy trong Thứ tự giải quyết phương thức của lớp sẽ được gọiTrong trường hợp điển hình, chỉ cần xác định phương thức Foobar a,
b(3),
c(5, M_PI/4);
0. (Ngoại lệ phổ biến nhất là đối với các đối tượng bất biến. )#include
class Student {
public:
Student(int a = 0, int b = 0); // Default constructor.
int a;
int b;
};
7Các lớp thường đóng vai trò là nhà máy cho các thể hiện mới của chính chúng, nghĩa là một lớp là một đối tượng có thể gọi được (giống như một hàm), với lời gọi là hàm tạo và việc gọi lớp trả về một thể hiện của lớp đó. Tuy nhiên, phương thức class Foobar {
public:
Foobar(double r = 1.0,
double alpha = 0.0) // Constructor, parameters with default values.
: x_(r * cos(alpha)) // <- Initializer list
{
y_ = r * sin(alpha); // <- Normal assignment
}
private:
double x_;
double y_;
};
9 được phép trả về một thứ khác ngoài một thể hiện của lớp cho các mục đích chuyên biệt. Trong trường hợp đó, Foobar a,
b(3),
c(5, M_PI/4);
0 không được gọiVới Raku, thậm chí có thể loại bỏ nhiều bản soạn sẵn hơn, với điều kiện là một phương thức mới mặc định được kế thừa, các thuộc tính có thể được chỉ định, cũng như liệu chúng có thể được đặt, đặt lại hoặc được yêu cầu hay không. Ngoài ra, bất kỳ chức năng xây dựng bổ sung nào cũng có thể được đưa vào phương thức BUILD sẽ được gọi để cho phép khởi tạo tùy chỉnh. Một phương thức TWEAK có thể được chỉ định để xử lý hậu kỳ bất kỳ thuộc tính nào đã được khởi tạo (ngầm) #include
class Student {
public:
Student(int a = 0, int b = 0); // Default constructor.
int a;
int b;
};
8Lớp Person được khởi tạo như thế này #include
class Student {
public:
Student(int a = 0, int b = 0); // Default constructor.
int a;
int b;
};
9Ngoài ra, các tham số được đặt tên có thể được chỉ định bằng cú pháp cặp dấu hai chấm trong Perl 6 class Foobar {
public:
Foobar(double r = 1.0,
double alpha = 0.0) // Constructor, parameters with default values.
: x_(r * cos(alpha)) // <- Initializer list
{
y_ = r * sin(alpha); // <- Normal assignment
}
private:
double x_;
double y_;
};
0Và nếu bạn đã thiết lập các biến có tên trùng với tham số đã đặt tên, bạn có thể sử dụng lối tắt sẽ sử dụng tên của biến cho tham số đã đặt tên class Foobar {
public:
Foobar(double r = 1.0,
double alpha = 0.0) // Constructor, parameters with default values.
: x_(r * cos(alpha)) // <- Initializer list
{
y_ = r * sin(alpha); // <- Normal assignment
}
private:
double x_;
double y_;
};
1Trong Ruby, các hàm tạo được tạo bằng cách định nghĩa một phương thức có tên là Example e = Example(0, 50); // Explicit call. Example e2(0, 50); // Implicit call.06. Phương thức này được thực thi để khởi tạo từng phiên bản mới Khi một đối tượng được truyền dưới dạng đối số cho một phương thức?Khi một đối tượng được truyền dưới dạng đối số cho một phương thức, đối tượng này thực sự được truyền . đây là tên của một biến tham chiếu luôn có sẵn cho một phương thức thể hiện và tham chiếu đến đối tượng đang gọi phương thức đó. Trường mảng này chứa số phần tử mà mảng có.
Phương thức nào được gọi khi tự động khi một đối tượng được tạo?Constructor là phương thức được gọi tự động khi một đối tượng của lớp được tạo. Chúng cung cấp các giá trị ban đầu trong các trường mẫu.
Khi một đối tượng được truyền cho một phương thức, cái gì thực sự được truyền?Ghi chú. Khi một tham chiếu đối tượng được truyền cho một phương thức, chính tham chiếu đó được truyền bằng cách sử dụng lệnh gọi theo giá trị . Tuy nhiên, vì giá trị được truyền tham chiếu đến một đối tượng, nên bản sao của giá trị đó sẽ vẫn tham chiếu đến cùng một đối tượng mà đối số tương ứng của nó thực hiện.
Khi gọi một phương thức với một đối số đối tượng ___ được thông qua?Khi gọi phương thức có đối số đối tượng, tham chiếu đến đối tượng được chuyển. Bạn phải truyền vào một đối tượng cho một phương thức để có thể sửa đổi một đối số. Trong Java, các đối tượng cũng được truyền theo giá trị; . |
