Property (programming):

In some object-oriented programming languages, a property is a special sort of class member, intermediate between a field (or data member) and a method. You read and write a property just as you read and write a field, but this is (usually) translated to get and set method calls. The field-like syntax is easier to read and write than lots of method calls, yet the interposition of method calls allows for data validation, active updating (as of GUI visuals), and/or read-only 'fields'. That is, properties are intermediate between member code (methods) and member data (instance variables) of the class, and properties provide a higher level of encapsulation than public fields.

Support in languages

In most languages, properties are implemented as a pair of accessor/mutator methods, but accessed using the same syntax as for public fields. Omitting a method from the pair yields a read-only or write-only property, the latter being rather uncommon.

In some languages with no built-in support for properties, a similar construct can be implemented as a single method that either returns or changes the underlying data, depending on the context of its invocation. Such techniques are used e.g. in Perl.

Example syntax

Delphi/Free Pascal

type TPen = class
  private
    m_Color: Integer;
    function Get_Color: Integer;
    procedure Set_Color(RHS: Integer);
  public
    property Color: Integer read Get_Color write Set_Color;
end;
 
function TPen.Get_Color: Integer;
begin
  Result := m_Color
end;
 
procedure TPen.Set_Color(RHS: Integer);
begin
  m_Color := RHS
end;

// accessing:
var pen: TPen;
// ...
pen.Color := not pen.Color;
 
(*
Delphi also supports a 'direct field' syntax -
 
property Color: 'Integer read m_Color write Set_Color;
 
or
 
property Color: Integer read Get_Color write m_Color;
 
where the compiler generates the exact same code as for reading and writing
a field. This offers the efficiency of a field, with the safety of a property.
(You can't get a pointer to the property, and you can always replace the member
access with a method call.)
*)

Visual Basic 6

' in a class named clsPen
Private m_Color As Long
 
Public Property Get Color() As Long
    Color = m_Color
End Property
 
Public Property Let Color(ByVal RHS As Long)
    m_Color = RHS
End Property

' accessing:
Dim pen As New clsPen
' ...
pen.Color = Not pen.Color

Visual Basic

Public Class Pen
 
    Private m_Color as Integer ' Private field
 
    Public Property Color as Integer ' Public property
        Get
            Return m_Color
        End Get
        Set(ByVal Value as Integer)
            m_Color = Value
        End Set
    End Property
 
End Class

' accessing:
Dim pen As New Pen()
' ...
pen.Color = Not pen.Color

class Pen
{
    private int m_Color; // private field
 
    public int Color   // public property
    {
        get
        {
            return m_Color;
        }
        set 
        {
            m_Color = value;
        }
    }
}

// accessing:
Pen pen = new Pen();
// ...
pen.Color = ~pen.Color; // bitwise complement ...
 
// another silly example:
pen.Color += 1; // a lot clearer than "pen.set_Color(pen.get_Color() + 1)"!

class Pen
{
    private int m_color; // private field
 
    // public get property
    public int color () {
        return m_color;
    }
 
    // public set property
    public int color (int value) {
        return m_color = value;
    }
}

auto pen = new Pen;
pen.color = ~pen.color; // bitwise complement
 
// the set property can also be used in expressions, just like regular assignment
int theColor = (pen.color = 0xFF0000);

Python

class Pen(object):
    def __init__(self):
        self.__color = 0 # "private" variable
        self.__writeonly = "You can't read this!"
    def _set_color(self, color):
        self.__color = color
    def _get_color(self):
        return self.__color
    color = property(_get_color, _set_color) # read/write access translates to get/set methods
    def _set_writeonly(self, new_value):
        self.__writeonly = new_value
    writeonly = property(fset = _set_writeonly) # write-only access is provided (reading throws an exception)''

pen = Pen()
# accessing:
pen.color = ~pen.color # bitwise complement ...
 
print pen.writeonly # raise "AttributeError: unreadable attribute"
pen.writeonly = "Something Else" # <code>__writeonly</code> is now "Something Else"
print pen._Pen__writeonly

PHP

class Pen {
    private $_color;
 
    function __set($property, $value) {
        switch ($property) {
            case 'Color': $this->_color = $value; break;
        }
    }
 
    function __get($property) {
        switch ($property) {
            case 'Color': return $this->_color; break;
        }
    }
}

$p = new Pen();
$p->Color = !$p->Color;
echo $p->Color;

Objective C 2.0

 
 @interface Pen : NSObject {
   NSColor *color;
}
@property(copy) NSColor *color;        // color values always copied.
@end
 
@implementation Pen
@synthesize color;                     // synthesize accessor methods.
@end
 
// Example Usage
Pen *pen = [Pen new];
pen.color = [NSColor blackColor];
float red = pen.color.redComponent;
[pen.color drawSwatchInRect:NSMakeRect(0, 0, 100, 100)];

Property (programming)

Contents