Call an object method: Difference between revisions

[[Category:Object oriented]]

[[Category:Encyclopedia]]

 

In [[object-oriented programming]] a method is a function associated with a particular class or object. In most forms of object oriented implementations methods can be static, associated with the class itself; or instance, associated with an instance of a class.

 

Show how to call a static or class method, and an instance method of a class.

=={{header|ActionScript}}==

MyClass.method(someParameter);

 

// Instance

myInstance.method(someParameter);</syntaxhighlight>

=={{header|Ada}}==

Ada is a language based on strict typing. Nevertheless, since Ada 95 (the first major revision of the language), Ada also includes the concepts of a class. Types may be tagged, and for each tagged type T there is an associated type T'Class. If you define a method as "procedure Primitive(Self: T)", the actual parameter Self must be of type T, exactly, and the method Primitive will be called, well, statically. This may be surprising, if you are used to other object-oriented languages.

 

Specify the class My_Class, with one primitive subprogram, one dynamic subprogram and a static subprogram:

type Object is tagged private;

procedure Primitive(Self: Object); -- primitive subprogram

 

Implement the package:

procedure Primitive(Self: Object) is

begin

 

Specify and implement a subclass of My_Class:

type Object is new My_Class.Object with null record;

overriding procedure Primitive(Self: Object);

The main program, making the dynamic and static calls:

 

 

procedure Call_Method is

Hi there! ... Hello World!

Hi there! ... Hello Universe!</pre>

 

=={{header|Apex}}==

MyClass.method(someParameter);

 

{{works with|AutoHotkey_L}}

(AutoHotkey Basic does not have classes)

{

Method(someParameter){

myInstance := new myClass

myInstance.Method("bye")</syntaxhighlight>

=={{header|Bracmat}}==

Bracmat has no classes. Rather, objects can be created as copies of other objects. In the example below, the variable <code>MyObject</code> has a copy of variable <code>MyClass</code> as value. Notice the extra level of reference in <code>(MyObject..Method)$argument</code>, comparable to <code>MyObject->Method(argument)</code> in C. Rather than being the object itself, <code>MyObject</code> points to an object and can be aliased by assigning to another variable.

 

Inside an object, the object is represented by <code>its</code>, comparable to <code>this</code> in other languages.

= (name=aClass)

( Method

Output from object1: Example of calling an instance method

Output from object1: Example of calling an instance method from an alias</pre>

 

=={{header|C}}==

C has structures and it also has function pointers, which allows C structures to be associated with any function with the same signature as the pointer. Thus, C structures can also have object methods.

#include<stdlib.h>

#include<stdio.h>

Factorial of 10 is 3628800

</pre>

=={{header|C++}}==

MyClass::method(someParameter);

 

MyPointer->method(someParameter);

</syntaxhighlight>

=={{header|C_sharp|C#}}==

MyClass.Method(someParameter);

// Instance

myInstance.Method(someParameter);</syntaxhighlight>

=={{header|ChucK}}==

MyClass myClassObject;

myClassObject.myFunction(some parameter);

</syntaxhighlight>

=={{header|Clojure}}==

(System/currentTimeMillis)

 

(.equals 1 2) ; use dot operator to call instance methods

(. 1 (equals 2)) ; alternative style</syntaxhighlight>

=={{header|COBOL}}==

 

 

To call factory methods of objects of an unknown type (such as when you may have a subclass of the class wanted), it is necessary to get a reference to the class's factory object by calling the <code>"FactoryObject"</code> method.

*> foo-factory can be treated like a normal object reference.

INVOKE foo-factory "someMethod"</syntaxhighlight>

=={{header|CoffeeScript}}==

While CoffeeScript does provide a useful class abstraction around its prototype-based inheritance, there aren't any actual classes.

@staticMethod: -> 'Bar'

 

foo.instanceMethod() #=> 'Baz'

Foo.staticMethod() #=> 'Bar'</syntaxhighlight>

 

=={{header|Common Lisp}}==

In Common Lisp, classmethods are methods that apply to classes, rather than classes that contain methods.

((x

:accessor get-x ;; getter function

Value of x^2: 100

</pre>

 

=={{header|D}}==

static int staticMethod() {

return 2;

assert(d.dynamicMethod() == "Woof!");

}</syntaxhighlight>

 

=={{header|Dragon}}==

Making an object of class and then calling it.

r.val()</syntaxhighlight>

=={{header|Dyalect}}==

 

Dyalect supports both instance and static methods. Instance methods have a special <code>this</code> reference that returns an instance. Static method are always invoked through the type name.

 

static func Integer.Div(x, y) {

x / y

<pre>4

4</pre>

=={{header|E}}==

{{improve|E|Add runnable example.}}

A method call in E has the syntax <code><var>recipient</var>.<var>verb</var>(<var>arg1</var>, <var>arg2</var>, <var>...</var>)</code>, where <var>recipient</var> is an expression, <var>verb</var> is an identifier (or a string literal preceded by <code>::</code>), and <var>argN</var> are expressions.

 

 

In E, there are no distinguished "static methods". Instead, it is idiomatic to place methods on the maker of the object. This is very similar to methods on constructors in JavaScript, or class methods in Objective-C.

 

=={{header|Elena}}==

The message call:

console.printLine("Hello"," ","World!");

</syntaxhighlight>

=={{header|Elixir}}==

Elixir doesn't do objects. Instead of calling methods on object you send messages to processes. Here's an example of a process created with spawn_link which knows how to receive a message "concat" and return a result.

defmodule ObjectCall do

def new() do

IO.puts(obj |> ObjectCall.concat("Hello ", "World!"))

</syntaxhighlight>

 

=={{header|Factor}}==

In Factor, there is no distinction between instance and static methods. Methods are contained in generic words and specialize on a class. Generic words define a <i>method combination</i> so methods know which object(s) to dispatch on. (But most methods dispatch on the object at the top of the data stack.) Under this object model, calling a method is no different than calling any other word.

 

IN: rosetta-code.call-a-method

 

I don't know how to speak!

</pre>

=={{header|Forth}}==

{{works with|4tH|3.62.0}}

{{trans|D}}

There are numerous, mutually incompatible object oriented frameworks for Forth. This one works with the FOOS preprocessor extension of [[4tH]].

include 4pp/lib/foos.4pp

 

Needs the FMS-SI (single inheritance) library code located here:

http://soton.mpeforth.com/flag/fms/index.html

 

:class animal

Sparky speak \ => woof ok

</syntaxhighlight>

=={{header|Fortran}}==

In modern Fortran a "derived type" concept corresponds to "class" in OOP. Such types have "type bound procedures", i.e. static methods. Procedure pointer components depend on the value of the object (so they are object-bound), can be redefined runtime and correspond approx to instances.

! type declaration

type my_type

 

</syntaxhighlight>

=={{header|FreeBASIC}}==

' FB 1.05.0 Win64

 

Hello world!

Hello static world!

</pre>

 

=={{header|Go}}==

Go distances itself from the word "object" and from many object oriented concepts. It does however have methods. Any user-defined type in Go can have methods and these work very much like "instance methods" of object oriented languages. The examples below illustrate details of Go methods and thus represent the concept of instance methods.

 

// method on the type itself; can be called on that type or its pointer

 

An example package:

 

import "sync/atomic"

}</syntaxhighlight>

Example use:

 

import "box"

 

Unicon has no concept of static methods; all methods are normally invoked using an instance of a class. While it is technically possible to call a method without an instance, it requires knowledge of the underlying implementation, such as the name-mangling conventions, and is non-standard.

 

bar := foo() # create instance

L := [cp1]

end</syntaxhighlight>

=={{header|Haskell}}==

 

 

Dummy example:

 

-- smart constructor

*Main> show o2

Obj 5</pre>

=={{header|J}}==

 

Static:

 

 

and, given an object instance reference:

 

 

an instance invocation could be:

 

 

Note that J also supports infix notation when using methods. In this case, there will be a second parameter list, on the left of the method reference.

 

or

 

These variations might be useful when building combining words that need to refer to two different kinds of things. But mostly it's to be consistent with the rest of the language.

Finally, note that static methods can be referred to using the same notation as instance methods -- in this case you must have a reference to the class name:

 

methodName__classReference parameters</syntaxhighlight>

 

You can also refer to a dynamic method in the same fashion that you use to refer to a instance method -- in this case you must know the object name (which is a number). For example, to refer to a method on object 123

 

 

This last case can be useful when debugging.

=={{header|Java}}==

Static methods in Java are usually called by using the dot operator on a class name:

Instance methods are called by using the dot operator on an instance:

varName.methodName(argument1, argument2);

//or

 

This means that there is no benefit to making a static method call this way, because one can make the call based on the static type that is already known from looking at the code when it is written. Furthermore, such a call may lead to serious pitfalls, leading one to believe that changing the object that it is called on could change the behavior. For example, a common snippet to sleep the thread for 1 second is the following: <code>Thread.currentThread().sleep(1000);</code>. However, since <code>.sleep()</code> is actually a static method, the compiler replaces it with <code>Thread.sleep(1000);</code> (since <code>Thread.currentThread()</code> has a return type of <code>Thread</code>). This makes it clear that the thread that is put to sleep is not under the user's control. However, written as <code>Thread.currentThread().sleep(1000);</code>, it may lead one to falsely believe it to be possible to sleep another thread by doing <code>someOtherThread.sleep(1000);</code> when in fact such a statement would also sleep the current thread.

=={{header|JavaScript}}==

If you have a object called <tt>x</tt> and a method called <tt>y</tt> then you can write:

=={{header|Julia}}==

module Animal

#

masskg(x) = x.weight

=={{header|Kotlin}}==

fun instanceMethod(s: String) = println(s)

 

}

 

val mc = MyClass()

mc.instanceMethod("Hello instance world!")

 

In Latitude, everything is an object. Being prototype-oriented, Latitude does not distinguish between classes and instances. Calling a method on either a class or an instance is done by simple juxtaposition.

MyClass someMethod (arg1, arg2, arg3).</syntaxhighlight>

The parentheses on the argument list may be omitted if there is at most one argument and the parse is unambiguous.

myObject someMethod (argument). ;; Parentheses are necessary here

myObject someMethod. ;; No arguments</syntaxhighlight>

Finally, a colon may be used instead of parentheses, in which case the rest of the line is considered to be the argument list.

=={{header|LFE}}==

 

 

===With Closures===

(export all))

 

 

With this done, one can create objects and interact with them. Here is some usage from the LFE REPL:

 

> (slurp '"object.lfe")

 

===With Lightweight Processes===

(export all))

 

 

Here is some usage from the LFE REPL:

 

> (slurp '"object.lfe")

"3e64e5c20fb742dd88dac1032749c2fd"]

ok</syntaxhighlight>

=={{header|Lingo}}==

script("MyClass").foo()

 

obj = script("MyClass").new()

obj.foo()</syntaxhighlight>

=={{header|Logtalk}}==

In Logtalk, class or instance are ''roles'' that an object can play depending on the relations in other objects. Thus, a "class" can be defined by having an object specializing another object and an instance can be defined by having an object instantiating another object. Metaclasses are easily defined and thus a class method is just an instance method defined in the class metaclass.

% avoid infinite metaclass regression by

% making the metaclass an instance of itself

:- end_object.

</syntaxhighlight>

:- object(class,

instantiates(metaclass)).

:- end_object.

</syntaxhighlight>

:- object(instance,

instantiates(class)).

</syntaxhighlight>

Testing:

| ?- class::me(Me).

Me = class

yes

</syntaxhighlight>

=={{header|Lua}}==

Lua does not provide a specific OO implementation, but its metatable mechanism and sugar for method-like calls does make it easy to implement and use such as system, as evidenced by its multitude of class libraries in particular.

 

Instance methods, in their most basic form, are simply function calls where the calling object reference is duplicated and passed as the first argument. Lua offers some syntactical sugar to facilitate this, via the colon operator:

 

object:func() -- with : sugar

 

Using metatables, and specifically the __index metamethod, it is possible to call a method stored in an entirely different table, while still passing the object used for the actual call:

function methods:func () -- if a function is declared using :, it is given an implicit 'self' parameter

print(self.name)

 

Example module, named <code>box.lua</code>:

local box = { }

local boxmt = { __index = box }

 

Example use:

 

local b = box.new()

print(b:tellSecret())

print(box.count())</syntaxhighlight>

=={{header|M2000 Interpreter}}==

Module CheckIt {

\\ A class definition is a function which return a Group

=={{header|Maple}}==

There is no real difference in how you call a static or instance method.

Method( obj, other, arg );</syntaxhighlight>

Method( obj, other, arg );</syntaxhighlight>

=={{header|MiniScript}}==

MiniScript uses prototype-based inheritance, so the only difference between a static method and an instance method is in whether it uses the <code>self</code> pseudo-keyword.

Dog.name = ""

Dog.help = function()

<pre>This class represents dogs.

Fido says Woof!</pre>

=={{header|Nanoquery}}==

declare static id = 5

declare MyName

<pre>5

test</pre>

=={{header|Nemerle}}==

MyClass.Method(someParameter);

// Instance

myInstance.Method(someParameter);</syntaxhighlight>

=={{header|NetRexx}}==

Like [[#Java|Java]], static methods in NetRexx are called by using the dot operator on a class name:

Instance methods are called by using the dot operator on an instance:

objectInstance.instanceMethod() -- call the instance method

 

SomeClass().instanceMethod() -- same as above; create a new instance of the class and call the instance method immediately</syntaxhighlight>

=={{header|Nim}}==

In Nim there are no object methods, but regular procedures can be called with method call syntax:

add(x, 4)

x.add(5)</syntaxhighlight>

=={{header|OASYS Assembler}}==

The OASYS runtime is strange; all classes share the same methods and properties, there are no static methods and properties, and there are no procedures/functions other than methods on objects. However, the initialization method can be called on a null object (no other method has this possibility).

 

The following code calls a method called <tt>&amp;GO</tt> on the current object:

=={{header|Objeck}}==

ClassName->some_function(); # call class function

instance->some_method(); # call instance method</syntaxhighlight>

Objeck uses the same syntax for instance and class method calls. In Objeck, functions are the equivalent of public static methods.

=={{header|Object Pascal}}==

 

Object Pascal as implemented in Delphi and Free Pascal supports both static (known in Pascal as class method) and instance methods. Free Pascal has two levels of static methods, one using the class keyword and one using both the class and the static keywords. A class method can be called in Pascal, while a static class method could be called even from C, that's the main difference.

 

MyClass.method(someParameter);

 

myInstance.method(someParameter);

</syntaxhighlight>

=={{header|Objective-C}}==

In Objective-C, calling an instance method is sending a message to an instance, and calling a class method is sending a message to a class object. Class methods are inherited through inheritance of classes. All messages (whether sent to a normal object or class object) are resolved dynamically at runtime, hence there are no "static" methods (see also: Smalltalk).

[MyClass method:someParameter];

// or equivalently:

// Method with no arguments

[myInstance method];</syntaxhighlight>

=={{header|OCaml}}==

 

We can only call the method of an instantiated object:

 

=={{header|Oforth}}==

When a method is called, the top of the stack is used as the object on which the method will be applyed :

 

For class methods, the top of the stack must be a class (which is also an object of Class class) :

=={{header|ooRexx}}==

c=.circle~new(1)

say "c~area:" c~area

c~area: 3.14159265

10 circles were created</pre>

=={{header|Perl}}==

MyClass->classMethod($someParameter);

# Equivalently using a class name

MyClass::classMethod('MyClass', $someParameter);

MyClass::method($myInstance, $someParameter);</syntaxhighlight>

=={{header|Phix}}==

{{libheader|Phix/Class}}

Phix does not demand that all routines be inside classes; traditional standalone routines are "static" in every sense.<br>

There is no way to call a class method without an instance, since "this" will typecheck even if not otherwise used.

<span style="color: #008080;">without</span> <span style="color: #008080;">js</span> <span style="color: #000080;font-style:italic;">-- (no class in p2js)</span>

<span style="color: #008080;">class</span> <span style="color: #000000;">test</span>

<span style="color: #000000;">t</span><span style="color: #0000FF;">.</span><span style="color: #000000;">inst</span><span style="color: #0000FF;">()</span> <span style="color: #000080;font-style:italic;">-- prints "this is a test"</span>

<!--</syntaxhighlight>-->

=={{header|PHP}}==

MyClass::method($someParameter);

// In PHP 5.3+, static method can be called on a string of the class name

// Instance method

$myInstance->method($someParameter);</syntaxhighlight>

=={{header|PicoLisp}}==

Method invocation is syntactically equivalent to normal function calls. Method names have a trailing '>' by convention.

(foo> MyObject)</syntaxhighlight>

=={{header|Pike}}==

Pike does not have static methods. (the <code>static</code> modifier in Pike is similar to <code>protected</code> in C++).

 

regular methods can be called in these ways:

obj["method"]();

call_function(obj->method);

 

because <code>()</code> is actually an operator that is applied to a function reference, the following is also possible:

func();</syntaxhighlight>

as alternative to static function, modules are used. a module is essentially a static class. a function in a module can be called like this:

module["func"]();</syntaxhighlight>

it should be noted that <code>module.func</code> is resolved at compile time while <code>module["func"]</code> is resolved at runtime.

=={{header|PL/SQL}}==

-- A class needs at least one member even though we don't use it

dummy NUMBER,

DBMS_OUTPUT.put_line( myInstance.instance_method() );

END;/</syntaxhighlight>

=={{header|PowerShell}}==

$Date.AddDays( 1 )

[System.Math]::Sqrt( 2 )</syntaxhighlight>

=={{header|Processing}}==

class HelloWorld

{

// and call the instance method

hello.sayGoodbye();</syntaxhighlight>

=={{header|Python}}==

@classmethod

def myClassMethod(self, x):

myInstance.myClassMethod(someParameter)

myInstance.myStaticMethod(someParameter)</syntaxhighlight>

=={{header|Quackery}}==

 

(It would be possible to extend this technique to a more fully-fledged object oriented system. See Dick Pountain's slim volume "Object Oriented FORTH: Implementation of Data Structures" (pub. 1987) for an example of doing so in Forth; a language to which Quackery is related, but slightly less amenable to such shenanigans.)

 

[ immovable

Resetting mycounter.

Current value of mycounter: 0</pre>

=={{header|Racket}}==

 

The following snippet shows a call to the <tt>start</tt> method of the <tt>timer%</tt> class.

 

 

(define timer (new timer%))

(send timer start 100)</syntaxhighlight>

=={{header|Raku}}==

(formerly Perl 6)

{{works with|Rakudo|2015.12}}

=== Basic method calls ===

method regular-example() { say 'I haz a method' }

 

The <code>.</code> operator can be decorated with meta-operators.

 

my @array = <a z c d y>;

@array .= sort; # short for @array = @array.sort;

A method that is not in a class can be called by using the <code>&</code> sigil explicitly.

 

my $object = "a string"; # Everything is an object.

my method example-method {

say $object.&example-method; # Outputs "This is a string."

</syntaxhighlight>

=={{header|Ring}}==

new point { print() }

Class Point

func print see x + nl + y + nl + z + nl

</syntaxhighlight>

o1 = new System.output.console

o1.print("Hello World")

see cText + nl

</syntaxhighlight>

=={{header|Ruby}}==

MyClass.some_method(some_parameter)

 

# Calling a method with no parameters

my_instance.another_method</syntaxhighlight>

=={{header|Rust}}==

 

impl Foo {

println!("The answer to life is still {}." lots_of_references.get_the_answer_to_life());

}</syntaxhighlight>

=={{header|Scala}}==

* creates "val variable1: Int" with that value.

*/

println("Successfully completed without error.")

}</syntaxhighlight>

=={{header|Sidef}}==

method foo(arg) { say arg }

}

# Alternatively, by asking for a method

instance.method(:foo)(arg);</syntaxhighlight>

=={{header|Smalltalk}}==

In Smalltalk, calling an instance method is sending a message to an instance, and calling a class method is sending a message to a class object. Class methods are inherited through inheritance of classes. All messages (whether sent to a normal object or class object) are resolved dynamically at runtime, hence strictly speaking, there are no "static" methods. Often in literature, Smalltalk's class messages are described as synonymous to static function calls. This is wrong, because class methods can be overwritten in subclasses just as any other message.

Classes are first class objects, meaning that references to them can be passed as argument, stored in other objects or returned as the result of a message send. This makes some of the common design patterns which deal with creation of objects trivial or even superfluous. (see also: ObjectiveC)

 

MyClass selector: someArgument .

" or equivalently "

 

Example for dynamic class determination:

 

Message names (selectors) can be chosen or constructed dynamically at runtime. For example:

foo perform: whichMessage</syntaxhighlight>

 

or:

 

foo perform: theMessage.</syntaxhighlight>

This is often sometimes used as a dispatch mechanism (also, to implement state machines, for example).

 

Of course, especially with all that dynamics, a selector for an unimplemented message might be encountered. This raises a MessageNotUnderstood exception (runtime exception).

foo perform: theMessage

] on: MessageNotUnderstood do:[

Dialog information: 'sorry'

]</syntaxhighlight>

=={{header|SuperCollider}}==

In SuperCollider, classes are objects. To call a class or object method, a message is passed to the class or the object instance. In the implementation, class method names are prefixed with an asterix, all other methods are instance methods.

SomeClass {

a.someInstanceMethod;

</syntaxhighlight>

=={{header|Swift}}==

In Swift, instance methods can be declared on structs, enums, and classes. "Type methods", which include static methods for structs and enums, and class methods for classes, can be called on the type. Class methods are inherited through inheritance of classes, and are resolved dynamically at runtime like instance methods. (see also: Smalltalk).

MyClass.method(someParameter)

// or equivalently:

// Method with multiple arguments

myInstance.method(red:arg1, green:arg2, blue:arg3)</syntaxhighlight>

=={{header|Tcl}}==

# "Static" (on class object)

MyClass mthd someParameter

# Instance

$myInstance mthd someParameter</syntaxhighlight>

 

=={{header|Ursa}}==

decl file f

 

=={{header|VBA}}==

First we have to create a class module named "myObject" :

Option Explicit

 

End Sub</syntaxhighlight>

In a "standard" Module, the call should be :

 

Sub test()

 

What is your name ?</pre>

 

=={{header|Wren}}==

Note that it's possible in Wren for instance and static methods in the same class to share the same name. This is because static methods are considered to belong to a separate meta-class.

construct new() {}

method() { System.print("instance method called") }

You can call object methods using two types of structures. Classes and Objects.

===Classes===

construct=func(self,Props){

self:Props=Props;

</pre>

===Objects===

a=10;

AddA=func(self,x){

12

</pre>

=={{header|XLISP}}==

Class methods and instance methods are defined using <tt>DEFINE-CLASS-METHOD</tt> and <tt>DEFINE-METHOD</tt> respectively. They are called by sending a message to the class or to an instance of it: the message consists of (<i>a</i>) the name of the object that will receive it, which may be a class; (<i>b</i>) the name of the method, as a quoted symbol; and (<i>c</i>) the parameters if any.

 

(DEFINE-CLASS-METHOD (MY-CLASS 'DO-SOMETHING-WITH SOME-PARAMETER)

I am an instance of the class -- #<Object:MY-CLASS #x39979d0>

You sent me the parameter BAR</pre>

=={{header|Zig}}==

Zig does not have classes nor objects. Zig's structs, however, can have methods; but they are not special. They are only namespaced functions that can be called with dot syntax.

 

 

pub const ID = struct {

};

 

}</syntaxhighlight>

 

=={{header|zkl}}==

In zkl, a class can be static (there will only exist one instance of the class). A function is always a member of some class but will only be static if it does not refer to instance data.

C.f() // call function f in class C

C.v=5; c2:=C(); // create new instance of C

{{omit from|360 Assembly}}

{{omit from|6502 Assembly}}

{{omit from|8051 Assembly}}

{{omit from|8080 Assembly}}

{{omit from|8086 Assembly}}

{{omit from|AArch64 Assembly}}

{{omit from|ARM Assembly}}

{{omit from|Octave}}

{{omit from|PARI/GP}}

{{omit from|Retro}}

{{omit from|REXX|not OO}}