Call an object method: Difference between revisions
m
→{{header|Wren}}: Changed to Wren S/H
(→Anonymous methods: It has a name so it's not anonymous.) |
m (→{{header|Wren}}: Changed to Wren S/H) |
||
| (76 intermediate revisions by 46 users not shown) | |||
Line 1:
[[Category:Object oriented]]
[[Category:Encyclopedia]]
{{task|Basic language learning}}
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);</
=={{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.
Line 22 ⟶ 20:
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
Line 29 ⟶ 27:
private
type Object is tagged null record;
end My_Class;</
Implement the package:
<
procedure Primitive(Self: Object) is
begin
Line 49 ⟶ 47:
Put_Line("Greetings");
end Static;
end My_Class;</
Specify and implement a subclass of My_Class:
<
type Object is new My_Class.Object with null record;
overriding procedure Primitive(Self: Object);
Line 62 ⟶ 60:
Put_Line("Hello Universe!");
end Primitive;
end Other_Class;</
The main program, making the dynamic and static calls:
<
procedure Call_Method is
Line 85 ⟶ 83:
Ob1.Dynamic;
Ob2.Dynamic;
end Call_Method;</
{{out}}
Line 94 ⟶ 92:
Hi there! ... Hello World!
Hi there! ... Hello Universe!</pre>
=={{header|ALGOL 68}}==
Algol 68 doesn't do OO as such, but it has structures, the members of which can be procedures. This allows OO features to be implemented, though without syntactic sugar, "this" pointers must be passed explicitly. In Algol 68, <code>a OF b</code> is used where most other languages would use <code>b.a</code>.
<br>
This means that a call to an instance method called "print" say of a class instance "a" in Algol 68 would be written <code>( print OF a )( a )</code>, - note the explicit "this" parameter - whereas <code>a.print</code> would be used in most other languages.
<br>
Class methods could be members of the structure (as here) without a "this" parameter, or could be procedures defined outside the structure.
<br>
In this example, the instance and class methods return VOID, but this is not necessary, any return type could be used.
<syntaxhighlight lang="algol68">
BEGIN # demonstrate a possible method of simulating class & instance methods #
# declare a "class" #
MODE ANIMAL = STRUCT( STRING species
, PROC( REF ANIMAL )VOID print # instance method #
, PROC VOID cm # class method #
);
# constructor #
PROC new animal = ( STRING species )REF REF ANIMAL:
BEGIN
HEAP ANIMAL newv := ANIMAL( species
, ( REF ANIMAL this )VOID:
print( ( "[animal instance[", species OF this, "]]" ) )
, VOID: print( ( "[animal class method called]" ) )
);
HEAP REF ANIMAL newa := newv;
newa
END # new animal # ;
REF ANIMAL a
:= new animal( "PANTHERA TIGRIS" ); # create an instance of ANIMAL #
cm OF a; # call the class method #
( print OF a )( a ) # call the instance method #
END
</syntaxhighlight>
{{out}}
<pre>
[animal class method called][animal instance[PANTHERA TIGRIS]]
</pre>
=={{header|Apex}}==
<syntaxhighlight lang="java">// Static
MyClass.method(someParameter);
// Instance
myInstance.method(someParameter);</syntaxhighlight>
=={{header|AutoHotkey}}==
{{works with|AutoHotkey_L}}
(AutoHotkey Basic does not have classes)
<
{
Method(someParameter){
Line 107 ⟶ 149:
myClass.method("hi")
myInstance := new myClass
myInstance.Method("bye")</
=={{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
Line 125 ⟶ 166:
& !MyObject:?Alias
& (Alias..Method)$"Example of calling an instance method from an alias"
);</
Output:
<pre>Output from aClass: Example of calling a 'class' method
Line 131 ⟶ 172:
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.
<syntaxhighlight lang="c">
#include<stdlib.h>
#include<stdio.h>
typedef struct{
int x;
int (*funcPtr)(int);
}functionPair;
int factorial(int num){
if(num==0||num==1)
return 1;
else
return num*factorial(num-1);
}
int main(int argc,char** argv)
{
functionPair response;
if(argc!=2)
return printf("Usage : %s <non negative integer>",argv[0]);
else{
response = (functionPair){.x = atoi(argv[1]),.funcPtr=&factorial};
printf("\nFactorial of %d is %d\n",response.x,response.funcPtr(response.x));
}
return 0;
}
</syntaxhighlight>
And yes, it works :
<pre>
$ ./a.out 10
Factorial of 10 is 3628800
</pre>
=={{header|C++}}==
<
MyClass::method(someParameter);
// Instance
myInstance.method(someParameter);
// Pointer
MyPointer->method(someParameter);
</syntaxhighlight>
=={{header|C_sharp|C#}}==
<
MyClass.Method(someParameter);
// Instance
myInstance.Method(someParameter);</
=={{header|ChucK}}==
<syntaxhighlight lang="c">
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</
=={{header|COBOL}}==
{{Works with|COBOL 2002}}
There are two ways to invoke a method: the <code>INVOKE</code> statement and inline method invocation.
<syntaxhighlight lang="cobolfree">*> INVOKE statements.
INVOKE
USING BY REFERENCE some-parameter
RETURNING foo
INVOKE my-instance "another-method" *> Instance object
USING BY REFERENCE some-parameter
RETURNING foo
*> Inline method invocation.
MOVE
MOVE
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"</
=={{header|CoffeeScript}}==
While CoffeeScript does provide a useful class abstraction around its prototype-based inheritance, there aren't any actual classes.
<
@staticMethod: -> 'Bar'
Line 182 ⟶ 267:
foo.instanceMethod() #=> 'Baz'
Foo.staticMethod() #=> 'Bar'</
=={{header|Common Lisp}}==
In Common Lisp, classmethods are methods that apply to classes, rather than classes that contain methods.
<syntaxhighlight lang="lisp">(defclass my-class ()
((x
:accessor get-x ;; getter function
:initarg :x ;; arg name
:initform 0))) ;; initial value
;; declaring a public class method
(defmethod square-x ((class-instance my-class))
(* (get-x class-instance) (get-x class-instance)))
;; create an instance of my-class
(defvar *instance*
(make-instance 'my-class :x 10))
(format t "Value of x: ~a~%" (get-x *instance*))
(format t "Value of x^2: ~a~%" (square-x *instance*))
</syntaxhighlight>
Output (CLISP v2.49):
<pre>$ clisp object.cl
Value of x: 10
Value of x^2: 100
</pre>
=={{header|D}}==
<
static int staticMethod() {
return 2;
Line 221 ⟶ 334:
d = new Dog;
assert(d.dynamicMethod() == "Woof!");
}</
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls}}
This example shows the creation of a simple integer stack object. The object contains "Push" and "Pop" static methods.
<syntaxhighlight lang="Delphi">
{Simple stack interface}
type TSimpleStack = class(TObject)
private
FStack: array of integer;
protected
public
procedure Push(I: integer);
function Pop(var I: integer): boolean;
constructor Create;
end;
{ TSimpleStack implementation }
constructor TSimpleStack.Create;
{Initialize stack by setting size to zero}
begin
SetLength(FStack,0);
end;
function TSimpleStack.Pop(var I: integer): boolean;
{Pop top item off stack into "I" returns False if stack empty}
begin
Result:=Length(FStack)>=1;
if Result then
begin
{Get item from top of stack}
I:=FStack[High(FStack)];
{Delete the top item}
SetLength(FStack,Length(FStack)-1);
end;
end;
procedure TSimpleStack.Push(I: integer);
{Push item on stack by adding to end of array}
begin
{Increase stack size by one}
SetLength(FStack,Length(FStack)+1);
{Insert item}
FStack[High(FStack)]:=I;
end;
procedure ShowStaticMethodCall(Memo: TMemo);
var Stack: TSimpleStack; {Declare stack object}
var I: integer;
begin
{Instanciate stack object}
Stack:=TSimpleStack.Create;
{Push items on stack by calling static method "Push"}
for I:=1 to 10 do Stack.Push(I);
{Call static method "Pop" to retrieve and display stack items}
while Stack.Pop(I) do
begin
Memo.Lines.Add(IntToStr(I));
end;
{release stack memory and delete object}
Stack.Free;
end;
</syntaxhighlight>
{{out}}
<pre>
10
9
8
7
6
5
4
3
2
1
Elapsed Time: 10.571 ms.
</pre>
=={{header|Dragon}}==
Making an object of class and then calling it.
<syntaxhighlight lang="dragon">r = new run()
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.
<syntaxhighlight lang="dyalect">//Static method on a built-in type Integer
static func Integer.Div(x, y) {
x / y
}
//Instance method
func Integer.Div(n) {
this / n
}
print(Integer.Div(12, 3))
print(12.Div(3))</syntaxhighlight>
{{out}}
<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.
<syntaxhighlight lang
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|Ecstasy}}==
Calling a method or function in Ecstasy follows roughly the same conventions as in Java and C#, but in order to prevent certain types of bugs, Ecstasy explicitly disallows calling a function <i>as if it were a method</i>.
<syntaxhighlight lang="java">
module CallMethod {
/**
* This is a class with a method and a function.
*/
const Example(String text) {
@Override
String toString() { // <-- this is a method
return $"This is an example with text={text}";
}
static Int oneMoreThan(Int n) { // <-- this is a function
return n+1;
}
}
void run() {
@Inject Console console;
Example example = new Example("hello!");
String methodResult = example.toString(); // <-- call a method
console.print($"Result from calling a method: {methodResult.quoted()}");
// Int funcResult = example.oneMoreThan(12); // <-- compiler error
Int funcResult = Example.oneMoreThan(12); // <-- call a function
console.print($"Results from calling a function: {funcResult}");
// methods and functions are also objects that can be manipulated;
// note that "function String()" === "Function<<>, <String>>"
Method<Example, <>, <String>> method = Example.toString;
function String() func = method.bindTarget(example);
console.print($"Calling a bound method: {func().quoted()}");
// by default, a method with target T converts to a function taking a T;
// Ecstasy refers to this as "Bjarning" (because C++ takes "this" as a param)
val func2 = Example.toString; // <-- type: function String()
console.print($"Calling a Bjarne'd function: {func2(example).quoted()}");
// the function is just an object, and invocation (and in this case, binding,
// as indicated by the '&' operator which requests a reference) is accomplished
// using the "()" operator
val func3 = Example.oneMoreThan; // <-- type: function Int(Int)
val func4 = &func3(13); // <-- type: function Int()
console.print($"Calling a fully bound function: {func4()}");
}
}
</syntaxhighlight>
{{out}}
<pre>
Result from calling a method: "This is an example with text=hello!"
Results from calling a function: 13
Calling a bound method: "This is an example with text=hello!"
Calling a Bjarne'd function: "This is an example with text=hello!"
Calling a fully bound function: 14
</pre>
=={{header|Elena}}==
The message call:
<syntaxhighlight lang="elena">
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.
<syntaxhighlight lang="elixir">
defmodule ObjectCall do
def new() do
spawn_link(fn -> loop end)
end
defp loop do
receive do
{:concat, {caller, [str1, str2]}} ->
result = str1 <> str2
send caller, {:ok, result}
loop
end
end
def concat(obj, str1, str2) do
send obj, {:concat, {self(), [str1, str2]}}
receive do
{:ok, result} ->
result
end
end
end
obj = ObjectCall.new()
IO.puts(obj |> ObjectCall.concat("Hello ", "World!"))
</syntaxhighlight>
=={{header|EMal}}==
{{trans|Wren}}
<syntaxhighlight lang="emal">
type MyClass ^|we are defining a new data type and entering in its static context|^
fun method = void by block do writeLine("static method called") end
model ^|we enter the instance context|^
fun method = void by block do writeLine("instance method called") end
end
type CallAnObjectMethod
var myInstance = MyClass() ^|creating an instance|^
myInstance.method()
MyClass.method()
</syntaxhighlight>
{{out}}
<pre>
instance method called
static method called
</pre>
=={{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.
<syntaxhighlight lang="factor">USING: accessors io kernel literals math sequences ;
IN: rosetta-code.call-a-method
! Define some classes.
SINGLETON: dog
TUPLE: cat sassiness ;
! Define a constructor for cat.
C: <cat> cat
! Define a generic word that dispatches on the object at the top
! of the data stack.
GENERIC: speak ( obj -- )
! Define methods in speak which specialize on various classes.
M: dog speak drop "Woof!" print ;
M: cat speak sassiness>> 0.5 > "Hiss!" "Meow!" ? print ;
M: object speak drop "I don't know how to speak!" print ;
! Call speak on various objects.
! Despite being a method, it's called like any other word.
dog speak
0.75 <cat> speak
0.1 <cat> speak
"bird" speak</syntaxhighlight>
{{out}}
<pre>
Woof!
Hiss!
Meow!
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
Line 273 ⟶ 650:
; \ same for dynamic methods
main</
Works with any ANS Forth
Line 279 ⟶ 656:
Needs the FMS-SI (single inheritance) library code located here:
http://soton.mpeforth.com/flag/fms/index.html
<
:class animal
Line 308 ⟶ 685:
Frisky speak \ => meow ok
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.
<syntaxhighlight lang="fortran">
! type declaration
type my_type
Line 328 ⟶ 704:
mytype_object%method2() ! call method2 defined as function
</syntaxhighlight>
=={{header|FreeBASIC}}==
<syntaxhighlight lang="freebasic">
' FB 1.05.0 Win64
Type MyType
Public:
Declare Sub InstanceMethod(s As String)
Declare Static Sub StaticMethod(s As String)
Private:
dummy_ As Integer ' types cannot be empty in FB
End Type
Sub MyType.InstanceMethod(s As String)
Print s
End Sub
Static Sub MyType.StaticMethod(s As String)
Print s
End Sub
Dim t As MyType
t.InstanceMethod("Hello world!")
MyType.Staticmethod("Hello static world!")
Print
Print "Press any key to quit the program"
Sleep
</syntaxhighlight>
{{out}}
<pre>
Hello world!
Hello static world!
</pre>
=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">
local fn FBClassDemo
// Class
ClassRef class = fn MutableStringClass
// Cocoa base class name as human-readable string
print fn StringFromClass( class )
// Instantiate
CFMutableStringRef mutStr = fn MutableStringNew
// Method with single argument
MutableStringSetString( mutStr, @"Hello, World!" )
print mutStr
// Method with multiple arguments
MutableStringReplaceAllOccurrencesOfString( mutStr, @"World", @"Rosetta Code" )
print mutStr
end fn
fn FBClassDemo
HandleEvents
</syntaxhighlight>
{{output}}
<pre>
NSMutableString
Hello, World!
Hello, Rosetta Code!
</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
Line 360 ⟶ 800:
Foo.ValueMethod(myValue, someParameter)
(*Foo).PointerMethod(myPointer, someParameter)
(*Foo).ValueMethod(myPointer, someParameter)</
Go has no direct equivalent to class methods as long as you think of a Go type as a class. A Go ''package'' however can be organized and used much like a class, and in this context, any function exported from the package works much like a class method.
An example package:
<
import "sync/atomic"
Line 392 ⟶ 832:
func Count() uint32 {
return atomic.LoadUint32(&sn)
}</
Example use:
<
import "box"
Line 409 ⟶ 849:
// Call class method. In Go terms, another exported function.
box.Count()
}</
==Icon and {{header|Unicon}}==
Icon does not have objects or methods; they can be implemented on top of other types such as records.
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.
<syntaxhighlight lang="unicon">procedure main()
bar := foo() # create instance
bar.m2() # call method m2 with self=bar, an implicit first parameter
foo_m1( , "param1", "param2") # equivalent of static class method, first (self) parameter is null
end
class foo(cp1,cp2)
Line 435 ⟶ 877:
initially
L := [cp1]
end</
=={{header|Haskell}}==
Haskell doesn't have objects in OOP sence (i.e. first-class sitizens
appearing in runtime with incapsulated state and ability to send messages (methods) to other objects).
Haskell has first-class immutable records with fields of any type, representing abstraction and incapsulation (due to purity).
Polymorphism is implemented via type-classes, which are similar to OOP interfaces.
Dummy example:
<syntaxhighlight lang="haskell">data Obj = Obj { field :: Int, method :: Int -> Int }
-- smart constructor
mkAdder :: Int -> Obj
mkAdder x = Obj x (+x)
-- adding method from a type class
instanse Show Obj where
show o = "Obj " ++ show (field o) </syntaxhighlight>
<pre>*Main> let o1 = Obj 1 (*5)
*Main> field o1
1
*Main> method o1 6
30
*Main> show o1
Obj 1
*Main> let o2 = mkAdder 5
*Main> field o2
5
*Main> method o2 6
11
*Main> show o2
Obj 5</pre>
=={{header|J}}==
Line 446 ⟶ 920:
Static:
<syntaxhighlight lang
and, given an object instance reference:
<
an instance invocation could be:
<syntaxhighlight lang
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.
<syntaxhighlight lang
or
<syntaxhighlight lang
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.
Line 466 ⟶ 940:
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</
This might be useful when you are working with a variety of classes which share a common structure.
Line 473 ⟶ 947:
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
<syntaxhighlight lang
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
new ClassWithMethod().methodName(argument1, argument2);</
Instance methods may not be called on references whose value is <code>null</code> (throws a <code>NullPointerException</code>). <!--Maybe add reflection stuff here too? It might be too complicated or it might not belong here-->
Line 491 ⟶ 964:
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:
<syntaxhighlight lang
=={{header|Julia}}==
module Animal
abstract type Animal end
abstract type Dog <: Animal end
abstract type Cat <: Animal end
struct Collie <: Dog
name::String
weight::Float64
end
struct Persian <: Cat
name::String
weight::Float64
end
#
# This function is static: it works on any dog, even on a blank instance, in
# the same way, to produce the same output for anything that isa Dog in type.
#
function soundalert(a::T) where T <: Dog
println("Woof!")
end
#
# This function depends on the class instance's data for its value, so this type
# of function is one way to do an instance method in Jula.
#
masskg(x) = x.weight
=={{header|Kotlin}}==
Kotlin does not have static methods, but they can be easily simulated by <code>companion object</code> methods.
<syntaxhighlight lang="kotlin">class MyClass {
fun instanceMethod(s: String) = println(s)
companion object {
fun staticMethod(s: String) = println(s)
}
}
fun main() {
val mc = MyClass()
mc.instanceMethod("Hello instance world!")
MyClass.staticMethod("Hello static world!")
}</syntaxhighlight>
{{out}}
<pre>
Hello instance world!
Hello static world!
</pre>
=={{header|Latitude}}==
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.
<syntaxhighlight lang="latitude">myObject someMethod (arg1, arg2, arg3).
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.
<syntaxhighlight lang="latitude">myObject someMethod "string constant argument".
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.
<syntaxhighlight lang="latitude">myObject someMethod: arg1, arg2, arg3.</syntaxhighlight>
=={{header|LFE}}==
Line 506 ⟶ 1,041:
===With Closures===
<
(export all))
Line 599 ⟶ 1,134:
(defun get-children-count (object)
(funcall (get-method object 'children-count) object))
</syntaxhighlight>
With this done, one can create objects and interact with them. Here is some usage from the LFE REPL:
<
> (slurp '"object.lfe")
Line 646 ⟶ 1,181:
children: ["fdcf35983bb496650e558a82e34c9935",
"3e64e5c20fb742dd88dac1032749c2fd"]
ok</
===With Lightweight Processes===
<
(export all))
Line 749 ⟶ 1,284:
(defun get-children-count (object)
(call-method object 'children-count))</
Here is some usage from the LFE REPL:
<
> (slurp '"object.lfe")
Line 796 ⟶ 1,331:
children: ["fdcf35983bb496650e558a82e34c9935",
"3e64e5c20fb742dd88dac1032749c2fd"]
ok</
=={{header|Lingo}}==
<syntaxhighlight lang="lingo">-- call static method
script("MyClass").foo()
-- call instance method
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
Line 811 ⟶ 1,352:
:- end_object.
</syntaxhighlight>
<
:- object(class,
instantiates(metaclass)).
Line 822 ⟶ 1,363:
:- end_object.
</syntaxhighlight>
<
:- object(instance,
instantiates(class)).
:- end_object.
</syntaxhighlight>
Testing:
<
| ?- class::me(Me).
Me = class
Line 838 ⟶ 1,379:
Class = 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
object.func(object) -- without : 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)
Line 858 ⟶ 1,398:
object:func() -- with : sugar
methods.func(object) -- without : sugar</
Lua does not have a specific way of handling static methods, but similarly to Go, they could simply be implemented as regular functions inside of a module.
Example module, named <code>box.lua</code>:
<
local box = { }
local boxmt = { __index = box }
Line 878 ⟶ 1,418:
return count
end
return M</
Example use:
<
local b = box.new()
print(b:tellSecret())
print(box.count())</
=={{header|M2000 Interpreter}}==
In M2000 there are some kinds of objects. Group is an object. We can compose members to groups, with functions, operators, modules, events, and inner groups, among other members of type pointer to object. Another type is the COM type. Here we see the Group object
<syntaxhighlight lang="m2000 interpreter">
Module CheckIt {
\\ A class definition is a function which return a Group
\\ We can make groups and we can alter them using Group statement
\\ Groups may have other groups inside
Group Alfa {
Private:
myvalue=100
Public:
Group SetValue {
Set (x) {
Link parent myvalue to m
m<=x
}
}
Module MyMethod {
Read x
Print x*.myvalue
}
}
Alfa.MyMethod 5 '500
Alfa.MyMethod %x=200 ' 20000
\\ we can copy Alfa to Z
Z=Alfa
Z.MyMethod 5
Z.SetValue=300
Z.MyMethod 5 ' 1500
Alfa.MyMethod 5 ' 500
Dim A(10)
A(3)=Z
A(3).MyMethod 5 '1500
A(3).SetValue=200
A(3).MyMethod 5 '1000
\\ get a pointer of group in A(3)
k->A(3)
k=>SetValue=100
A(3).MyMethod 5 '500
\\ k get pointer to Alfa
k->Alfa
k=>SetValue=500
Alfa.MyMethod 5 '2500
k->Z
k=>MyMethod 5 ' 1500
Z.SetValue=100
k=>MyMethod 5 ' 500
}
Checkit
</syntaxhighlight>
=={{header|Maple}}==
There is no real difference in how you call a static or instance method.
<
Method( obj, other, arg );</
<
Method( obj, other, arg );</
=={{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.
<syntaxhighlight lang="miniscript">Dog = {}
Dog.name = ""
Dog.help = function()
print "This class represents dogs."
end function
Dog.speak = function()
print self.name + " says Woof!"
end function
fido = new Dog
fido.name = "Fido"
Dog.help // calling a "class method"
fido.speak // calling an "instance method"</syntaxhighlight>
{{out}}
<pre>This class represents dogs.
Fido says Woof!</pre>
=={{header|Nanoquery}}==
<syntaxhighlight lang="nanoquery">class MyClass
declare static id = 5
declare MyName
// constructor
def MyClass(MyName)
this.MyName = MyName
end
// class method
def getName()
return this.MyName
end
// static method
def static getID()
return id
end
end
// call the static method
println MyClass.getID()
// instantiate a new MyClass object with the name "test"
// and call the class method
myclass = new(MyClass, "test")
println myclass.getName()</syntaxhighlight>
{{out}}
<pre>5
test</pre>
=={{header|Nemerle}}==
<
MyClass.Method(someParameter);
// Instance
myInstance.Method(someParameter);</
=={{header|NetRexx}}==
Like [[#Java|Java]], static methods in NetRexx are called by using the dot operator on a class name:
<syntaxhighlight lang
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</
=={{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)</
=={{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>&GO</tt> on the current object:
<syntaxhighlight lang
=={{header|Objeck}}==
<
ClassName->some_function(); # call class function
instance->some_method(); # call instance method</
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);
// Instance
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:
Line 955 ⟶ 1,591:
// Method with no arguments
[myInstance method];</
=={{header|OCaml}}==
We can only call the method of an instantiated object:
<syntaxhighlight lang
=={{header|Oforth}}==
When a method is called, the top of the stack is used as the object on which the method will be applyed :
<syntaxhighlight lang
For class methods, the top of the stack must be a class (which is also an object of Class class) :
<syntaxhighlight lang
=={{header|ooRexx}}==
<
c=.circle~new(1)
say "c~area:" c~area
Line 1,000 ⟶ 1,633:
Say self~class
Say self
return self~class~pi * radius * radius </
'''Output:'''
<pre>pi: 3.14159265358979323
Line 1,007 ⟶ 1,640:
c~area: 3.14159265
10 circles were created</pre>
=={{header|Perl}}==
<
MyClass->classMethod($someParameter);
# Equivalently using a class name
Line 1,025 ⟶ 1,657:
# the package and calling it on the class name or object reference explicitly
MyClass::classMethod('MyClass', $someParameter);
MyClass::method($myInstance, $someParameter);</
=={{header|Phix}}==
{{libheader|Phix/Class}}
Class methods are only "static" (not really a Phix term) if you don't override them.<br>
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.
<!--<syntaxhighlight lang="phix">(notonline)-->
<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: #004080;">string</span> <span style="color: #000000;">msg</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"this is a test"</span>
<span style="color: #008080;">procedure</span> <span style="color: #000000;">show</span><span style="color: #0000FF;">()</span> <span style="color: #0000FF;">?</span><span style="color: #7060A8;">this</span><span style="color: #0000FF;">.</span><span style="color: #000000;">msg</span> <span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
<span style="color: #008080;">procedure</span> <span style="color: #000000;">inst</span><span style="color: #0000FF;">()</span> <span style="color: #0000FF;">?</span><span style="color: #008000;">"this is dynamic"</span> <span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
<span style="color: #008080;">end</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: #7060A8;">new</span><span style="color: #0000FF;">()</span>
<span style="color: #000000;">t</span><span style="color: #0000FF;">.</span><span style="color: #000000;">show</span><span style="color: #0000FF;">()</span> <span style="color: #000080;font-style:italic;">-- prints "this is a 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 dynamic"</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: #000000;">t</span><span style="color: #0000FF;">.</span><span style="color: #000000;">show</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
Line 1,091 ⟶ 1,685:
// Instance method
$myInstance->method($someParameter);</
=={{header|PicoLisp}}==
Method invocation is syntactically equivalent to normal function calls. Method names have a trailing '>' by convention.
<
(foo> MyObject)</
=={{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);
call_function(obj["method"]);</
<code>call_function()</code> is rarely used anymore.
because <code>()</code> is actually an operator that is applied to a function reference, the following is also possible:
<
func();</
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"]();</
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,
Line 1,142 ⟶ 1,734:
DBMS_OUTPUT.put_line( myClass.static_method() );
DBMS_OUTPUT.put_line( myInstance.instance_method() );
END;/</
=={{header|PowerShell}}==
<
$Date.AddDays( 1 )
[System.Math]::Sqrt( 2 )</
=={{header|Processing}}==
<syntaxhighlight lang="processing">// define a rudimentary class
class HelloWorld
{
public static void sayHello()
{
println("Hello, world!");
}
public void sayGoodbye()
{
println("Goodbye, cruel world!");
}
}
// call the class method
HelloWorld.sayHello();
// create an instance of the class
HelloWorld hello = new HelloWorld();
// and call the instance method
hello.sayGoodbye();</syntaxhighlight>
=={{header|Python}}==
<
@classmethod
def myClassMethod(self, x):
Line 1,173 ⟶ 1,785:
# You can also call class or static methods on an instance, which will simply call it on the instance's class
myInstance.myClassMethod(someParameter)
myInstance.myStaticMethod(someParameter)</
=={{header|Quackery}}==
Quackery is not an Object Oriented language. However it is possible to create a zen-like "distilled essence of object-orientation" in just a few lines of code.
Note that Quackery also does not have operator overloading (but see
[https://rosettacode.org/wiki/Modular_arithmetic3Quackery Modular arithmetic#Quackery] for an illustration of how this can be achieved) so there is limited inheritance of methods possible - here only the methods <code>localise</code> and <code>delocalise</code> are common to all object types.
(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.)
<syntaxhighlight lang="quackery">( ---------------- zen object orientation -------------- )
[ immovable
]this[ swap do ]done[ ] is object ( --> )
[ ]'[ ] is method ( --> [ )
[ method
[ dup share
swap put ] ] is localise ( --> [ )
[ method [ release ] ] is delocalise ( --> [ )
( -------------- example: counter methods -------------- )
( to create a counter object, use:
"[ object 0 ] is 'name' ( [ --> )" )
[ method
[ 0 swap replace ] ] is reset-counter ( --> [ )
[ method
[ 1 swap tally ] ] is increment-counter ( --> [ )
[ method [ share ] ] is report-counter ( --> [ )
( -------------------- demonstration ------------------- )
say 'Creating counter object: "mycounter".' cr cr
[ object 0 ] is mycounter ( [ --> )
say "Initial value of mycounter: "
report-counter mycounter echo cr cr
say "Incrementing mycounter three times." cr
3 times [ increment-counter mycounter ]
say "Current value of mycounter: "
report-counter mycounter echo cr cr
say "Localising mycounter." cr cr
localise mycounter
say " Current value of mycounter: "
report-counter mycounter echo cr cr
say " Resetting mycounter." cr
reset-counter mycounter
say " Current value of mycounter: "
report-counter mycounter echo cr cr
say " Incrementing mycounter six times." cr
6 times [ increment-counter mycounter ]
say " Current value of mycounter: "
report-counter mycounter echo cr cr
say "Delocalising mycounter." cr cr
delocalise mycounter
say "Current value of mycounter: "
report-counter mycounter echo cr cr
say "Resetting mycounter." cr
reset-counter mycounter
say "Current value of mycounter: "
report-counter mycounter echo cr cr</syntaxhighlight>
{{out}}
<pre>Creating counter object: "mycounter".
Initial value of mycounter: 0
Incrementing mycounter three times.
Current value of mycounter: 3
Localising mycounter.
Current value of mycounter: 3
Resetting mycounter.
Current value of mycounter: 0
Incrementing mycounter six times.
Current value of mycounter: 6
Delocalising mycounter.
Current value of mycounter: 3
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)</
=={{header|Raku}}==
(formerly Perl 6)
{{works with|Rakudo|2015.12}}
=== Basic method calls ===
<syntaxhighlight lang="raku" line>class Thing {
method regular-example() { say 'I haz a method' }
multi method multi-example() { say 'No arguments given' }
multi method multi-example(Str $foo) { say 'String given' }
multi method multi-example(Int $foo) { say 'Integer given' }
};
# 'new' is actually a method, not a special keyword:
my $thing = Thing.new;
# No arguments: parentheses are optional
$thing.regular-example;
$thing.regular-example();
$thing.multi-example;
$thing.multi-example();
# Arguments: parentheses or colon required
$thing.multi-example("This is a string");
$thing.multi-example: "This is a string";
$thing.multi-example(42);
$thing.multi-example: 42;
# Indirect (reverse order) method call syntax: colon required
my $foo = new Thing: ;
multi-example $thing: 42;
</syntaxhighlight>
=== Meta-operators ===
The <code>.</code> operator can be decorated with meta-operators.
<syntaxhighlight lang="raku" line>
my @array = <a z c d y>;
@array .= sort; # short for @array = @array.sort;
say @array».uc; # uppercase all the strings: A C D Y Z
</syntaxhighlight>
=== Classless methods ===
A method that is not in a class can be called by using the <code>&</code> sigil explicitly.
<syntaxhighlight lang="raku" line>
my $object = "a string"; # Everything is an object.
my method example-method {
return "This is { self }.";
}
say $object.&example-method; # Outputs "This is a string."
</syntaxhighlight>
=={{header|Ring}}==
<syntaxhighlight lang="ring">
new point { print() }
Class Point
x = 10 y = 20 z = 30
func print see x + nl + y + nl + z + nl
</syntaxhighlight>
<syntaxhighlight lang="ring">
o1 = new System.output.console
o1.print("Hello World")
Package System.Output
Class Console
Func Print cText
see cText + nl
</syntaxhighlight>
=={{header|Ruby}}==
<
MyClass.some_method(some_parameter)
Line 1,194 ⟶ 1,981:
# Instance method
my_instance.
# The parentheses are optional
my_instance.
# Calling a method with no parameters
my_instance.another_method</
=={{header|Rust}}==
<
impl Foo {
Line 1,233 ⟶ 2,019:
let lots_of_references = &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&foo;
println!("The answer to life is still {}." lots_of_references.get_the_answer_to_life());
}</
=={{header|Scala}}==
<
* creates "val variable1: Int" with that value.
*/
Line 1,259 ⟶ 2,044:
assert(n.memberVal == 3)
println("Successfully completed without error.")
}</
=={{header|Sidef}}==
<
method foo(arg) { say arg }
}
Line 1,284 ⟶ 2,068:
# Alternatively, by asking for a method
instance.method(:foo)(arg);</
=={{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 "
Line 1,306 ⟶ 2,089:
" Binary (operator) message"
myInstance + argument .</
Example for dynamic class determination:
<
Message names (selectors) can be chosen or constructed dynamically at runtime. For example:
<
foo perform: whichMessage</
or:
<
foo perform: theMessage.</
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'
]</
=={{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.
<syntaxhighlight lang="supercollider">
SomeClass {
*someClassMethod {
}
someInstanceMethod {
}
}
SomeClass.someClassMethod;
a = SomeClass.new;
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:
Line 1,341 ⟶ 2,143:
// Method with multiple arguments
myInstance.method(red:arg1, green:arg2, blue:arg3)</
=={{header|Tcl}}==
<
# "Static" (on class object)
MyClass mthd someParameter
# Instance
$myInstance mthd someParameter</
=={{header|TXR}}==
TXR Lisp method invocation syntax is <code>obj.(method args...)</code>.
Static methods are just functions that don't take an object as an argument. The above notation, therefore, normally isn't used, rather the functional square brackets: <code>[obj.function args...]</code>.
The <code>defstruct</code> clause <code>:method</code> is equivalent to <code>:function</code> except that it requires at least one argument, the leftmost one denoting the object.
The <code>obj.(method args...)</code> could be used to call a static function; it would pass <code>obj</code> as the leftmost argument. Vice versa, the square bracket call notation can be used to invoke a method; the object has to be manually inserted: <code>[obj.function obj args...]</code>.
<syntaxhighlight lang="txrlisp">(defvarl thing-count 0)
(defstruct thing ()
(call-count 0)
(:init (me)
(inc thing-count))
(:function get-thing-count () thing-count)
(:method get-call-count (me) (inc me.call-count)))
(let ((t1 (new thing))
(t2 (new thing)))
(prinl t1.(get-call-count)) ;; prints 1
(prinl t1.(get-call-count)) ;; prints 2
(prinl t1.(get-call-count)) ;; prints 3
(prinl t2.(get-call-count)) ;; prints 1
(prinl t2.(get-call-count)) ;; prints 2
(prinl t2.(get-call-count)) ;; prints 3
(prinl [t1.get-thing-count]) ;; prints 2
(prinl [t2.get-thing-count])) ;; prints 2</syntaxhighlight>
{{out}}
<pre>1
2
3
1
2
3
2
2</pre>
=={{header|Ursa}}==
<syntaxhighlight lang="ursa"># create an instance of the built-in file class
decl file f
# call the file.open method
f.open "filename.txt"</syntaxhighlight>
=={{header|VBA}}==
First we have to create a class module named "myObject" :
<syntaxhighlight lang="vb">
Option Explicit
Sub Method_1(Optional myStr As String)
Dim strTemp As String
If myStr <> "" Then strTemp = myStr
Debug.Print strTemp
End Sub
Static Sub Method_2(Optional myStr As String)
Dim strTemp As String
If myStr <> "" Then strTemp = myStr
Debug.Print strTemp
End Sub</syntaxhighlight>
In a "standard" Module, the call should be :
<syntaxhighlight lang="vb">Option Explicit
Sub test()
Dim Obj As New myObject
Obj.Method_1 "Hello to you"
Obj.Method_2 "What is your name ?"
Obj.Method_1
Obj.Method_2
End Sub</syntaxhighlight>
{{out}}
<pre>Hello to you
What is your name ?
What is your name ?</pre>
=={{header|V (Vlang)}}==
Vlang uses objects without classes (sometimes known as class-free or classless):
1) Structs can have methods assigned to them or be embedded in other structs.
2) Vlang also uses modules. Functions and structs can be exported from a module, which works somewhat similar to the class method.
<syntaxhighlight lang="Zig">
// Assigning methods to structs
struct HelloWorld {}
// Method's in Vlang are functions with special receiver arguments at the front (between fn and method name)
fn (sh HelloWorld) say_hello() {
println("Hello, world!")
}
fn (sb HelloWorld) say_bye() {
println("Goodbye, world!")
}
fn main() {
// instantiate object
hw := HelloWorld{}
// call methods of object
hw.say_hello()
hw.say_bye()
}
</syntaxhighlight>
{{out}}
<pre>
Hello, world!
Goodbye, world!
</pre>
Exporting functions from modules:
Create a module:
<syntaxhighlight lang="Zig">
// myfile.v
module mymodule
// Use "pub" to export a function
pub fn say_hi() {
println("hello from mymodule!")
}
</syntaxhighlight>
Import and use the module's function in your code:
<syntaxhighlight lang="Zig">
import mymodule
fn main() {
mymodule.say_hi()
}
</syntaxhighlight>
{{out}}
<pre>
hello from mymodule!
</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.
<syntaxhighlight lang="wren>class MyClass {
construct new() {}
method() { System.print("instance method called") }
static method() { System.print("static method called") }
}
var mc = MyClass.new()
mc.method()
MyClass.method()</syntaxhighlight>
{{out}}
<pre>
instance method called
static method called
</pre>
=={{header|XBS}}==
You can call object methods using two types of structures. Classes and Objects.
===Classes===
<syntaxhighlight lang="xbs">class MyClass {
construct=func(self,Props){
self:Props=Props;
}{Props={}}
GetProp=func(self,Name){
send self.Props[Name];
}
}
set Class = new MyClass with [{Name="MyClass Name"}];
log(Class::GetProp("Name"));</syntaxhighlight>
{{out}}
<pre>
MyClass Name
</pre>
===Objects===
<syntaxhighlight lang="xbs">set MyObj = {
a=10;
AddA=func(self,x){
send self.a+x;
};
}
log(MyObj::AddA(2));</syntaxhighlight>
{{out}}
<pre>
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.
<syntaxhighlight lang="xlisp">(DEFINE-CLASS MY-CLASS)
(DEFINE-CLASS-METHOD (MY-CLASS 'DO-SOMETHING-WITH SOME-PARAMETER)
(DISPLAY "I am the class -- ")
(DISPLAY SELF)
(NEWLINE)
(DISPLAY "You sent me the parameter ")
(DISPLAY SOME-PARAMETER)
(NEWLINE))
(DEFINE-METHOD (MY-CLASS 'DO-SOMETHING-WITH SOME-PARAMETER)
(DISPLAY "I am an instance of the class -- ")
(DISPLAY SELF)
(NEWLINE)
(DISPLAY "You sent me the parameter ")
(DISPLAY SOME-PARAMETER)
(NEWLINE))
(MY-CLASS 'DO-SOMETHING-WITH 'FOO)
(DEFINE MY-INSTANCE (MY-CLASS 'NEW))
(MY-INSTANCE 'DO-SOMETHING-WITH 'BAR)</syntaxhighlight>
{{out}}
<pre>I am the class -- #<Class:MY-CLASS #x38994c8>
You sent me the parameter FOO
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.
<syntaxhighlight lang="zig">const testing = @import("std").testing;
pub const ID = struct {
name: []const u8,
age: u7,
const Self = @This();
pub fn init(name: []const u8, age: u7) Self {
return Self{
.name = name,
.age = age,
};
}
pub fn getAge(self: Self) u7 {
return self.age;
}
};
test "call an object method" {
// Declare an instance of a struct by using a struct method.
const person1 = ID.init("Alice", 18);
// Or by declaring it manually.
const person2 = ID{
.name = "Bob",
.age = 20,
};
// test getAge() method call
try testing.expectEqual(@as(u7, 18), person1.getAge());
try testing.expectEqual(@as(u7, 20), ID.getAge(person2));
}</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
Line 1,363 ⟶ 2,425:
D.f.isStatic //-->False
class E{var v; fcn f{}} E.f.isStatic //-->True</
<!-- Same omits as Classes page -->
{{omit from|360 Assembly}}
{{omit from|6502 Assembly}}
{{omit from|8051 Assembly}}
{{omit from|8080 Assembly}}
{{omit from|8086 Assembly}}
{{omit from|68000 Assembly}}
{{omit from|AArch64 Assembly}}
{{omit from|ARM Assembly}}
{{omit from|AWK|not OO}}
{{omit from|BASIC|not OO}}
{{omit from|bc}}
{{omit from|dc}}
{{omit from|GUISS}}
Line 1,377 ⟶ 2,446:
{{omit from|Maxima}}
{{omit from|Metafont}}
{{omit from|MIPS Assembly}}
{{omit from|Octave}}
{{omit from|PARI/GP}}
{{omit from|Plain English|Plain English does not support objects.}}
{{omit from|Retro}}
{{omit from|REXX|not OO}}
{{omit from|Standard ML}}
{{omit from|TI-83 BASIC|not OO}}
{{omit from|TI-89 BASIC|Does not have user-defined types/classes}}
{{omit from|UNIX Shell}}
{{omit from|Vim Script}}
{{omit from|x86 Assembly}}
{{omit from|Z80 Assembly}}
{{omit from|ZX Spectrum Basic|not OO}}
| |||