Method (computer programming): Difference between revisions

Revision as of 08:33, 25 December 2018

Latest revision as of 07:31, 11 August 2025

(98 intermediate revisions by 57 users not shown)

Line 1:

{{short description|Function that is tied to a particular instance or class}}

A '''method''' in [[object-oriented programming]] (OOP) is a [[Procedure (computer science)|procedure]] associated with a [[Message passing|message]] and an [[Object (computer science)|object]]. An object is mostly made up of data and behavior, which form the interface that an object presents to the outside world. Data is represented as [[Property (programming)|properties]] of the object and behavior as methods. For example, a <code>Window</code> object would have methods such as <code>open</code> and <code>close</code>, while its state (whether it is opened or closed) would be a property.

A '''method''' in [[object-oriented programming]] (OOP) is a [[Procedure (computer science)|procedure]] associated with an [[Object (computer science)|object]], and generally also a [[Message passing|message]]. An object consists of ''state data'' and ''behavior''; these compose an [[Interface (object-oriented programming)|''interface'']], which specifies how the object may be used. A method is a behavior of an object parametrized by a user.

In [[class-based programming]], methods are defined in a [[class (computer science)|class]], and objects are instances of a given class. One of the most important capabilities that a method provides is method overriding. The same name (e.g., <code>area</code>) can be used for multiple different kinds of classes. This allows the sending objects to invoke behaviors and to delegate the implementation of those behaviors to the receiving object. A method in Java programming sets the behavior of a class object. For example, an object can send an <code>area</code> message to another object and the appropriate formula is invoked whether the receiving object is a <code>rectangle</code>, <code>circle</code>, <code>triangle</code>, etc.

Data is represented as [[Property (programming)|properties]] of the object, and behaviors are represented as methods. For example, a <code>Window</code> object could have methods such as <code>open</code> and <code>close</code>, while its state (whether it is open or closed at any given point in time) would be a property.

Methods also provide the interface that other classes use to access and modify the data [[Property (programming)|properties]] of an object. This is known as encapsulation. Encapsulation and overriding are the two primary distinguishing features between methods and procedure calls.<ref>{{cite web|title=What is an Object?|url=http://docs.oracle.com/javase/tutorial/java/concepts/object.html|work=oracle.com|publisher=Oracle Corporation|accessdate=13 December 2013}}</ref>

In [[class-based programming]], methods are defined within a [[class (computer science)|class]], and objects are [[Instance (computer science)|instances]] of a given class. One of the most important capabilities that a method provides is ''[[method overriding]]'' - the same name (e.g., <code>area</code>) can be used for multiple different kinds of classes. This allows the sending objects to invoke behaviors and to delegate the implementation of those behaviors to the receiving object. A method in [[Java (programming language)|Java]] programming sets the behavior of a class object. For example, an object can send an <code>area</code> message to another object and the appropriate formula is invoked whether the receiving object is a <code>rectangle</code>, <code>circle</code>, <code>triangle</code>, etc.

==Overriding and overloading==

[[Method overriding]] and overloading are two of the most significant ways that a method differs from a conventional procedure or function call. Overriding refers to a subclass redefining the implementation of a method of its superclass. For example, <code>findArea</code> may be a method defined on a shape class. The various subclasses: <code>rectangle</code>, <code>circle</code>, <code>triangle</code>, etc. would each define the appropriate formula to calculate their area. The idea is to look at objects as "black boxes" so that changes to the internals of the object can be made with minimal impact on the other objects that use it. This is known as encapsulation and is meant to make code easier to maintain and re-use.

Methods also provide the interface that other classes use to access and modify the properties of an object; this is known as [[Encapsulation (computer programming)|''encapsulation'']]. Encapsulation and overriding are the two primary distinguishing features between methods and procedure calls.<ref>{{cite web|title=What is an Object?|url=http://docs.oracle.com/javase/tutorial/java/concepts/object.html|work=oracle.com|publisher=Oracle Corporation|access-date=13 December 2013}}</ref>

Method overloading, on the other hand, refers to differentiating the code used to handle a message based on the parameters of the method. If one views the receiving object as the first parameter in any method then overriding is just a special case of overloading where the selection is based only on the first argument.<ref>[http://www.codeproject.com/Articles/16407/METHOD-Overload-Vs-Overriding http://www.codeproject.com/Articles/16407/METHOD-Overload-Vs-Overriding]</ref> The following simple [[Java language|Java]] example illustrates the difference:<ref>{{cite web

| accessdate = 2011-08-12

| author = John Suzuki

| date = 2000-02-18

| ___location = http://www.jguru.com/

| publisher = j Guru

| title = What is an overloaded method?

| quote = Overloaded methods are multiple methods in the same class that shares the same name but have different parameter lists. Overloaded methods cannot have the same parameter lists with different return types.

| url = http://www.jguru.com/faq/view.jsp?EID=15565}}

</ref>

==Overriding and overloading==

<syntaxhighlight lang="java">

[[Method overriding]] and [[Function overloading|overloading]] are two of the most significant ways that a method differs from a conventional procedure or function call. Overriding refers to a subclass redefining the implementation of a method of its superclass. For example, <code>findArea</code> may be a method defined on a shape class,<ref name=":0" /> <code>triangle</code>, etc. would each define the appropriate formula to calculate their area. The idea is to look at objects as "black boxes" so that changes to the internals of the object can be made with minimal impact on the other objects that use it. This is known as encapsulation and is meant to make code easier to maintain and re-use.

public class class1 {

int f(int x) {

return x+3;

}

}

Method overloading, on the other hand, refers to differentiating the code used to handle a message based on the parameters of the method. If one views the receiving object as the first parameter in any method then overriding is just a special case of overloading where the selection is based only on the first argument. The following simple Java example illustrates the difference:

public class class2 extends class1 {

@Override

int f(int x) { // overriding

return x*x;

}

int f(int x, int y) { // overloading

return x*y;

}

}

</syntaxhighlight>

==Accessor, mutator and manager methods==

[[Accessor methodsmethod]]s are used to read the data values of an object. Mutator methods are used to modify the data of an object. Manager methods are used to initialize and destroy objects of a class, e.g. constructors and destructors.

These methods provide an [[abstraction layer]] that facilitates [[Encapsulation (object-oriented programming)|encapsulation]] and [[Modularity (programming)|modularity]]. For example, if a bank-account class provides a <code>getBalance()</code> accessor method to retrieve the current [[Balance (accounting)|balance]] (rather than directly accessing the balance data fields), then later [[revision control|revisions]] of the same code can implement a more complex mechanism for balance retrieval (e.g., a [[database]] fetch), without the dependent code needing to be changed. The concepts of encapsulation and modularity are not unique to object-oriented programming. Indeed, in many ways the object-oriented approach is simply the logical extension of previous paradigms such as [[abstract data types]] and [[structured programming]].<ref>{{cite book|last=Meyer|first=Bertrand|title=Object-Oriented Software Construction|year=1988|publisher=Prentice Hall International Series in Computer Science|___location=Cambridge|isbn=0-13-629049-3|pages=52–54}}</ref>

===Constructors===

{{Main|Constructor (computer science)}}

A [[Constructor (computer science)|''constructor'']] is a method that is called at the beginning of an object's lifetime to create and initialize the object, a process called [[object creation|construction]] (or ''instantiation''). Initialization may include an acquisition of resources. Constructors may have parameters but usually, do not return values in most languages. See the following example in Java:

A [[Constructor (computer science)|''constructor'']] is a method that is called at the beginning of an object's lifetime to create and initialize the object, a process called [[object creation|construction]] (or ''instantiation''). Initialization may include an acquisition of resources. Constructors may have parameters but usually do not return values in most languages. See the following example in Java:

<syntaxhighlight lang="java">

public class Main {

String name_name;

int roll_roll;

Main(String _name, int _roll) { //constructor method

Main(String name, int roll) { // constructor method

this.name = _name;

this.roll_name = _rollname;

this._roll = roll;

}

}

}

</syntaxhighlight>

===DestructorsDestructor===

{{Main|Destructor (computer science)}}

A ''[[Destructor (computer science)|destructor]]'' is a method that is called automatically at the end of an object's lifetime, a process called [[object lifetime|destruction]]. Destruction in most languages does not allow destructor method arguments nor return values. Destruction can be implemented so as to perform cleanup chores and other tasks at object destruction.

A ''[[Destructor (computer science)|Destructor]]'' is a method that is called automatically at the end of an object's lifetime, a process called [[object lifetime|Destruction]]. Destruction in most languages does not allow destructor method arguments nor return values. Destructors can be implemented so as to perform cleanup chores and other tasks at object destruction.

====Finalizers====

In [[Garbage collection (computer science)|garbage-collected]] languages, such as [[Java (programming language)|Java]],<ref name=Bloch>{{cite book | title= "Effective Java: Programming Language Guide" |last=Bloch| first=Joshua| publisher=Addison-Wesley | edition=third | isbn=978-0134685991| year=2018}}</ref>{{rp|26, 29}} [[C Sharp (programming language)|C#]],<ref name=Albahari>{{cite book |last=Albahari |first=Joseph |title= C# 10 in a Nutshell |publisher= O'Reilly |isbn= 978-1-098-12195-2}}</ref>{{rp|208-209}} and [[Python (programming language)|Python]], destructors are known as ''[[finalizer]]s''. They have a similar purpose and function to destructors, but because of the differences between languages that utilize garbage-collection and languages with [[manual memory management]], the sequence in which they are called is different.

==Abstract methods==

An '''abstract method''' is one with only a [[method signature|signature]] and no [[method body|implementation body]]. It is often used to specify that a subclass must provide an implementation of the method, as in an [[Class (computer programming)#Abstract and concrete|abstract class]]. Abstract methods are used to specify [[Interface (computing)|interfaces]] in some computerprogramming languages.<ref>{{cite web|title=Abstract Methods and Classes|url=http://docs.oracle.com/javase/tutorial/java/IandI/abstract.html|website=oracle.com|publisher=Oracle Java Documentation|accessdateaccess-date=11 December 2014}}</ref>

===Example===

[[File:UML abstract methods.svg]]

The following [[Java (programming language)|Java]] code shows an abstract class that needs to be extended:

Line 83 ⟶ 65:

}

}

</syntaxhighlight>

===Reabstraction===

If a subclass provides an implementation for an abstract method, another subclass can make it abstract again. This is called ''reabstraction''.

In practice, this is rarely used.

====Example====

In C#, a virtual method can be overridden with an abstract method. (This also applies to Java, where all non-private methods are virtual.)

<syntaxhighlight lang="csharp">

class IA

{

public virtual void M() { }

}

abstract class IB : IA

{

public override abstract void M(); // allowed

}

</syntaxhighlight>

Interfaces' default methods can also be reabstracted, requiring subclasses to implement them. (This also applies to Java.)

<syntaxhighlight lang="csharp">

interface IA

{

void M() { }

}

interface IB : IA

{

abstract void IA.M();

}

class C : IB { } // error: class 'C' does not implement 'IA.M'.

</syntaxhighlight>

==Class methods==

Class methods are methods that are called on a [[Class (computer programming)|class]] rather than an instance. They are typically used as part of an object [[meta-model]]. I.e, for each class, defined an instance of the class object in the meta-model is created. [[Meta-object protocol|Meta-model protocols]] allow classes to be created and deleted. In this sense, they provide the same functionality as constructors and destructors described above. But in some languages such as the [[Common Lisp Object System|Common Lisp Object System (CLOS)]] the meta-model allows the developer to dynamically alter the [[object model]] at run time: e.g., to create new classes, redefine the class hierarchy, modify properties, etc.

==Special methods==

Special methods are very language-specific and a language may support none, some, or all of the special methods defined here. A language's [[compiler]] may automatically generate default special methods or a programmer may be allowed to optionally define special methods. Most special methods cannot be directly called, but rather the compiler generates code to call them at appropriate times.

===Static methods===

{{see also|Static member function}}

Static methods are meant to be relevant to all the instances of a class rather than to any specific instance. They are similar to static variables in that sense. An example would be a static method to sum the values of all the variables of every instance of a class. For example, if there were a <code>Product</code> class it might have a static method to compute the average price of all products.

Static methods are meant to be relevant to all the instances of a class rather than to any specific instance. They are similar to [[static variable]]s in that sense. An example would be a static method to sum the values of all the variables of every instance of a class. For example, if there were a <code>Product</code> class it might have a static method to compute the average price of all products.

A static method can be invoked even if no instances of the class exist yet. Static methods are called "static" because they are resolved at [[compile time]] based on the class they are called on and not dynamically as in the case with instance methods, which are resolved polymorphically based on the runtime type of the object.

====Examples====

=====In Java=====

In Java, a commonly used static method is:

Math.max(double a, double b)

This static method has no owning object and does not run on an instance. It receives all information from its arguments.<ref name=":0">{{Cite book|title = Clean Code: A Handbook of Agile Software Craftsmanship|last = Martin|first = Robert C.|publisher = Prentice Hall|year = 2009|isbn = 978-0-13-235088-4|___location = |pages = 296|author-link = Robert Cecil Martin}}</ref>

A static method can be invoked even if no instances of the class exist yet. Static methods are called "static" because they are resolved at compile time based on the class they are called on and not dynamically as in the case with instance methods, which are resolved polymorphically based on the runtime type of the object.

===Copy-assignment operators===

Line 104 ⟶ 120:

===Operator methods===

Operator methods [[Operator overloading|define or redefine operator symbols]] and define the operations to be performed with the symbol and the associated method parameters. C++ Exampleexample:

<syntaxhighlight lang="cpp">

#include <string>

class data

{

class Data {

public:

public:

string name;

bool operator<(const Data& data) const { return roll_ < data.roll_; }

int roll;

bool operator <bool operator==(const dataData& pdata) const {

return name_ == data.name_ && roll_ == data.roll_;

{

}

return roll < p.roll;

}

private:

bool operator == (const data& p) const

std::string name_;

{

int roll_;

return (name == p.name) and (roll == p.roll);

}

};

</syntaxhighlight>

Line 133 ⟶ 148:

#include <memory>

class Super {

public:

{

virtual ~Super() = default;

public:

virtual void iAm() { std::cout << "I'm the super class!\n"; }

virtual void IAm() { std::cout << "I'm the super class!\n"; }

};

class Sub : public Super {

public:

{

void IAm() override { std::cout << "I'm the subclass!\n"; }

public:

void iAm() { std::cout << "I'm the subclass!\n"; }

};

int main() {

std::unique_ptr<Super> inst1 = std::make_unique<Super>();

{

std::unique_ptr<Super> inst1(newinst2 Super= std::make_unique<Sub>());

std::unique_ptr<Super> inst2(new Sub());

inst1->iAmIAm(); // callsCalls |Super::iAm()IAm|.

inst2->iAmIAm(); // callsCalls |Sub::iAm()IAm|.

}

</syntaxhighlight>

Line 158 ⟶ 172:

* [[Property (programming)]]

* [[Remote method invocation]]

* [[Subroutine]], also called subprogram, routine, procedure, or function

== Notes ==

Line 165 ⟶ 179:

== References ==

{{refbegin}}

*{{cite book|url=https://books.google.com/books?id=DnsM0WD-6iMC&pg=PA131|title=C++ ANDand OBJECTObject-ORIENTEDoriented PROGRAMMINGProgramming PARADIGMParadigm|last=JANA|first=DEBASISH|date=1 January 2005|publisher=PHI Learning Pvt. Ltd.|isbn=978-81-203-2871-6|ref=harv}}

*{{cite book|url=https://books.google.com/books?id=ZLzt5WtsdzIC&pg=PA50|title=Object-Oriented Programming: Fundamentals And Applications|last=Sengupta|first=Probal|date=1 August 2004|publisher=PHI Learning Pvt. Ltd.|isbn=978-81-203-1258-6|ref=harv}}

*{{cite book|url=https://books.google.com/books?id=Miq73i_J1i4C&pg=PA36|title=Object-oriented Programming: Using C++ for Engineering and Technology|last=Svenk|first=Goran|publisher=Cengage Learning|year=2003|isbn=0-7668-3894-3|ref=harv}}

*{{cite book|url=https://books.google.com/books?id=WCHZAgAAQBAJ&pg=PA74|title=Object Oriented Programming with C++|publisher=Tata McGraw-Hill Education|year=2013|isbn=978-1-259-02993-6|ref=harv|author=Balagurusamy}}

*{{cite book|url=https://books.google.com/books?id=-yhuY0Wg_QcC&pg=PA181|title=A Complete Guide to Programming in C++|last2=Prinz|first2=Peter|publisher=Jones & Bartlett Learning|year=2002|isbn=978-0-7637-1817-6|ref=harv|last1=Kirch-Prinz|first1=Ulla}}

*{{cite book|url=https://books.google.com/books?id=1F6ipojt7DcC&pg=PA79|title=Creating Games in C++: A Step-by-step Guide|last=Conger|first=David|publisher=New Riders|year=2006|isbn=978-0-7357-1434-2|ref=harv}}

*{{cite book|url=https://books.google.com/books?id=fgGLZ7WYxCMC&pg=PA97|title=The Advanced C++ Book|last=Skinner|first=M. T.|publisher=Silicon Press|year=1992|isbn=978-0-929306-10-0|ref=harv}}

*{{cite book|url=https://books.google.com/books?id=NXVkcCjPblcC&pg=PA18|title=Linux Kernel Development|date=1 September 2005|publisher=Pearson Education|isbn=978-81-7758-910-8|ref=harv|author=Love}}

*{{cite book|url=https://books.google.com/books?id=fxUVrhjD4k0C&pg=PA78|title=OBJECT-ORIENTED PROGRAMMING USING C++|last2=JAGADEV|first2=ALOK KUMAR|last3=RATH|first3=AMIYA KUMAR|date=8 May 2007|publisher=PHI Learning Pvt. Ltd.|isbn=978-81-203-3085-6|ref=harv|last1=DEHURI|first1=SATCHIDANANDA}}

{{refend}}