# 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
 
&
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
];


}



@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
()


```