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 constructors
public:
 Foo(int x);
 Foo(int x, int y); // Overloaded Constructor
 Foo(const Foo &amp;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 &amp;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.
@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];
@end
int
main(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()
Tham khảo.
[[Thể loại:Đối tượng (khoa học máy tính)]]