Vòng đời đối tượng
Trong lập trình hướng đối tượng (OOP), vòng đời đối tượng (tiếng Anh: object lifetime hay life cycle) của một đối tượng là khoảng thời gian giữa việc tạo ra và hủy đi của đối tượng đó. Các quy tắc đối với vòng đời đối tượng có sự khác nhau đáng kể giữa các ngôn ngữ, trong một số trường hợp giữa sự hiện thực của một ngôn ngữ nhất định, và vòng đời của một đối tượng cụ thể có thể khác nhau tùy thời điểm chạy của chương trình.
Trong một số trường hợp, vòng đời của đối tượng trùng với vòng đời biến của một biến với đối tượng đó như giá trị (cho cả biến tĩnh và biến tự động), nhưng nhìn chung thì vòng đời đối tượng không được gắn với vòng đời của bất cứ biến nào. Trong nhiều trường hợp – và mặc định trong ngôn ngữ hướng đối tượng (OOL), đặc biệt với những ngôn ngữ dùng cơ chế thu gom rác (GC) – các đối tượng được cấp phát trong bộ nhớ heap, và vòng đời đối tượng không được xác định bởi vòng đời của một biến: giá trị của biến nắm giữ một đối tượng thật ra tương ứng với một tham chiếu đến đối tượng chứ không phải là đối tượng đó, và hủy đi một biến chỉ phá hủy tham chiếu chứ không phải là đối tượng bên dưới.
Ví dụ
C++
class Foo{ // This is the prototype of the constructorspublic: Foo(int x); Foo(int x, int y); // Overloaded Constructor Foo(const Foo &old); // Copy Constructor ~Foo(); // Destructor};Foo::Foo(int x){ // This is the implementation of // the one-argument constructor}Foo::Foo(int x, int y){ // This is the implementation of // the two-argument constructor}Foo::Foo(const Foo &old){ // This is the implementation of // the copy constructor}Foo::~Foo(){ // This is the implementation of the destructor}int main(){ Foo foo(14); // call first constructor Foo foo2(12, 16); // call overloaded constructor Foo foo3(foo); // call the copy constructo return 0; // destructors called in backwards-order // here, automatically}Java
class Foo{ public Foo(int x) { // This is the implementation of // the one-argument constructor } public Foo(int x, int y) { // This is the implementation of // the two-argument constructor } public Foo(Foo old) { // This is the implementation of // the copy constructor } public static void main(String[] args) { Foo foo = new Foo(14); // call first constructor Foo foo2 = new Foo(12, 16); // call overloaded constructor Foo foo3 = new Foo(foo); // call the copy constructor // garbage collection happens under the covers, and objects are destroyed }}C#
namespace ObjectLifeTime {class Foo{ public Foo() { // This is the implementation of // default constructor } public Foo(int x) { // This is the implementation of // the one-argument constructor } ~Foo() { // This is the implementation of // the destructor } public Foo(int x, int y) { // This is the implementation of // the two-argument constructor } public Foo(Foo old) { // This is the implementation of // the copy constructor } public static void Main(string[] args) { Foo defaultfoo = new Foo(); // call default constructor Foo foo = new Foo(14); // call first constructor Foo foo2 = new Foo(12, 16); // call overloaded constructor Foo foo3 = new Foo(foo); // call the copy constructor } }}Objective-C
#import <objc/Object.h>@interface Point: Object{ double x; double y;}//These are the class methods; we have declared two constructors+ (Point *) newWithX: (double) andY: (double);+ (Point *) newWithR: (double) andTheta: (double);//Instance methods- (Point *) setFirstCoord: (double);- (Point *) setSecondCoord: (double);/* Since Point is a subclass of the generic Object * class, we already gain generic allocation and initialization * methods, +alloc and -init. For our specific constructors * we can make these from these methods we have * inherited. */@end @implementation Point- (Point *) setFirstCoord: (double) new_val{ x = new_val;}- (Point *) setSecondCoord: (double) new_val{ y = new_val;}+ (Point *) newWithX: (double) x_val andY: (double) y_val{ //Concisely written class method to automatically allocate and //perform specific initialization. return [[[Point alloc] setFirstCoord:x_val] setSecondCoord:y_val]; }+ (Point *) newWithR: (double) r_val andTheta: (double) theta_val{ //Instead of performing the same as the above, we can underhandedly //use the same result of the previous method return [Point newWithX:r_val andY:theta_val];}@endintmain(void){ //Constructs two points, p and q. Point *p = [Point newWithX:4.0 andY:5.0]; Point *q = [Point newWithR:1.0 andTheta:2.28]; //...program text.... //We're finished with p, say, so, free it. //If p allocates more memory for itself, may need to //override Object's free method in order to recursively //free p's memory. But this is not the case, so we can just [p free]; //...more text... [q free]; return 0;}Object Pascal
program Example;type DimensionEnum = ( deUnassigned, de2D, de3D, de4D); PointClass = class private Dimension: DimensionEnum; public X: Integer; Y: Integer; Z: Integer; T: Integer; public (* prototype of constructors *) constructor Create(); constructor Create(AX, AY: Integer); constructor Create(AX, AY, AZ: Integer); constructor Create(AX, AY, AZ, ATime: Integer); constructor CreateCopy(APoint: PointClass); (* prototype of destructors *) destructor Destroy; end;constructor PointClass.Create();begin // implementation of a generic, non argument constructor Self.Dimension:= deUnassigned;end;constructor PointClass.Create(AX, AY: Integer);begin // implementation of a, 2 argument constructor Self.X:= AX; Y:= AY; Self.Dimension:= de2D;end;constructor PointClass.Create(AX, AY, AZ: Integer);begin // implementation of a, 3 argument constructor Self.X:= AX; Y:= AY; Self.X:= AZ; Self.Dimension:= de3D;end;constructor PointClass.Create(AX, AY, AZ, ATime: Integer);begin // implementation of a, 4 argument constructor Self.X:= AX; Y:= AY; Self.X:= AZ; T:= ATime; Self.Dimension:= de4D;end;constructor PointClass.CreateCopy(APoint: PointClass);begin // implementation of a, "copy" constructor APoint.X:= AX; APoint.Y:= AY; APoint.X:= AZ; APoint.T:= ATime; Self.Dimension:= de4D;end;destructor PointClass.PointClass.Destroy;begin // implementation of a generic, non argument destructor Self.Dimension:= deUnAssigned;end;var (* variable for static allocation *) S: PointClass; (* variable for dynamic allocation *) D: ^PointClass;begin (* of program *) (* object lifeline with static allocation *) S.Create(5, 7); (* do something with "S" *) S.Destroy; (* object lifeline with dynamic allocation *) D = new PointClass, Create(5, 7); (* do something with "D" *) dispose D, Destroy;end. (* of program *)Python
class Socket: def __init__(self, remote_host): self.connection = connectTo(remote_host) def send(self): # send data def recv(self): # receive data;def f(): s = Socket('example.com') s.send('test') return s.recv()Ghi chú
Tham khảo
🔥 Top keywords: Đài Truyền hình Kỹ thuật số VTCTrang ChínhGiỗ Tổ Hùng VươngTrương Mỹ LanĐặc biệt:Tìm kiếmHùng VươngVương Đình HuệUEFA Champions LeagueKuwaitChiến dịch Điện Biên PhủFacebookĐài Truyền hình Việt NamTrần Cẩm TúĐội tuyển bóng đá quốc gia KuwaitGoogle DịchViệt NamCúp bóng đá U-23 châu ÁCúp bóng đá U-23 châu Á 2024Real Madrid CFBảng xếp hạng bóng đá nam FIFACleopatra VIITô LâmTim CookNguyễn Phú TrọngHồ Chí MinhHai Bà TrưngManchester City F.C.VnExpressChủ tịch nước Cộng hòa xã hội chủ nghĩa Việt NamNguyễn Ngọc ThắngĐền HùngCúp bóng đá trong nhà châu Á 2024Võ Văn ThưởngOne PieceLịch sử Việt NamCuộc đua xe đạp toàn quốc tranh Cúp truyền hình Thành phố Hồ Chí Minh 2024Phạm Minh ChínhTikTokĐinh Tiên Hoàng