Method (computer science)

Used mainly in object-oriented programming, the term method refers to a piece of code that is exclusively associated either with a class (called class methods or static 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 parameterize those actions, and possibly an output value (called return value) of some kind. The purpose of methods is to provide a mechanism for accessing (for both reading and writing) the private data stored in an object or a class.

A 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. 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 (usually miscalled a "function") 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", an OO programmer 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 task. Method calls are often modelled as a means of passing a message to an object. Rather than pushing a value onto the stack, a value is sent to the stack, along with the message "push!", and the stack either complies or raises an exception describing why it can not do so.

Kinds of methods

As stated above, instance methods are associated with a particular object, while class or static methods (also called shared methods) are instead associated with a class. In typical implementations, instance methods are passed a hidden reference (e.g. this or self) to the object (whether a class or class instance) they belong to, so that they can access the data associated with it. A typical example of a class method would be one that keeps count of the number of created objects within a given class.

Constructors, are special instance methods that are called automatically upon the creation of an instance of a class. In Java, C++ and C# they are distinguished by having the same name as the class of the object they're associated with.

An abstract method is a method which has no implementation. It is often used as a place-holder 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 kind of method that is usually small, simple and provides the means for the state of 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 database fetch) without the dependent code needing to be changed. An accessor method that changes the state of an object is often called an update method or, sometimes, mutator method. Objects that provide such methods are considered mutable objects.

Isolation levels

Whereas a C programmer might push a value onto a Stack data-structure by calling:

stackPush(&myStack, value);

a C++ programmer would write:

myStack.push(value);

The difference is the required level of isolation. In C, the stackPush procedure 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 functions which are part of myStack will be able to get access to those low-level details without going through the formal interface functions. Languages such as C can provide comparable levels of protection by using different source files and not providing external linkage to the private parts of the stack implementation but this is less neat and systematic than the more cohesive and enforced isolation of the C++ approach.de:Methode (objektorientierte Programmierung) fr:Méthode (informatique) lt:Metodas (programavimas) pl:Metoda (programowanie obiektowe)