Classes: Difference between revisions
m
→{{header|Wren}}: Changed to Wren S/H
m (→{{header|Wren}}: Changed to Wren S/H) |
|||
(34 intermediate revisions by 19 users not shown) | |||
Line 1:
[[Category:Object oriented]]
[[Category:Type System]]
[[Category:Encyclopedia]]
{{task|Basic language learning}}
In [[object-oriented programming]] '''class''' is a set (a [[wp:Transitive_closure|transitive closure]]) of types bound by the relation of [[inheritance]]. It is said that all types derived from some base type T and the type T itself form a class T.
Line 37 ⟶ 38:
Create a basic class with a method, a constructor, an instance variable and how to instantiate it.
<br><br>
=={{header|11l}}==
<
Int public_variable // member variable = instance variable
. Int private_variable
Line 48:
F someMethod() // member function = method
.private_variable = 1
.public_variable = 10</
Note that member functions in 11l by default are not polymorphic; if you want a polymorphic member function, you have to mark it as virtual. Example:
<
F.virtual.new someMethod() -> N // this is polymorphic
print()</
=={{header|ActionScript}}==
<
public class MyClass {
Line 76 ⟶ 75:
}
}
}</
=={{header|Ada}}==
Class is used in many languages to provide both encapsulation, or grouping of data and actions, and type definition. Ada packages provide encapsulation or grouping while type definitions are done using the ''type'' reserved word. Types participating in inheritance are named ''tagged'' record types.
A package specification has the following form:
<
type My_Type is tagged private;
procedure Some_Procedure(Item : out My_Type);
Line 90 ⟶ 88:
Variable : Integer := -12;
end record;
end My_Package;</
The type declaration at the top of the package gives public visibility to the private tagged type My_Type. Since My_Type is declared to be private, the public has no visibility of its structure. The type must be treated as a black box. The private section of the package specification includes the actual tagged record definition. Note that the data member Variable is initialized to -12. This corresponds to a default constructor for the type.
The package body must contain the implementation of the procedures and functions declared in the package specification.
<
procedure Some_Procedure(Item : out My_Type) is
begin
Line 106 ⟶ 104:
return Temp;
end Set;
end My_Package;</
The Set function acts as a conversion constructor for My_Type.
An instance is typically created outside the package:
<
procedure Main is
Line 117 ⟶ 115:
Some_Procedure(Foo); -- Foo is doubled
Foo := Set(2007); -- Foo.Variable is set to 2007
end Main;</
=={{header|Aikido}}==
Aikido provides classes with single inheritance and multiple interface implementation. A class takes a set of constructor arguments and provides a set of public functions, operators, classes, monitors and threads.
<
var myvec = new Vector (x, y)
Line 127 ⟶ 124:
// draw the circle
}
}</
=={{header|ALGOL 68}}==
{{trans|python}}
Line 141 ⟶ 137:
Other examples of this experimental approach are located at pages: [[Life in two dimensions#ALGOL 68|Life in two dimensions]], [[Playing Cards#ALGOL 68|Playing Cards]] and [[Stack#ALGOL 68|Stack]].
<
INT name1
);
Line 222 ⟶ 218:
print (((name OF person2), ": ",
(gender OF person2|(STRING gender):gender|attribute error), " "));
print (((age OF person2|(INT age):age|attribute error), new line)) # "Jane Female 23" #</
{{out}}
<pre>
Line 228 ⟶ 224:
Jane: Female +23
</pre>
=={{header|AmigaE}}==
<
varA, varP
ENDOBJECT
Line 256 ⟶ 251:
WriteF('\d\n', obj.getP())
END obj
ENDPROC</
=={{header|Arturo}}==
<
define :person [ ; define a new custom type "Person"
name ; with fields: name, surname, age
surname
age
][
; with custom post-construction initializer
init: [
this\name: capitalize this\name
]
; custom print function
print: [
render "NAME: |this\name|, SURNAME: |this\surname|, AGE: |this\age|"
]
; custom comparison operator
compare: 'age
]
ensure -> is? :person this
print ["Hello" this\name]
]
; create new objects of our custom type
a: to :person ["John" "Doe" 34] ; let's create 2 "Person"s
b: to :person ["jane" "Doe" 33] ; and another one
; call pseudo-inner method
sayHello a ; Hello John
sayHello b ; Hello Jane
; access object fields
print ["The first person's name is:" a\name] ; The first person's name is: John
print ["The second person's name is:" b\name] ; The second person's name is: Jane
a\name: "Bob"
sayHello a ; Hello Bob
; verifying object type
print type a ; :person
print is? :person a ; true
; printing objects
print a ; NAME: John, SURNAME: Doe, AGE: 34
; sorting user objects (using custom comparator)
sort @[a b] ; Jane..., John...
sort.descending @[a b] ; John..., Jane... </syntaxhighlight>
{{out}}
<pre>Hello John
Hello Jane
The first person's name is: John
The second person's name is: Jane
Hello Bob
:person
true
NAME: Bob, SURNAME: Doe, AGE: 34</pre>
=={{header|AutoHotkey}}==
{{works with|AutoHotkey_L}}
AutoHotkey_L is prototype-based. However, for convenience, class-syntax may be used to create a base object.
<
obj.WhenCreated()
Line 330 ⟶ 340:
MsgBox, % "Object created at " this.time " on " this.date
}
}</
=={{header|BASIC}}==
==={{header|BaCon}}===
This is an '''advanced feature''' to extend the the compiler we can also compile using g++ or clang++ using PRAGMA
<syntaxhighlight lang="cpp">
PRAGMA COMPILER g++
PRAGMA OPTIONS -Wno-write-strings -Wno-pointer-arith -fpermissive
OPTION PARSE FALSE
'---The class does the declaring for you
CLASS Books
public:
const char* title;
const char* author;
const char* subject;
int book_id;
END CLASS
'---pointer to an object declaration (we use a class called Books)
DECLARE Book1 TYPE Books
'--- the correct syntax for class
Book1 = Books()
'--- initialize the strings const char* in c++
Book1.title = "C++ Programming to bacon "
Book1.author = "anyone"
Book1.subject ="RECORD Tutorial"
Book1.book_id = 1234567
PRINT "Book title : " ,Book1.title FORMAT "%s%s\n"
PRINT "Book author : ", Book1.author FORMAT "%s%s\n"
PRINT "Book subject : ", Book1.subject FORMAT "%s%s\n"
PRINT "Book book_id : ", Book1.book_id FORMAT "%s%d\n"
</syntaxhighlight>
Now the same but using the c++ "new" command and arrow operators syntax
<syntaxhighlight lang="cpp">
PRAGMA COMPILER g++
PRAGMA OPTIONS -Wno-write-strings -Wno-pointer-arith -fpermissive
OPTION PARSE FALSE
'---The class does the declaring for you
CLASS Books
public:
const char* title;
const char* author;
const char* subject;
int book_id;
END CLASS
'---pointer to an object declaration (we use a class called Books)
DECLARE Book1 TYPE Books*
'--- the correct syntax for class
Book1 = new Books()
'--- initialize the strings const char* in c++
Book1->title = "C++ Programming to bacon "
Book1->author = "anyone"
Book1->subject ="RECORD Tutorial"
Book1->book_id = 1234567
PRINT "Book title : " ,Book1->title FORMAT "%s%s\n"
PRINT "Book author : ", Book1->author FORMAT "%s%s\n"
PRINT "Book subject : ", Book1->subject FORMAT "%s%s\n"
PRINT "Book book_id : ", Book1->book_id FORMAT "%s%d\n"
</syntaxhighlight>
==={{header|BBC BASIC}}===
{{works with|BBC BASIC for Windows}}
<
REM Declare the class:
Line 373 ⟶ 441:
REM Discard the instance:
PROC_discard(myclass{})</
==={{header|QuickBASIC}}===
{{works with|QuickBasic|4.5}}
<syntaxhighlight lang="basic"> TYPE MyClass
Variable AS INTEGER
END TYPE
DECLARE SUB MyClassDelete (pthis AS MyClass)
DECLARE SUB MyClassSomeMethod (pthis AS MyClass)
DECLARE SUB MyClassInit (pthis AS MyClass)
DIM obj AS MyClass
MyClassInit obj
MyClassSomeMethod obj
SUB MyClassInit (pthis AS MyClass)
pthis.Variable = 0
END SUB
SUB MyClassSomeMethod (pthis AS MyClass)
pthis.Variable = 1
END SUB</syntaxhighlight>
=={{header|blz}}==
<
# Constructors can take parameters (that automatically become properties)
constructor Ball(color, radius)
Line 393 ⟶ 483:
print(red_ball)
# => a red ball with radius 2
</syntaxhighlight>
=={{header|BQN}}==
Classes with a constructor can be defined in BQN with the help of a namespace. All data members are immutable(private) and can only be modified with the help of exported functions. Exported variables can be accessed, but they cannot be mutated(this may change in the future).
<syntaxhighlight lang="bqn">ExClass ← {
𝕊 value: # Constructor portion
priv ← value
priv2 ⇐ 0
ChangePriv ⇐ { priv ↩ 𝕩 }
DispPriv ⇐ {𝕊: •Show priv‿priv2 }
}
obj ← ExClass 5
obj.DispPriv@
obj.ChangePriv 6
obj.DispPriv@</syntaxhighlight>
=={{header|Bracmat}}==
Bracmat has no class-inheritance. Any object can function as a template for creating other objects.
<
= (x=)
(y=)
Line 404 ⟶ 510:
& new$(resolution,640,480):?VGA
& new$(resolution,1920,1080):?1080p
& out$("VGA: horizontal " !(VGA..x) " vertical " !(VGA..y)));</
{{out}}
<pre>VGA: horizontal 640 vertical 480</pre>
=={{header|C}}==
{{works with|gcc|4.0.2}}
<syntaxhighlight lang="c">
#include <stdlib.h>
Line 441 ⟶ 546:
MyClass obj = MyClass_new();
MyClass_someMethod(obj);
MyClass_delete(&obj);</
=={{header|C sharp|C#}}==
<syntaxhighlight lang="csharp">public class MyClass
{
public MyClass()
{
}
public void SomeMethod()
{
}
private int _variable;
public int Variable
{
get { return _variable; }
set { _variable = value; }
}
public static void Main()
{
// instantiate it
MyClass instance = new MyClass();
// invoke the method
instance.SomeMethod();
// set the variable
instance.Variable = 99;
// get the variable
System.Console.WriteLine( "Variable=" + instance.Variable.ToString() );
}
}</syntaxhighlight>
=={{header|C++}}==
{{works with|g++|4.0.2}}
<
{
public:
Line 473 ⟶ 604:
MyClass* pInstance = new MyClass;
// Instances allocated with new must be explicitly destroyed when not needed any more:
delete pInstance;</
Note: <tt>MyClass instance();</tt> would ''not'' define an instance, but declare a function returning an instance. Accidentally declaring functions when object definitions are wanted is a rather common bug in C++.
Line 479 ⟶ 610:
Functions can also be defined inline:
<
{
public:
Line 486 ⟶ 617:
private:
int variable;
};</
Note that member functions in C++ by default are ''not'' polymorphic; if you want a polymorphic member function, you have to mark it as virtual. In that case, you should also add a virtual destructor, even if that is empty. Example:
<
{
public:
virtual void someMethod(); // this is polymorphic
virtual ~MyClass(); // destructor
};</
=={{header|Clojure}}==
Clojure gives you several options, and to help you decide which is more appropriate to use, see the [https://github.com/cemerick/clojure-type-selection-flowchart/ Clojure type selection flowchart].
defrecord example:
<
; You can think of this as an interface
(defprotocol Foo (getFoo [this]))
Line 538 ⟶ 640:
; Create instance and invoke our method to return field value
(-> (Example1. "Hi") .getFoo)
"Hi"</
=={{header|COBOL}}==
<!-- This took far too long to create and to get to compile. -->
<
CLASS-ID. my-class INHERITS base.
Line 607 ⟶ 708:
.
END PROGRAM example-class-use.</
=={{header|Coco}}==
<
# The constructor is defined as a bare function. This
# constructor accepts one argument and automatically assigns it
Line 624 ⟶ 724:
# Instantiate the class using the 'new' operator.
rect = new Rectangle 2</
=={{header|CoffeeScript}}==
<
class Rectangle
# Constructor that accepts one argument
Line 640 ⟶ 739:
# Instantiate the class using the new operator
rect = new Rectangle 2</
=={{header|Common Lisp}}==
<
((radius :initarg :radius
:initform 1.0
Line 654 ⟶ 752:
> (defvar *c* (make-instance 'circle :radius 2))
> (area *c*)
12.566370614359172d0</
=={{header|Component Pascal}}==
BlackBox Component Builder
Module that defines a Class
<
MODULE Point;
IMPORT
Line 702 ⟶ 799:
END ToString;
END Point.
</syntaxhighlight>
Module that uses previous class
<
MODULE DrivePoint;
IMPORT
Line 722 ⟶ 819:
END DrivePoint.
</syntaxhighlight>
Execute: ^Q DrivePoint.Do<br/>
{{out}}
Line 730 ⟶ 827:
p.y:> 2
</pre>
=={{header|Crystal}}==
{{trans|Ruby}}
<
def initialize
Line 746 ⟶ 842:
my_class = MyClass.new
</syntaxhighlight>
=={{header|D}}==
<
class MyClass {
Line 790 ⟶ 886:
// prints 'variable = 99'
writeln("variable = ", obj.variable);
}</
=={{header|Delphi}}==
<
{$APPTYPE CONSOLE}
Line 836 ⟶ 931:
lMyClass.Free;
end;
end.</
=={{header|DM}}==
In DM, all "classes" are part of the "object tree". Instance variables, procs (functions), ... are all defined inside this "tree".
Adding elements (procs, variables, classes) to this tree is done by defining the name and such.
<syntaxhighlight lang
This declares a type "/s" at the root of the tree, which can now be instantiated.
Line 848 ⟶ 942:
A more complicated example:
<syntaxhighlight lang="dm">
// Declare the class "/foo"
foo
Line 871 ⟶ 965:
x.bar = 10 // Assign to the instance variable.
x.baz() // Call "baz" on our instance.
</syntaxhighlight>
This is enough to declare a
=={{header|Dragon}}==
<
func val(){
showln 10+20
}
}
</syntaxhighlight>
=={{header|DWScript}}==
Methods can be implemented inline or out-of-line, this sample illustrates both.
<syntaxhighlight lang="delphi">type
TMyClass = class
private
Line 909 ⟶ 1,001:
lMyClass.SomeField := 99;
lMyClass.SomeMethod;</
=={{header|E}}==
In E, classes, constructors, and instance variables are not built into the language. This is an example of the basic convention; different cases may call for objects built in different ways.
<
def color {
to colorize(thing :String) {
Line 921 ⟶ 1,012:
}
return color
}</
Example interactive session creating and using it:
<
# value: <color>
? red.colorize("apple")
# value: "red apple"</
=={{header|EchoLisp}}==
<syntaxhighlight lang="lisp">
(lib 'gloops) ; load oo library
(define-class Person null (name (age :initform 66)))
(define-method tostring (Person) (lambda (p) ( format "🚶 %a " p.name)))
(define-method mailto (Person Person) (lambda( p o) (printf "From %a to️ %a : ..." p o)))
;; define a sub-class of Person with same methods
(define-class Writer (Person) (books))
(define-method tostring (Writer) (lambda (w)( format "🎩 %a" w.name)))
(define-method mailto (Person Writer)
(lambda (p w) (printf " From %a (age %d). Dear writer of %a ..." p p.age w.books )))
</syntaxhighlight>
{{Output}}
<syntaxhighlight lang="lisp">
;; instantiate
(define simone (make-instance Person :name 'simone :age 42)) ;; slots values by name
(define antoinette (make-instance Person :name 'antoinette :age 37))
(define albert (Person "albert" 33)) ;; quick way : slots values in order
(define simon (make-instance Writer :name "simon" :books '(my-life my-bike)))
(mailto simone simon) ;; method Person-Writer
(mailto simone antoinette) ;; method Person-Person
(mailto simon albert) ;; no method Writer-Person : call 'super' Person-Person
(mailto simon simon) ;; no mehod Writer-Writer : call 'super' Person-Writer
→
From 🚶 simone (age 42). Dear writer of (my-life my-bike) ...
From 🚶 simone to️ 🚶 antoinette : ...
From 🎩 simon to️ 🚶 albert : ...
From 🎩 simon (age 66). Dear writer of (my-life my-bike) ...
</syntaxhighlight>
=={{header|Eiffel}}==
=== The Most Basic Form of Class ===
The shortest way to write an Eiffel class is to have the class keyword, followed by the name of the class (all caps), and ending with the end keyword.
<syntaxhighlight lang="eiffel">
class MY_CLASS
end
</syntaxhighlight>
=== Add a Creation Procedure (Constructor) ===
<syntaxhighlight lang="eiffel">
class MY_CLASS
Line 955 ⟶ 1,079:
end
</syntaxhighlight>
=== Add Multiple Creation Procedures (Constructors) ===
In Eiffel, you may have more than one creation procedure (or "Constructor").
<syntaxhighlight lang="eiffel">
class MY_CLASS
Line 1,002 ⟶ 1,126:
end
</syntaxhighlight>
=== Add some Properties & Methods ===
Below, we've added three attributes (i.e. "Properties"). The "make" is not only a "Constructor" (Creation Procedure), but also an example of a "Method".
<syntaxhighlight lang="eiffel">
class MY_CLASS
Line 1,055 ⟶ 1,179:
end
</syntaxhighlight>
=={{header|Elena}}==
ELENA
<
class MyClass
{
someMethod()
Line 1,120 ⟶ 1,208:
// get the variable
console.printLine("Variable=",instance.Variable)
}</
=={{header|EMal}}==
<syntaxhighlight lang="emal">
type Bear ^| the type system is informed about the new type,
| here we are in the static context
|^
model # instance context
text name # instance variable
^|
| in EMal the instance variables are ordered, and a default
| variadic constructor is provided by the runtime.
| Every value passed to the constructor sets the instance variable
| according to the order.
|^
fun makeNoise = void by block # method of Bear
writeLine("Growl!")
end
end
type Cat
model
text noise
new by text noise # an explicit constructor
me.noise = noise # we must use me to access instance variables
end
fun makeNoise = void by block
writeLine(me.noise)
end
end
type Main
Bear bear = Bear("Bruno") # creating a new instance
writeLine("The bear is called " + bear.name)
bear.makeNoise()
Cat("Meow").makeNoise()
</syntaxhighlight>
{{out}}
<pre>
The bear is called Bruno
Growl!
Meow
</pre>
=={{header|ERRE}}==
ERRE isn't OOP-oriented, but with new PC version 3.0 is possibile to define classes and instance variables, like in this example:
<
CLASS QUADRATO
Line 1,154 ⟶ 1,282:
PRINT(PERIMETROQ)
END PROGRAM
</syntaxhighlight>
The answers is
100
80
=={{header|F_Sharp|F#}}==
A minimal example as required by the task description:
<
let mutable var = init // a private instance variable
member x.Method() = // a simple method
Line 1,169 ⟶ 1,296:
// create an instance and use it
let myObject = new MyClass(42)
myObject.Method()</
A somewhat more meaningful example, inspired by the Haskell version:
<
type Shape =
Line 1,186 ⟶ 1,313:
interface Shape with
member x.Perimeter() = 2.0 * width + 2.0 * height
member x.Area() = width * height</
=={{header|Factor}}==
<syntaxhighlight lang="factor">TUPLE: my-class foo bar baz ;
M: my-class quux foo>> 20 + ;
C: <my-class> my-class
10 20 30 <my-class> quux ! result: 30
TUPLE: my-child-class < my-class quxx ;
C: <my-child-class> my-child-class
M: my-child-class foobar 20 >>quux ;
20 20 30 <my-child-class> foobar quux ! result: 30</syntaxhighlight>
=={{header|Falcon}}==
Falcon classes are a mix of data and code that can be used to instantiate objects. Classes are defined below. Note: inh1...inhN can also be passed the param_list.
<
[ static block ]
[ properties declaration ]
[init block]
[method list]
end</
Example of a class:
<
capacity = max_msg * 10
Line 1,211 ⟶ 1,346:
end
end</
Instantiation:
<
// Ouputs: Box now ready for 100 messages.</
=={{header|Fancy}}==
<
read_slot: 'instance_var # creates getter method for @instance_var
@@class_var = []
Line 1,253 ⟶ 1,377:
}
myclass = MyClass new</
=={{header|Fantom}}==
<
{
// an instance variable
Line 1,282 ⟶ 1,405:
c := MyClass { x = 3 } // instantiates the class, sets x to 3
}
}</
=={{header|Forth}}==
{{works with|Win32Forth}}
Line 1,290 ⟶ 1,412:
Declare a class
<
int memvar
Line 1,303 ⟶ 1,425:
:m show: ( -- ) ." Memvar = " memvar . ;m
;class</
Allocate a static object
<syntaxhighlight lang
Allocate a dynamic object, saving its pointer in a global variable.
<syntaxhighlight lang
Call member functions
<
show: newInstance</
Free a dynamically allocated object
<
0 to newInstance \ no dangling pointers!</
Example of dynamic allocation and local variable use"
<
New> MyClass to obj
show: obj
1000 set: obj
obj dispose ;</
Line 1,333 ⟶ 1,455:
Needs the FMS-SI (single inheritance) library code located here:
http://soton.mpeforth.com/flag/fms/index.html
<
:class foo \ begin class foo definition
Line 1,364 ⟶ 1,486:
bar \ 10 30
bar' \ 10 30
</syntaxhighlight>
=={{header|Fortran}}==
Creating abstract derived type (abstract class), extended derived types, using constructor and finalization, pointers etc. Works with gfortran 5.0 and intel ifort 15.0.2
<
!-----------------------------------------------------------------------
!Module accuracy defines precision and some constants
Line 1,549 ⟶ 1,670:
end program rosetta_class
</syntaxhighlight>
=={{header|FreeBASIC}}==
<
Type MyClass
Line 1,578 ⟶ 1,698:
Print mc.MyInt, mc.Treble()
Print "Press any key to quit the program"
Sleep</
{{out}}
Line 1,584 ⟶ 1,704:
24 72
</pre>
=={{header|GLSL}}==
There are no classes in GLSL, but they can be simulated using structs:
<
struct Rectangle{
float width;
Line 1,607 ⟶ 1,726:
return (self.width+self.height)*2.0;
}
</syntaxhighlight>
=={{header|Go}}==
The task describes several concepts concerning class methods before giving some task requirements. The following code satisfies the task requirements. The concepts described however, are more involved. A discussion of these concepts follows.
<
import "fmt"
Line 1,660 ⟶ 1,778:
fmt.Println(forTwo)
fmt.Println(forToo)
}</
{{out}}
<pre>
Line 1,683 ⟶ 1,801:
This happens when a method is called through an interface. Consider this code in addition to the example above.
<
type happinessTester interface {
Line 1,708 ⟶ 1,826:
ps.happy())
}
}</
On the last line, in the call to ps.happy(), ps is of the interface type happinessTester. The method actually called is based on the underlying concrete type.
For the method call, this is called the receiver type and the variable b (in both happy methods) is called the receiver. Dispatch is based on this single receiver so Go is a single dispatch kind of language.
Line 1,726 ⟶ 1,844:
To the extent that an interface represents a class, it is distinct from a type that satisfies it. Interface is one kind of type, but an object of any type can satisfy an interface. The two types—the interface type and the type satisfying the interface—are distinct.
=={{header|Groovy}}==
A class:
<
class Stuff {
/** Heare bee anne instance variable declared */
def guts
/** This
Stuff(injectedGuts) {
guts = injectedGuts
Line 1,743 ⟶ 1,860:
println "This stuff is flangulating its guts: ${guts}"
}
}</
A demonstration:
<
I have made mistakes in the past.
I have made mistakes in the future.
Line 1,761 ⟶ 1,878:
'''
stuff.flangulate()</
{{out}}
Line 1,774 ⟶ 1,891:
and neither do we.
-- President George W. Bush</pre>
=={{header|Haskell}}==
Haskell is entirely statically typed; that is, the type of every expression is completely determined at compile-time.
Hence, the usual approach to object-oriented programming, in which the actual method invoked by a method call isn't determined until runtime (think of C++'s virtual functions), is impossible in Haskell 98.
Haskell's type classes allow for polymorphic functions, but all the polymorphism happens at compile-time (think of C++ templates) without the use of language extensions (existential types).
<
perimeter :: a -> Double
area :: a -> Double
Line 1,811 ⟶ 1,927:
{- The correct version of apRatio (and hence the correct
implementations of perimeter and area) is chosen based on the type
of the argument. -}</
The primary way to simulate run-time polymorphism in Haskell is to use a single algebraic data type with multiple constructors, rather than several types belonging to a single class.
<
{- This Shape is a type rather than a type class. Rectangle and
Circle are its constructors. -}
Line 1,837 ⟶ 1,953:
{- The value returned by apRatio is determined by the return values
of area and perimeter, which just happen to be defined differently
for Rectangles and Circles. -}</
== Icon and {{header|Unicon}} ==
Unicon supports classes.
<
# method definition
Line 1,861 ⟶ 1,977:
write (x2.x)
write (x2.double ()) # call a method
end</
=={{header|J}}==
'''Class definition:'''
<
exampleMethod=: monad define
Line 1,875 ⟶ 1,990:
)
exampleInstanceVariable=: 0</
'''Instantiation:'''
<
Note that all J system defined utilities designed specifically to work on classes and objects have names which begin with the prefix <code>co</code>.
=={{header|Java}}==
<
// instance variable
Line 1,901 ⟶ 2,015:
this.variable = 1;
}
}</
Note: "this." in someMethod is optional. "variable = 1;" works also. If a parameter also named "variable" came into someMethod, using "this" specifies using the instance variable rather than the local method variable. Instantiate this class using:
<syntaxhighlight lang
=={{header|JavaScript}}==
===ES5===
JavaScript is [[wp:Prototype-based programming|prototype-based]], so it doesn't have classes per se. Thinking in classes when coding JavaScript will only hinder you in the long run, but here's an example of JavaScript OO:
<
function Car(brand, weight) {
this.brand = brand;
Line 1,932 ⟶ 2,045:
alert(cars[i].brand + " " + cars[i].weight + " " + cars[i].size + ", " +
(cars[i] instanceof Car) + " " + (cars[i] instanceof Truck));
}</
The alerts shows us:
<pre>
Line 1,941 ⟶ 2,054:
===ES6===
<
/**
* A few brands of cars
Line 2,017 ⟶ 2,130:
let myTruck = new Truck('Volvo', 2);
console.log(myTruck.formattedStats);
myTruck.drive(40);</
Output:
Line 2,025 ⟶ 2,138:
Size: 2
A Volvo Truck drove 40cm</pre>
=={{header|Julia}}==
{{works with|Julia|0.6}}
Line 2,032 ⟶ 2,144:
Multiple dispatch is a core feature of the language.
<
habitat(::Mammal) = "planet Earth"
Line 2,051 ⟶ 2,163:
for a in arr
println("Habitat of $a: ", habitat(a))
end</
{{output}}
Line 2,057 ⟶ 2,169:
Habitat of a whale: ocean
Habitat of a wolf: planet Earth</pre>
=={{header|Kotlin}}==
<
fun treble(): Int = myInt * 3
}
Line 2,066 ⟶ 2,177:
val mc = MyClass(24)
print("${mc.myInt}, ${mc.treble()}")
}</
{{out}}
Line 2,072 ⟶ 2,183:
24, 72
</pre>
=={{header|Lasso}}==
In Lasso, a "class" is termed a "type"
<syntaxhighlight lang="lasso">
define mytype => type {
data
Line 2,095 ⟶ 2,205:
local(x = mytype)
#x->val = '99 Bottles of beer'
#x->asString // outputs 'has a value of: "99 Bottles of beer" and a rand number of "48"'</
=={{header|LFE}}==
<
(defmodule simple-object
(export all))
Line 2,131 ⟶ 2,240:
"Get a variable passed when constructing the object."
(funcall (get-method object 'species) object))
</syntaxhighlight>
Usage from the LFE REPL:
<
> (slurp '"simple-object.lfe")
#(ok simple-object)
Line 2,143 ⟶ 2,252:
> (get-species my-fish)
"Carp"
</syntaxhighlight>
=={{header|Lingo}}==
'''Class definition:'''
<
-- @desc Class "MyClass"
-- @file parent script "MyClass"
Line 2,165 ⟶ 2,273:
me._myvar = me._myvar * 2
put me._myvar
end</
'''Instantiation:'''
<
foo.doubleAndPrint()
-- 46</
=={{header|Lisaac}}==
<
+ name := SAMPLE;
Line 2,196 ⟶ 2,303:
sample := SAMPLE.clone;
sample.some_method;
);</
=={{header|Logtalk}}==
The definition of classes in Logtalk require the use of meta-classes. In order to avoid infinite regression, we use here the usual trick of making a class an instance of itself. The class meta-class holds the constructor method, allowing the class to accept a message for creating a new instance. The class itself defines the methods and variables of its instances.
<
instantiates(metaclass)).
Line 2,219 ⟶ 2,325:
:- private(state/1).
:- end_object.</
A simple usage example after compiling and loading the above code:
<
Instance = o1
yes
Line 2,227 ⟶ 2,333:
| ?- o1::method(Value).
Value = 1
yes</
=={{header|Lua}}==
Classes in Lua are implemented with metatables. This doesn't implement a full system, but it gets the basic idea:
<
__index = function(z,i) return myclass[i] end, --this makes class variables a possibility
setvar = function(z, n) z.var = n end
Line 2,244 ⟶ 2,349:
instance:setvar(6)
print(instance.var) -->6</
=={{header|M2000 Interpreter}}==
<syntaxhighlight lang="m2000 interpreter">
Class zz {
module bb {
Line 2,351 ⟶ 2,455:
A(3)=zz()
A(3).bb
Report {
there is no super like java super in M2000 when we use inheritance through classes
see Superclass (example SUP) which is something differnent
}
class Shape {
private:
super.X, super.Y
Function super.toString$(a=10) {
="Shape(" + str$(.super.X,"") + ", " + str$(.super.Y,"") + ")"
}
public:
Module final setPosition (px, py) {
.super.X <= px
.super.Y <= py
}
Function toString$() {
=.super.toString$()
}
}
class MoveShape {
Module MoveRelative(xr, yr) {
.super.X+=xr
.super.Y+=yr
}
}
class Circle as MoveShape as Shape {
private:
radius
public:
Module setRadius (r) {
.radius <= r
}
Function toString$() {
= .super.toString$() + ": Circle(" + str$(.radius,"") + ")"
}
}
class Rectangle as MoveShape as Shape {
private:
height, width
public:
Module MoveLeftSide (p as *Rectangle) {
\\ for same type objects private members are like public
for This, p {
.super.X<=..super.X+..width
.super.Y<=..super.Y
}
}
module setDimensions (h,w) {
.height <= h
.width <= w
}
Function toString$() {
= .super.toString$() + ": Rectangle(" + str$(.height,"") + " x " + str$(.width,"") + ")"
}
}
c =Circle()
r = Rectangle()
r.setPosition 1, 2
r.setDimensions 50, 50
c.setPosition 3, 4
c.setRadius 10
Print r.tostring$()
Print c.tostring$()
r.MoveRelative 100,100
c.MoveRelative -50,-50
Print r.tostring$()
Print c.tostring$()
Report {
wokring with pointers like in c++
pointers in M2000 are objects, so null pointer (pc->0&) isn't a zero, but an empty Group (object)
}
pc->circle()
pr->rectangle()
pr=>setPosition 1, 2
pr=>setDimensions 50, 50
pc=>setPosition 3, 4
pc=>setRadius 10
Print pr=>tostring$()
Print pc=>tostring$()
\\ we can open up to ten objects (from one to ten dots, normaly one to three)
\\ if we use nestef for object {} also we have up to ten objects in total
\\ every for object {} is an area for temporary definitions, after exit from brackets
\\ any new definition erased.
For pr, pc {
.MoveRelative 100,100
..MoveRelative -50,-50
Print .tostring$()
Print ..tostring$()
}
pr2->rectangle()
pr2=>SetDimensions 30, 30
pr2=>MoveLeftSide pr
Print pr2=>toString$()
</syntaxhighlight>
=={{header|MATLAB}}==
There are two ways to declare classes in MATLAB: with a classdef or without it. First you must create a folder named after the class type that you are defining with an "@" appended to the front, e.g. "@LinkedList", in your MATLAB root directory. In this folder you put all of the class methods and, if you have it, the classdef. Any MATLAB buitlin methods can be overloaded for any class you define. For example, if you want to overload the "+" operator, create an .m file in the class folder named "plus.m". Furthermore, all class variables have to be generated in the class constructor if a classdef is not going to be used.
Line 2,362 ⟶ 2,564:
GenericClass.m: Class Constructor
<
if isempty(varargin) %No input arguments
Line 2,373 ⟶ 2,575:
GenericClassInstance = class(GenericClassInstance,'GenericClass');
end</
getValue.m:
<
function value = getValue(GenericClassInstance)
value = GenericClassInstance.classVariable;
end</
setValue.m:
<
function GenericClassInstance = setValue(GenericClassInstance,newValue)
GenericClassInstance.classVariable = newValue;
end</
display.m: This method overloads the "disp()" command
<
disp(sprintf('%f',GenericClassInstance.classVariable));
end</
Sample Usage:
<
3.000000
>> myClass = setValue(myClass,pi)
Line 2,398 ⟶ 2,600:
ans =
3.141592653589793</
@GenericClass2
GenericClass2.m: This is the classdef, it includes the class constructor as well as class variables and methods.
<
properties
Line 2,429 ⟶ 2,631:
end %methods
end</
getValue.m:
<
function value = getValue(GenericClassInstance)
value = GenericClassInstance.classVariable;
end</
display.m: This method overloads the "disp()" command
<
disp(sprintf('%f',GenericClassInstance.classVariable));
end</
Sample Usage:
<
3.000000
>> setValue(myClass,pi)
Line 2,448 ⟶ 2,650:
ans =
3.141592653589793</
=={{header|MiniScript}}==
<
Weapon = { "name": "Sword", "damage": 3 }
Weapon.slice = function()
Line 2,462 ⟶ 2,662:
wep.name = "Lance"
wep.slice</
=={{header|MiniZinc}}==
MiniZinc does not have classes, but they can be simulated using functions with constraints:
<syntaxhighlight lang="minizinc">% define a Rectangle "class"
var int: Rectangle(var int: width, var int: height) =
let {
var int: this;
constraint Type(this) = Rectangle; %define the "type" of the instance
%define some "instance methods"
constraint area(this) = width*height;
constraint width(this) = width;
constraint height(this) = height;
} in this;
%this enum should contain the list of class names
enum Type = {Rectangle};
function var Type: Type(var int:a);
%declare the "instance methods"
function var int: area(var int:this) = let {var int:result;} in result;
function var int: height(var int:a) = let {var int:result;} in result;
function var int: width(var int:a) = let {var int:result;} in result;
%create an instance of the "class"
var int: rect = Rectangle(3,4);
var int: area1 = area(rect);
solve satisfy;
% print the area of the rectangle
output [show(area1),"\n"];</syntaxhighlight>
=={{header|Nanoquery}}==
<
declare name
Line 2,482 ⟶ 2,711:
// display the name value
println inst.getName()</
=={{header|Nemerle}}==
<
{
public this() { } // the constructor in Nemerle is always named 'this'
Line 2,503 ⟶ 2,731:
def myInstance = MyClass(); // no 'new' keyword needed
myInstance.MyVariable = 42; // set MyVariable
System.Console.WriteLine($"My variable is $(myInstance.MyVariable)") // get MyVariable</
=={{header|NetRexx}}==
<
properties private -- class scope
Line 2,536 ⟶ 2,763:
method test(s=boolean)
mies = 3
say s mies</
=={{header|Nim}}==
{{trans|Python}}
<
name: int
Line 2,567 ⟶ 2,792:
echo person1.name, " ", person1.gender, " ", person1.age # Jane female 50
var person2 = initMyOtherClass("John", male, 23)
echo person2.name, " ", person2.gender, " ", person2.age # John male 23</
=={{header|Oberon-2}}==
{{works with|OO2C|2.1.11}}
<
TYPE
Line 2,592 ⟶ 2,816:
END Increment;
END M.</
Exported procedures are marked with an asterisk (*). There is nothing special about the constructor New, it is just a function that returns a new object of type T. The name of the method receiver can also be chosen freely. INC is a predeclared procedure that increments its argument.
=={{header|Objeck}}==
<
class MyClass {
@var : Int;
Line 2,629 ⟶ 2,852:
}
}
}</
=={{header|Object Pascal}}==
{{works with|Turbo Pascal|6.0}}
:''Note: This is not part of standard Pascal, but Turbo Pascal specific''
<
MyClass = object
variable: integer;
Line 2,669 ⟶ 2,891:
instance.done;
dispose(pInstance, done);
end;</
=={{header|Objective-C}}==
{{works with|GCC}}
Line 2,676 ⟶ 2,897:
{{works with|GNUstep}}
Interface:
<
static int myClassVariable = 0;
Line 2,686 ⟶ 2,907:
- (int)variable; // Typical accessor - you should use the same name as the variable
@end</
Implementation:
<
// Was not declared because init is defined in NSObject
Line 2,706 ⟶ 2,927:
}
@end</
Using the class:
<
MyClass *mc = [[MyClass alloc] init];
// Sending a message
[mc variable];</
=={{header|OCaml}}==
<
object (self)
val mutable variable = 0
method some_method = variable <- 1
end</
Using the class:
Line 2,730 ⟶ 2,950:
- : unit = ()
</pre>
=={{header|Oforth}}==
Class creation
<
MyClass method: initialize(v) v := att ;</
Usage : instantiation
<
=={{header|Ol}}==
Otus Lisp have no classes support.
=={{header|ooRexx}}==
ooRexx classes are defined using directives. Only methods of the class can directly access instance variables to avoid fragile base class
problems, methods can only access variables at the level of the class hierarchy they are defined. ::attribute directives create setter and getter methods that allow instance variables to be accessed in other contexts.
<
c = .circle~new
Line 2,774 ⟶ 2,991:
::method print
expose radius
say "A circle of radius" radius "centered at location ("||self~x","self~y")"</
=={{header|OxygenBasic}}==
<
Class MyObject
static int count 'statics are private
int a,b,c
method
s=
a=pa : b=pb : c=pc
count++
end method
method
del s
end method
method
return a+b+c
end method
end class
new MyObject v(2,4,6)
print "Sum: " v.sum
del v
</syntaxhighlight>
=={{header|Oz}}==
Classes are created at runtime and first-class values.
<
class Something
feat
Line 2,884 ⟶ 3,050:
%% call a method
{Object increase}</
=={{header|Pascal}}==
See [[Classes#Delphi | Delphi]]
=={{header|Perl}}==
{{works with|Perl|5.8.6}}
The implementation (there are no declarations) of a class using the [http://search.cpan.org/perldoc?perlobj standard] object system:
<
# a class is a package (i.e. a namespace) with methods in it
package MyClass;
Line 2,910 ⟶ 3,074:
$self->{variable} = 1;
}
}</
This is the same using the [http://search.cpan.org/perldoc?Moose Moose] object system:
<
package MyClass;
use Moose;
Line 2,924 ⟶ 3,088:
$self->variable(1);
}
}</
This is the same class using the [http://search.cpan.org/perldoc?MooseX::Declare MooseX::Declare] extention:
<
class MyClass {
has 'variable' => (is => 'rw', default => 0);
Line 2,933 ⟶ 3,097:
$self->variable(1);
}
}</
All of the above classes can be used the same way:
<
$instance->some_method; # invoke method on object instance
# instance deallocates when the last reference falls out of scope</
=={{header|Phix}}==
{{libheader|Phix/Class}}
<!--<syntaxhighlight lang="phix">(notonline)-->
<span style="color: #008080;">without</span> <span style="color: #008080;">js</span> <span style="color: #000080;font-style:italic;">-- (else cffi namespaces error, classes not supported by pwa/p2js anyway)</span>
<span style="color: #7060A8;">requires</span> <span style="color: #0000FF;">(</span><span style="color: #008000;">"1.0.2"</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- (free up the temp used in the v.show() call)</span>
<span style="color: #008080;">class</span> <span style="color: #000000;">five</span> <span style="color: #008080;">nullable</span>
<span style="color: #008080;">private</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">n</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">3</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">get_n</span><span style="color: #0000FF;">()</span>
<span style="color: #008080;">return</span> <span style="color: #000000;">n</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #008080;">procedure</span> <span style="color: #000000;">set_n</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">this</span><span style="color: #0000FF;">.</span><span style="color: #000000;">n</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">n</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
<span style="color: #008080;">procedure</span> <span style="color: #000000;">show</span><span style="color: #0000FF;">()</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"show: n is %d\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">n</span><span style="color: #0000FF;">})</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">five</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">n</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">4</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"constructor five(%d) called\n"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">n</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">this</span><span style="color: #0000FF;">.</span><span style="color: #000000;">n</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">n</span>
<span style="color: #008080;">return</span> <span style="color: #7060A8;">this</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #008080;">procedure</span> <span style="color: #0000FF;">~</span><span style="color: #000000;">five</span><span style="color: #0000FF;">()</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"destructor ~five(%d) called\n"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">n</span><span style="color: #0000FF;">)</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;">five</span> <span style="color: #000000;">v</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">new</span><span style="color: #0000FF;">({</span><span style="color: #000000;">5</span><span style="color: #0000FF;">})</span>
<span style="color: #7060A8;">assert</span><span style="color: #0000FF;">(</span><span style="color: #000000;">v</span><span style="color: #0000FF;">.</span><span style="color: #000000;">n</span><span style="color: #0000FF;">=</span><span style="color: #000000;">5</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">v</span><span style="color: #0000FF;">.</span><span style="color: #000000;">n</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">6</span>
<span style="color: #000000;">v</span><span style="color: #0000FF;">.</span><span style="color: #000000;">show</span><span style="color: #0000FF;">()</span>
<span style="color: #000000;">v</span><span style="color: #0000FF;">=</span><span style="color: #004600;">NULL</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
constructor five(5) called
show: n is
destructor ~five(6) called
</pre>
Obviously when n is public then neither get_n() nor set_n() is needed.<br>
When there is no constructor method, new() args get assigned in order, so here n would still become 5.
=={{header|PHL}}==
<
extern printf;
Line 3,023 ⟶ 3,168:
printf("obj.myField: %i\n", obj::get_myField);
return 0;
]</
=={{header|PHP}}==
<
public static $classVar;
public $instanceVar; // can also initialize it here
Line 3,037 ⟶ 3,181:
}
}
$myObj = new MyClass();</
<!-- TODO ;; 2008-01-24 07:35 fill this in when i get a few spare moments
/*
Line 3,057 ⟶ 3,201:
*/
-->
=={{header|PicoLisp}}==
<
# dx dy
Line 3,066 ⟶ 3,209:
(println # Create a rectangle, and print its area
(area> (new '(+Rectangle) 'dx 3 'dy 4)) )</
=={{header|Pop11}}==
Object system is implemented as a library, so we must first load it.
<
define :class MyClass;
slot value = 1;
enddefine;</
Defining class MyClass automatically defines two constructors, newMyClass and consMyClass and slot (instance variable) accessors, so we can immediately start using our new class:
<
lvars instance1 = newMyClass();
;;; Construct instance with explicitely given slot values
Line 3,089 ⟶ 3,231:
12 -> value(instance1);
;;; Print it
value(instance1) =></
We can add methods at any time (even after creating an instance):
<
0 -> value(x);
enddefine;
reset(instance1);
;;; Print it
instance1 =></
=={{header|Portugol}}==
{{trans|D}}
<syntaxhighlight lang="portugol">
programa {
inclua biblioteca Objetos --> obj
// "constructor" returns address of object
funcao inteiro my_class_new(inteiro value) {
inteiro this = obj.criar_objeto()
obj.atribuir_propriedade(this, "variable", value) // add property to object
retorne this
}
// "method" takes the address returned by criar_objeto
funcao my_class_some_method(inteiro this) {
my_class_set_variable(this, 1)
}
// "setter"
funcao my_class_set_variable(inteiro this, inteiro value) {
obj.atribuir_propriedade(this, "variable", value)
}
// "getter"
funcao inteiro my_class_get_variable(inteiro this) {
retorne obj.obter_propriedade_tipo_inteiro(this, "variable")
}
funcao inicio() {
inteiro this = my_class_new(0)
escreva("variable = ", my_class_get_variable(this), "\n")
my_class_some_method(this)
escreva("variable = ", my_class_get_variable(this), "\n")
my_class_set_variable(this, 99)
escreva("variable = ", my_class_get_variable(this), "\n")
obj.liberar_objeto(this)
}
}
</syntaxhighlight>
=={{header|PowerShell}}==
{{works with|PowerShell|2}}
Prior to PowerShell 5, native class definition was not supported in PowerShell. But you could define classes in PowerShell using C#, JavaScript, or VisualBasic.
<
Add-Type -Language CSharp -TypeDefinition @'
public class MyClass
Line 3,132 ⟶ 3,319:
}
'@
</syntaxhighlight>
{{works with|PowerShell|5}}
<br>
<b>Basic syntax</b>
<syntaxhighlight lang="powershell">
class MyClass
{
Line 3,154 ⟶ 3,341:
}
}
</syntaxhighlight>
<b>Example class</b>
<syntaxhighlight lang="powershell">
class Banana
{
Line 3,190 ⟶ 3,377:
}
}
</syntaxhighlight>
<b>Using the example class</b>
<syntaxhighlight lang="powershell">
$MyBanana = [banana]::New()
$YourBanana = [banana]::New( $True )
Line 3,198 ⟶ 3,385:
If ( -not $MyBanana.IsReadyToEat() -and $YourBanana.IsReadyToEat() )
{ $MySecondBanana = $YourBanana }
</syntaxhighlight>
=={{header|Processing}}==
<
{
// instance variable:
Line 3,217 ⟶ 3,403:
// the method has no argument or local variable called "name", so we can omit the "this"
}
}</
How to use it:
<
ProgrammingLanguage processing = new ProgrammingLanguage("Processing");
// call the method:
processing.sayHello();</
{{out}}
<pre>Hello from the programming language Processing</pre>
=={{header|PureBasic}}==
===Generic version===
<
Get.i()
Set(Value.i)
Line 3,284 ⟶ 3,469:
*Foo\Set(341)
MessageRequester("Info", "Foo = " + *Foo\ToString() )
*Foo\Destroy()</
===Simple OOP Version===
Using the open-source precompiler [http://www.development-lounge.de/viewtopic.php?t=5915 SimpleOOP].
<
Private Value.i
Line 3,317 ⟶ 3,502:
*Demo.foo = NewObject.foo()
*Demo\Set(4)
MessageRequester("Info", "Val= " + *Demo\ToString())</
=={{header|Python}}==
<
name2 = 2 # Class attribute
Line 3,357 ⟶ 3,541:
print person1.age # Raises AttributeError exception!
person2 = MyOtherClass("Jane", "Female", 23)
print person2.name, person2.gender, person2.age # "Jane Female 23"</
Python allows for very flexible argument passing including normal named parameters, defaulted/optional named parameters, up to one "varargs" tuple, and any number of keywords arguments (which are all passed in the form of a single dictionary (associative array), and any non-ambiguous combination of these). All types of argument passing for functions can also be used for object instantiation/initialization (passed to the special ''__init__()'' method) as shown.
Line 3,363 ⟶ 3,547:
New-style classes inherit from "object" or any descendant of the "object" class:
<
...</
These "new-style" classes support some features which were unavailable in "classic classes". New features include a ''__new__()'' with lower level control over object instantiation, metaclass support, static methods, class methods, "properties" (managed attributes) and "slots" (attribute restrictions).
=={{header|R}}==
R has (at least) 5 different object oriented systems. S3 and S4 correspond to different versions of the S language, from which R was derived. See, for example, [http://www.r-project.org/conferences/useR-2004/Keynotes/Leisch.pdf this presentation by Freidrich Leisch] for a more thorough introduction to S3 and S4 classes. Both these class systems are in use, and ship with the standard R distribution. The [http://www.omegahat.org/RSOOP/ OOP], [http://cran.r-project.org/web/packages/R.oo/index.html R.oo] and [http://cran.r-project.org/web/packages/proto/index.html proto] packages provide other systems.
Line 3,373 ⟶ 3,556:
===S3===
S3 provides a very simple class system designed to be easily used interactively.
<
circS3 <- list(radius=5.5, centre=c(3, 4.2))
class(circS3) <- "circle"
Line 3,385 ⟶ 3,568:
type="l", ...)
}
plot(circS3)</
===S4===
S4 is a more formal class system that provides validity checking and a way to define different methods for different input signatures.
<
representation(
radius="numeric",
Line 3,412 ⟶ 3,595:
type="l", ...)
})
plot(circS4)</
=={{header|Racket}}==
Racket programs heavily use functions, but classes and objects are available as well:
<
#lang racket
Line 3,434 ⟶ 3,616:
;; constructing an instance
(new fish% [size 50])
</syntaxhighlight>
=={{header|Raku}}==
(formerly Perl 6)
{{works with|Rakudo|2015.12}}
<syntaxhighlight lang="raku" line>class Camel { has Int $.humps = 1; }
my Camel $a .= new;
say $a.humps; # Automatically generated accessor method.
my Camel $b .= new: humps => 2;
say $b.humps;</syntaxhighlight>
A more complex example:
<syntaxhighlight lang="raku" line>class Butterfly {
has Int $!age; # With the ! twigil, no public accessor method is generated
has Str $.name;
has Str $.color;
has Bool $.wings;
submethod BUILD(:$!name = 'Camelia', :$!age = 2, :$!color = 'pink') {
# BUILD is called by bless. Its primary use is to to control
# object initialization.
$!wings = $!age > 1;
}
method flap() {
say ($.wings
?? 'Watch out for that hurricane!'
!! 'No wings to flap.');
}
}
my Butterfly $a .= new: age => 5;
say "Name: {$a.name}, Color: {$a.color}";
$a.flap;
my Butterfly $b .= new(name => 'Osgood', age => 4);
say "Name: {$b.name}, Color: {$b.color}";
$b.flap;</syntaxhighlight>
=={{header|RapidQ}}==
<
Variable AS INTEGER
Line 3,453 ⟶ 3,673:
' invoke the method
instance.someMethod</
=={{header|Raven}}==
Build classes:
<
'I am Alpha.' as greeting
define say_hello
Line 3,463 ⟶ 3,682:
class Beta extend Alpha
'I am Beta!' as greeting</
Execute classes to create objects:
<
Beta as beta</
Call methods:
<
beta.say_hello</
Result:
<
I am Beta!</
=={{header|REALbasic}}==
This class "contains" a number ('TheNumber'). The Number methods allow read and write access to the number, and provide an example of method overloading as well as use of the "Assigns" keyword.
<syntaxhighlight lang="vb">
Class NumberContainer
Private TheNumber As Integer
Line 3,495 ⟶ 3,713:
End Sub
End Class
</syntaxhighlight>
<syntaxhighlight lang="vb">
Dim num As New NumberContainer(1) ' call the constructor
num.Number = num.Number + 5 ' call both Number methods
</syntaxhighlight>
=={{header|REBOL}}==
<
Title: "Classes"
URL: http://rosettacode.org/wiki/Classes
Line 3,541 ⟶ 3,758:
print "Howdy, Pecos!" pecos/hi
print "Tell us about yourself?" pecos/boast</
{{out}}
Line 3,554 ⟶ 3,771:
[[wp:Pecos_Bill|Context...]]
=={{header|Rhovas}}==
Rhovas has both structs and classes. [https://rhovas.dev/learn/tour/#structs Structs] are used for structured data (e.g. Kotlin data classes or Java records) however have some additional restrictions like fields always being part of the API (see earlier link).
An example of a struct for (<code>Decimal</code>) <code>Vector</code>s. Some notes:
* Fields are often mutable (<code>var</code>) and use mutability permissions to represent immutable structs rather than defining immutable fields directly.
* Methods are defined with a first parameter of <code>this</code>. The type is optional, but can be specified to support more nuanced subtypes as needed (e.g. with generics).
<syntaxhighlight lang="scala">
struct Vector {
var x: Decimal;
var y: Decimal;
func magnitude(this): Decimal {
return Math.sqrt(this.x * this.x + this.y * this.y);
}
}
</syntaxhighlight>
The next step up from structs are classes. [https://rhovas.dev/learn/tour/#classes Classes] support the full range of Object-Oriented capabilities (e.g. encapsulation and inheritance) and are primarily for maintaining invariants.
For example, a hypothetical <code>UnitVector</code> class has an invariant between <code>x</code> and <code>y</code>, requiring a direction with non-zero magnitude. One option is to use a class to maintain that invariant:
* The example below uses immutable fields and validates the invariant in the constructor, but in practice there would be mutation involved.
* <code>require direct.x != 0.0 ...</code> validates preconditions for the direction <code>Vector</code>.
* <code>this { x: ..., y: ... };</code> initializes object fields in a single action to prevent partially constructed instances from being leaked (which would break invariants) and is less restrictive than similar constructors in Kotlin/Java.
<syntaxhighlight lang="scala">
class UnitVector {
val x: Decimal;
val y: Decimal;
init(direction: Vector) {
require direction.x != 0.0 || direction.y != 0.0;
val magnitude = direction.magnitude();
this { x: direction.x / magnitude, y: direction.y / magnitude };
}
}
</syntaxhighlight>
=={{header|Ring}}==
Line 3,559 ⟶ 3,815:
Simple program to define class and create an object
<
New point { x=10 y=20 z=30 print() }
Class Point x y z func print see x + nl + y + nl + z + nl
</syntaxhighlight>
The previous program can be written in another way
<
New point # create new object using the point class
{ # access the new object attributes and methods
Line 3,582 ⟶ 3,838:
y + nl + # print the y attribute
z + nl # print the z attribute
</syntaxhighlight>
=={{header|Ruby}}==
<
def initialize
Line 3,599 ⟶ 3,853:
my_class = MyClass.new #allocates an object and calls it's initialize method, then returns it.
</syntaxhighlight>
=={{header|Rust}}==
<
struct MyClass {
variable: i32, // member variable = instance variable
Line 3,625 ⟶ 3,878:
// Create an instance in the heap.
let mut p_instance = Box
// Invoke method on both istances,
Line 3,633 ⟶ 3,886:
// Both instances are automatically deleted when their scope ends.
}
</syntaxhighlight>
=={{header|Sather}}==
<
readonly attr x:INT; -- give a public getter, not a setter
private attr y:INT; -- no getter, no setter
Line 3,656 ⟶ 3,908:
return y + s;
end;
end;</
<
main is
test ::= #CLASSTEST(1, 2, 3);
Line 3,669 ⟶ 3,921:
#OUT + test.getPrivateY(0) + "\n";
end;
end;</
=={{header|Scala}}==
Scala can be highly object-oriented and if so the task is trivial. In some cases the constructor and instance variables do not have to be explicitly declared; this example shows two ways each to make constructors and instance variables.
<
* creates "val variable1: Int" with that value.
*/
Line 3,696 ⟶ 3,947:
println(m.myMethod) // prints 0
println(n.myMethod) // prints 3
}</
=={{header|Scheme}}==
From [http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-20.html#%_sec_3.1.1 Structure and Interpretation of Computer Programs]
<
(if (>= balance amount)
(begin (set! balance (- balance amount))
Line 3,713 ⟶ 3,963:
(else (error "Unknown request -- MAKE-ACCOUNT"
m))))
dispatch)</
=={{header|Sidef}}==
<
method add(num) {
instance_var += num;
Line 3,724 ⟶ 3,973:
var obj = MyClass(3); # `instance_var` will be set to 3
obj.add(5); # calls the add() method
say obj.instance_var; # prints the value of `instance_var`: 8</
=={{header|Simula}}==
As the first object-oriented language, Simula introduced both the term <tt>class</tt> and the <tt>object.method(arguments)</tt> syntax that many other languages on this page employ. Notice that the object must be declared using <tt>ref</tt> (reference, i.e. pointer) before it can be instantiated.
<
CLASS MyClass(instanceVariable);
INTEGER instanceVariable;
Line 3,746 ⟶ 3,994:
myObject :- NEW MyClass(5);
myObject.doMyMethod(2)
END</
{{out}}
<pre> 5 + 2 = 7</pre>
=={{header|Slate}}==
Slate objects operate as prototypes with multi-methods:
<
MyPrototype traits addSlot: #classVar.
Line 3,763 ⟶ 4,010:
[
x instanceVar = 1 /\ (x classVar = 3)
].</
=={{header|Smalltalk}}==
<
instanceVariableNames: 'instanceVar'
classVariableNames: 'classVar'
Line 3,780 ⟶ 4,026:
^self instanceVar = 1; classVar = 3 ! !
MyClass new someMethod!</
=={{header|SuperCollider}}==
<syntaxhighlight lang="supercollider">
Line 3,819 ⟶ 4,064:
</syntaxhighlight>
Call it:
<syntaxhighlight lang="supercollider">
SpecialObject.randomizeAll;
a = SpecialObject(8);
a.coordinates;
</syntaxhighlight>
=={{header|Swift}}==
<
// stored property
Line 3,848 ⟶ 4,092:
self.variable = 1
}
}</
Instantiate this class using:
<syntaxhighlight lang
=={{header|Tcl}}==
{{works with|Tcl|8.6}} or {{libheader|TclOO}}
<
oo::class create summation {
variable v
Line 3,875 ⟶ 4,118:
puts "Add $i to get [$sum add $i]"
}
$sum destroy</
=={{header|TIScript}}==
TIScript is [[wp:Prototype-based programming|prototype-based]] and yet it has classes. Object that was created as an instance of one class can be transformed to the instance of another class by changing its obj.prototype field.
<
{
//Constructor function.
Line 3,914 ⟶ 4,156:
stdout.printf("#%d %s $%d %v %v, %v %v", i, car.brand, car.price, car.weight, car.size,
car instanceof Car, car instanceof Truck);
}</
{{out}} from console :
<pre>
Line 3,920 ⟶ 4,162:
#2 Volvo 2000 $30000 2, true true
</pre>
=={{header|Transd}}==
<syntaxhighlight lang="scheme">#lang transd
class Point : {
x: Double(),
y: Double(),
@init: (λ v Vector<Double>() (= x (get v 0)) (= y (get v 1))),
print: (λ (textout "Point(" x "; " y ")\n" ))
}
MainModule: {
v_: [[1.0, 2.0], [3.0, 4.0]],
_start: (λ
// creating an instance of class
(with pt Point([5.0, 6.0])
// calling a class' method
(print pt)
)
// creating several instances using data deserialization
(with v Vector<Point>(v_)
(for p in v do (print p))
) )
}</syntaxhighlight>
{{out}}
<pre>
Point(5; 6)
Point(1; 2)
Point(3; 4)
</pre>
=={{header|TXR}}==
<
cached-area
Line 3,945 ⟶ 4,217:
(:method calc-area (self)
(* self.length self.length)))</
{{out}}
Line 3,967 ⟶ 4,239:
* There must be no whitespace around the dot: <code>(a . b)</code> is the consing dot whereas <code>(a.b)</code> is the syntax <code>((qref a b))</code>.
* Ambiguity with floating-point numbers isn't allowed. For instance, <code>a.b.1</code> elicits an error from the parser (lexical scanner actually).
=={{header|UNIX Shell}}==
{{works with|ksh93}}
ksh93 has "type variables" which essentially declares a class.
<
integer sum
Line 3,989 ⟶ 4,260:
s.add $i
done
print ${s.sum}</
=={{header|Vala}}==
<
// Instance variable
public int variable;
Line 4,014 ⟶ 4,284:
instance.variable = 84;
print("%d\n", instance.variable);
}</
=={{header|VBA}}==
===Defining a class===
Line 4,026 ⟶ 4,295:
This is the contents of a class module "Foo" (like in the Visual Basic .NET example below):
<
Private m_bar As Integer
Line 4,056 ⟶ 4,325:
'Note: instead of using the instance variable m_bar we could refer to the Bar property of this object using the special word "Me":
' MultiplyBar = Me.Bar * x
End Function</
===Using an object===
Objects (e.g. of class Foo) are created and used in "normal" modules.
<
'declare and create separately
Dim f As Foo
Line 4,096 ⟶ 4,365:
'this will trigger one or two "object destroyed" messages
'depending on whether f0 was created...
End Sub</
{{out}}
Line 4,108 ⟶ 4,377:
---object destroyed---
</pre>
=={{header|Visual Basic .NET}}==
===Defining a class===
<
Private m_Bar As Integer
Line 4,139 ⟶ 4,407:
End Function
End Class</
===Using an object===
<
Dim foo1 As Foo
foo1 = New Foo
Line 4,163 ⟶ 4,431:
'Reading/writing properties
Console.WriteLine(foo4.Bar)
foo4.Bar = 1000</
=={{header|Visual FoxPro}}==
Visual FoxPro has a large number of base classes - Session is one of them.
<
LOCAL o1 As MyClass, o2 As MyClass
*!* Instantiate o1
Line 4,196 ⟶ 4,463:
ENDPROC
ENDDEFINE
</syntaxhighlight>
{{out}}
<pre>
Line 4,202 ⟶ 4,469:
Instance 2
</pre>
=={{header|Wren}}==
<syntaxhighlight lang="wren">class Bear {
// Constructs a Bear instance passing it a name
// which is stored in the field _name
// automatically created by Wren.
construct new(name) { _name = name }
// Property to get the name
name { _name }
// Method to make a noise.
makeNoise() { System.print("Growl!") }
}
// Create a new Bear instance and assign a reference to it
// to the variable b.
var b = Bear.new("Bruno")
// Print the bear's name.
System.print("The bear is called %(b.name).")
// Make a noise.
b.makeNoise()</syntaxhighlight>
{{out}}
<pre>
The bear is called Bruno.
Growl!
</pre>
=={{header|X86-64 Assembly}}==
===UASM 2.52===
Details about the UASM class extention can be found [http://www.terraspace.co.uk/uasm252_ext.pdf here].
<syntaxhighlight lang="asm">
option casemap:none
ifndef __SOMECLASS_CLASS__
__SOMECLASS_CLASS__ equ 1
;; Once again, HeapAlloc/Free is REQUIRED by the class extention for windows.
;; Malloc/Free are used by Linux and OSX. So the function prototypes have to
;; be defined somewhere. If you have include files where they're defined, just
;; include them in the usual way and remove the option dllimports.
if @Platform eq 1 ;; Windows 64
;; include windows.inc
;; includelib kernel32.lib
option dllimport:<kernel32>
HeapAlloc proto :qword, :dword, :qword
HeapFree proto :qword, :dword, :qword
ExitProcess proto :dword
GetProcessHeap proto
option dllimport:none
exit equ ExitProcess
elseif @Platform eq 3 ;; Linux 64
;;include libc.inc
malloc proto SYSTEMV :qword
free proto SYSTEMV :qword
exit proto SYSTEMV :dword
endif
printf proto :qword, :VARARG
CLASS someClass
CMETHOD someMethod
ENDMETHODS
var dd ?
ENDCLASS
;; The OS' ABI has an effect on this class extention. That is, the class self pointetr
;; is usually refferenced in the first arg register. So for Windows it would be rcx and
;; Linux would be rdi. So to write code that will assemble on both we use a register
;; that ISN'T used to pass arguments in either ABI(Not sure about OSX's ABI however)
METHOD someClass, Init, <VOIDARG>, <>, a:dword
mov rbx, thisPtr
assume rbx:ptr someClass
mov [rbx].var, a
mov rax, rbx
assume rbx:nothing
ret
ENDMETHOD
METHOD someClass, someMethod, <dword>, <>
mov rbx, thisPtr
assume rbx:ptr someClass
mov eax, [rbx].var
assume rbx:nothing
ret
ENDMETHOD
METHOD someClass, Destroy, <VOIDARG>, <>
ret
ENDMETHOD
endif ;; __CLASS_CLASS_
.code
main proc
local meh:ptr someClass
;; Create a new instance of someClass with an arg of 7
mov meh, _NEW(someClass, 7)
meh->someMethod() ;;Get meh->var value and return it in RAX
invoke printf, CSTR("class->someMethod = %i",10), rax
_DELETE(meh) ;; DIIIIIIIE!
invoke exit, 0 ;; Crashy crashy without it.
ret
main endp
end
</syntaxhighlight>
{{out}}
<pre>
class->someMethod = 7
</pre>
=={{header|XBS}}==
<syntaxhighlight lang="xbs">class Person {
construct=func(self,Name,Age,Gender){
self:Name=Name;
self:Age=Age;
self:Gender=Gender;
}{Name="John",Age=20,Gender="Male"};
ToString=func(self){
send self.Name+" ("+self.Gender+"): Age "+self.Age;
}
}
set John = new Person with [];
log(John::ToString());
set Jane = new Person with ["Jane",20,"Female"]
log(Jane::ToString());</syntaxhighlight>
{{out}}
<pre>
John (Male): Age 20
Jane (Female): Age 20
</pre>
=={{header|XLISP}}==
<
(INSTANCE-VARIABLES NAME YEAR))
Line 4,222 ⟶ 4,620:
(DISPLAY (LISP 'DESCRIBE))
(NEWLINE)</
{{out}}
<pre>(THE PROGRAMMING LANGUAGE LISP WAS CREATED IN 1958)</pre>
=={{header|zkl}}==
<syntaxhighlight lang="zkl">class C{ // define class named "C", no parents or attributes
println("starting construction"); // all code outside functions is wrapped into the constructor
var v; // instance data for this class
fcn init(x) // initializer for this class, calls constructor
{ v = x }
println("ending construction of ",self);
}
c1:=C(5); // create a new instance of C
c2:=c1("hoho"); // create another instance of C
println(C.v," ",c1.v," ",c2.v);</syntaxhighlight>
{{out}}
<pre>
starting construction
ending construction of Class(C)
starting construction
ending construction of Class(C)
Void 5 hoho
</pre>
<syntaxhighlight lang="zkl">C.__constructor(); // run base class constructor for giggles
C.init(456); // initialize base class without creating instance
println(C.v," ",c1.v);</syntaxhighlight>
{{out}}
<pre>
starting construction
ending construction of Class(C)
starting construction
ending construction of Class(C)
456 5
</pre>
=={{header|zonnon}}==
<
module Graphics;
type
Line 4,270 ⟶ 4,697:
writeln("Abs: ":4,p.Abs():3," Ord: ":5,p.Ord():3);
end Main.
</syntaxhighlight>
{{out}}
<pre>
Line 4,276 ⟶ 4,703:
Abs: 12 Ord: 12
</pre>
{{omit from|360 Assembly|not OO}}
{{omit from|6502 Assembly|not OO}}
{{omit from|8051 Assembly|not OO}}
{{omit from|8080 Assembly|not OO}}
{{omit from|8086 Assembly|not OO}}
{{omit from|68000 Assembly|not OO}}
{{omit from|AArch64 Assembly|not OO}}
{{omit from|ARM Assembly|not OO}}
{{omit from|AWK|not OO}}
{{omit from|BASIC|not OO}}
Line 4,318 ⟶ 4,722:
{{omit from|Maxima}}
{{omit from|Metafont}}
{{omit from|MIPS Assembly|not OO}}
{{omit from|Modula-2}}
{{omit from|Octave}}
Line 4,326 ⟶ 4,731:
{{omit from|TI-89 BASIC}}
{{omit from|Vim Script}}
{{omit from|Z80 Assembly|not OO}}
{{omit from|ZX Spectrum Basic|not OO}}
|