Vòng đời đối tượng

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