- Method (computer science)
object-oriented programming, the term method refers to a subroutinethat is exclusively associated either with a class (called class methods, static methods, or factory methods) or with an object (called instance methods). Like a procedure in procedural programming languages, a method usually consists of a sequence of statements to perform an action, a set of input parameters to customize those actions, and possibly an output value (called return value) of some kind. Methods can provide a mechanism for accessing (for both reading and writing) the encapsulated data stored in an object or a class.
Kinds of methods
As stated above, instance methods are associated with a particular object, while class or static methods are instead associated with a class. In all typical implementations, instance methods are passed a hidden
Me) to the object (whether a class or class instance) they belong to, so that they can access the data associated with it. For class/static methods this may or may not happen according to the language; A typical example of a class method would be one that keeps count of the number of created objects within a given class.
An abstract method is a
dummy codemethod which has no implementation. It is often used as a placeholder to be overridden later by a subclass of or an object prototyped from the one that implements the abstract method. In this way, abstract methods help to partially specify a framework.
An accessor method is a method that is usually small, simple and provides the means for the
stateof an object to be accessed from other parts of a program. Although it introduces a new dependency, use of the methods are preferred to directly accessing state data because they provide an abstraction layer. For example, if a bank-account class provides a
getBalance()accessor method to retrieve the current
balance(rather than directly accessing the balance data fields), then later revisions of the same code can implement a more complex mechanism balance retrieval (say, a databasefetch) without the dependent code needing to be changed. A method that changes the state of an object is no longer called an accessor method, but rather an update method, a modifier method, or a mutator method. Objects that provide such methods are considered mutable objects.
Many languages support methods that are called automatically upon the creation of an instance of a class, known as a Constructors. Some languages have a special syntax for constructors. In Java,
C++, C#, ActionScript, and PHPthey have the same name as the class of which they are a member (PHP 5 also allows
__constructas a constructor); in
Visual Basic .NETthe constructor is called
Object Pascalconstructors are signified by the keyword
constructorand can have user-defined names (but are mostly called
Objective-Cthe constructor method is split between two methods,
init, with the
allocmethod setting aside memory for an instance of the class and the
initmethod handling the bulk of initializing the instance; a call to the
newmethod invokes both the
initmethod for the class instance.
Likewise, some languages have special Destructor methods, i.e. instance methods that are called automatically upon the destruction of an instance of a class. In C++, they are distinguished by having the same name as the class of the object they're associated with, but with the addition of a
tilde(~) in front (or
__destructin PHP 5). In
Object Pascaldestructors have the keyword
destructorand can have user-defined names (but are mostly called Destroy). Under
Objective-Cthe destructor method is named
The difference is the required level of isolation. In C, the
stackPushprocedure could be in the same source file as the rest of the program and if it was, any other pieces of the program in that source file could see and modify all of the low level details of how the stack was implemented, completely bypassing the intended interface. In C++, regardless of where the class is placed, only the methods which are part of
myStackwill be able to get access to those low-level details without going through the formal interface methods. Languages such as C can provide comparable levels of protection by using different
source files and not providing external linkageto the private parts of the stack implementation but this is less neat and systematic than the more cohesive and enforced isolation of the java approach.
Some recommended usages
A public method should preserve the
class invariants of the object it is associated with, and should always assume that they are valid when it commences execution (private methods do not necessarily need to follow this recommendation). To this effect, preconditions are used to constrain the method's parameters, and postconditions to constrain method's output, if it has one. If any one of either the preconditions or postconditions is not met, a method may raise an exception. If the object's state does not satisfy its class invariants on entry to or exit from any method, the program is considered to have a bug.
The difference between a procedure and a method is that the latter, being associated with a particular object, may access or modify the data private to that object in a way "consistent with the intended behavior of the object". Consequently, rather than thinking "a method is just a sequence of commands", a programmer using an object-oriented language will consider a method to be "an object's way of providing a service" (its "method of doing the job", hence the name); a method call is thus considered to be a "request" to an object to perform some
Consequently, method calls are often modeled as a means of passing a message to an object. Rather than directly performing an operation on an object, a message (most of the time accompanied by parameters) is sent to the object telling it what it should do. The object either complies or raises an exception describing why it cannot do so. Applied to our stack example, rather than pushing a value onto the stack, a value is sent to the stack, along with the message "push".
As mentioned above, a method may be declared as static (or
Visual Basic .NET), meaning that it acts at the class level rather than at the instance level. Therefore, a static method cannot refer to a specific instance of the class (i.e. it cannot refer to
Me, etc.), unless such references are made through a parameter referencing an instance of the class, although in such cases they must be accessed through the parameter's identifier instead of
this. An example of a static member and its consumption in C# code:
Confusingly, methods marked as
classin Object Pascal also cannot refer to a class object, as can class methods in Python or Smalltalk. For example, this Python method can create an instance of
Dictor of any subclass of it, because it receives a reference to a "class object" as
Wikimedia Foundation. 2010.