Classes: Difference between revisions

 

=={{header|11l}}==

Int public_variable // member variable = instance variable

. Int private_variable

F someMethod() // member function = method

.private_variable = 1

 

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

 

=={{header|ActionScript}}==

public class MyClass {

}

}

 

=={{header|Ada}}==

 

A package specification has the following form:

type My_Type is tagged private;

procedure Some_Procedure(Item : out My_Type);

Variable : Integer := -12;

end record;

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

return Temp;

end Set;

The Set function acts as a conversion constructor for My_Type.

 

An instance is typically created outside the package:

 

procedure Main is

Some_Procedure(Foo); -- Foo is doubled

Foo := Set(2007); -- Foo.Variable is set to 2007

 

=={{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)

 

// draw the circle

}

 

=={{header|ALGOL 68}}==

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

);

print (((name OF person2), ": ",

(gender OF person2|(STRING gender):gender|attribute error), " "));

{{out}}

<pre>

 

=={{header|AmigaE}}==

varA, varP

ENDOBJECT

WriteF('\d\n', obj.getP())

END obj

 

=={{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()

 

MsgBox, % "Object created at " this.time " on " this.date

}

 

=={{header|BaCon}}==

This is an '''advanced feature''' to extend the the compiler we can also compile using g++ or clang++ using PRAGMA

 

PRAGMA COMPILER g++

PRAGMA OPTIONS -Wno-write-strings -Wno-pointer-arith -fpermissive

PRINT "Book subject : ", Book1.subject FORMAT "%s%s\n"

PRINT "Book book_id : ", Book1.book_id FORMAT "%s%d\n"

 

 

Now the same but using the c++ "new" command and arrow operators syntax

 

PRAGMA COMPILER g++

PRAGMA OPTIONS -Wno-write-strings -Wno-pointer-arith -fpermissive

PRINT "Book subject : ", Book1->subject FORMAT "%s%s\n"

PRINT "Book book_id : ", Book1->book_id FORMAT "%s%d\n"

 

=={{header|BASIC}}==

{{works with|QuickBasic|4.5}}

DECLARE SUB MyClassSomeMethod (pthis AS MyClass)

DECLARE SUB MyClassInit (pthis AS MyClass)

SUB MyClassSomeMethod (pthis AS MyClass)

pthis.Variable = 1

 

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

REM Declare the class:

REM Discard the instance:

 

=={{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).

 

𝕊 value: # Constructor portion

priv ← value

obj.DispPriv@

obj.ChangePriv 6

 

=={{header|blz}}==

# Constructors can take parameters (that automatically become properties)

constructor Ball(color, radius)

print(red_ball)

# => a red ball with radius 2

 

=={{header|Bracmat}}==

Bracmat has no class-inheritance. Any object can function as a template for creating other objects.

= (x=)

(y=)

& new$(resolution,640,480):?VGA

& new$(resolution,1920,1080):?1080p

{{out}}

<pre>VGA: horizontal 640 vertical 480</pre>

=={{header|C}}==

{{works with|gcc|4.0.2}}

#include <stdlib.h>

 

MyClass obj = MyClass_new();

MyClass_someMethod(obj);

 

=={{header|C sharp|C#}}==

{

public MyClass()

System.Console.WriteLine( "Variable=" + instance.Variable.ToString() );

}

 

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

{{works with|g++|4.0.2}}

{

public:

MyClass* pInstance = new MyClass;

// Instances allocated with new must be explicitly destroyed when not needed any more:

 

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++.

Functions can also be defined inline:

 

{

public:

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}}==

 

defrecord example:

; You can think of this as an interface

(defprotocol Foo (getFoo [this]))

; Create instance and invoke our method to return field value

(-> (Example1. "Hi") .getFoo)

 

=={{header|COBOL}}==

<!-- This took far too long to create and to get to compile. -->

CLASS-ID. my-class INHERITS base.

.

 

=={{header|Coco}}==

# The constructor is defined as a bare function. This

# constructor accepts one argument and automatically assigns it

# Instantiate the class using the 'new' operator.

 

=={{header|CoffeeScript}}==

class Rectangle

# Constructor that accepts one argument

 

# Instantiate the class using the new operator

 

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

((radius :initarg :radius

:initform 1.0

> (defvar *c* (make-instance 'circle :radius 2))

> (area *c*)

 

=={{header|Component Pascal}}==

 

Module that defines a Class

MODULE Point;

IMPORT

END ToString;

END Point.

Module that uses previous class

MODULE DrivePoint;

IMPORT

 

END DrivePoint.

Execute: ^Q DrivePoint.Do<br/>

{{out}}

=={{header|Crystal}}==

{{trans|Ruby}}

def initialize

my_class = MyClass.new

 

=={{header|D}}==

 

class MyClass {

// prints 'variable = 99'

writeln("variable = ", obj.variable);

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

lMyClass.Free;

end;

 

=={{header|DM}}==

Adding elements (procs, variables, classes) to this tree is done by defining the name and such.

 

 

This declares a type "/s" at the root of the tree, which can now be instantiated.

A more complicated example:

 

// Declare the class "/foo"

foo

x.bar = 10 // Assign to the instance variable.

x.baz() // Call "baz" on our instance.

 

This is enough to declare a

 

=={{header|Dragon}}==

func val(){

showln 10+20

}

}

 

=={{header|DWScript}}==

Methods can be implemented inline or out-of-line, this sample illustrates both.

TMyClass = class

private

 

lMyClass.SomeField := 99;

 

=={{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) {

}

return color

 

Example interactive session creating and using it:

 

# value: <color>

 

? red.colorize("apple")

 

=={{header|EchoLisp}}==

(lib 'gloops) ; load oo library

 

(lambda (p w) (printf " From %a (age %d). Dear writer of %a ..." p p.age w.books )))

 

{{Output}}

;; instantiate

(define simone (make-instance Person :name 'simone :age 42)) ;; slots values by name

From 🎩 simon to️ 🚶 albert : ...

From 🎩 simon (age 66). Dear writer of (my-life my-bike) ...

 

=={{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.

class MY_CLASS

end

 

=== Add a Creation Procedure (Constructor) ===

class MY_CLASS

 

 

end

=== Add Multiple Creation Procedures (Constructors) ===

In Eiffel, you may have more than one creation procedure (or "Constructor").

class MY_CLASS

 

 

end

 

=== 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".

class MY_CLASS

 

 

end

 

=={{header|Elena}}==

ELENA 4.x :

class MyClass

// get the variable

console.printLine("Variable=",instance.Variable)

 

=={{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

PRINT(PERIMETROQ)

END PROGRAM

The answers is

100

=={{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

// create an instance and use it

let myObject = new MyClass(42)

 

A somewhat more meaningful example, inspired by the Haskell version:

 

type Shape =

interface Shape with

member x.Perimeter() = 2.0 * width + 2.0 * height

 

=={{header|Factor}}==

M: my-class quux foo>> 20 + ;

C: <my-class> my-class

C: <my-child-class> my-child-class

M: my-child-class foobar 20 >>quux ;

 

=={{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]

Example of a class:

capacity = max_msg * 10

end

 

Instantiation:

 

=={{header|Fancy}}==

read_slot: 'instance_var # creates getter method for @instance_var

@@class_var = []

}

 

 

=={{header|Fantom}}==

{

// an instance variable

c := MyClass { x = 3 } // instantiates the class, sets x to 3

}

 

=={{header|Forth}}==

Declare a class

 

 

int memvar

:m show: ( -- ) ." Memvar = " memvar . ;m

 

 

Allocate a static object

 

Allocate a dynamic object, saving its pointer in a global variable.

 

Call member functions

 

Free a dynamically allocated object

 

 

Example of dynamic allocation and local variable use"

 

New> MyClass to obj

show: obj

1000 set: obj

 

 

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

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

 

:class foo \ begin class foo definition

bar \ 10 30

bar' \ 10 30

 

=={{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

end program rosetta_class

 

 

=={{header|FreeBASIC}}==

 

Type MyClass

Print mc.MyInt, mc.Treble()

Print "Press any key to quit the program"

 

{{out}}

=={{header|GLSL}}==

There are no classes in GLSL, but they can be simulated using structs:

struct Rectangle{

float width;

return (self.width+self.height)*2.0;

}

 

=={{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"

fmt.Println(forTwo)

fmt.Println(forToo)

{{out}}

<pre>

 

This happens when a method is called through an interface. Consider this code in addition to the example above.

 

type happinessTester interface {

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.

=={{header|Groovy}}==

A class:

class Stuff {

/** Heare bee anne instance variable declared */

println "This stuff is flangulating its guts: ${guts}"

}

 

A demonstration:

I have made mistakes in the past.

I have made mistakes in the future.

'''

 

 

{{out}}

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

{- The correct version of apRatio (and hence the correct

implementations of perimeter and area) is chosen based on the type

 

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. -}

{- The value returned by apRatio is determined by the return values

of area and perimeter, which just happen to be defined differently

 

== Icon and {{header|Unicon}} ==

Unicon supports classes.

 

# method definition

write (x2.x)

write (x2.double ()) # call a method

 

=={{header|J}}==

'''Class definition:'''

 

exampleMethod=: monad define

)

 

 

'''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

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:

 

=={{header|JavaScript}}==

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;

alert(cars[i].brand + " " + cars[i].weight + " " + cars[i].size + ", " +

(cars[i] instanceof Car) + " " + (cars[i] instanceof Truck));

The alerts shows us:

<pre>

 

===ES6===

/**

* A few brands of cars

let myTruck = new Truck('Volvo', 2);

console.log(myTruck.formattedStats);

 

Output:

Multiple dispatch is a core feature of the language.

 

habitat(::Mammal) = "planet Earth"

 

for a in arr

println("Habitat of $a: ", habitat(a))

 

{{output}}

 

=={{header|Kotlin}}==

fun treble(): Int = myInt * 3

}

val mc = MyClass(24)

print("${mc.myInt}, ${mc.treble()}")

 

{{out}}

In Lasso, a "class" is termed a "type"

 

define mytype => type {

data

local(x = mytype)

#x->val = '99 Bottles of beer'

 

=={{header|LFE}}==

 

(defmodule simple-object

(export all))

"Get a variable passed when constructing the object."

(funcall (get-method object 'species) object))

 

Usage from the LFE REPL:

> (slurp '"simple-object.lfe")

#(ok simple-object)

> (get-species my-fish)

"Carp"

 

=={{header|Lingo}}==

'''Class definition:'''

-- @desc Class "MyClass"

-- @file parent script "MyClass"

me._myvar = me._myvar * 2

put me._myvar

 

'''Instantiation:'''

foo.doubleAndPrint()

 

=={{header|Lisaac}}==

 

+ name := SAMPLE;

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)).

 

:- private(state/1).

 

A simple usage example after compiling and loading the above code:

Instance = o1

yes

| ?- o1::method(Value).

Value = 1

 

=={{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

instance:setvar(6)

 

 

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

Class zz {

module bb {

Print pr2=>toString$()

 

 

=={{header|MATLAB}}==

 

GenericClass.m: Class Constructor

 

if isempty(varargin) %No input arguments

GenericClassInstance = class(GenericClassInstance,'GenericClass');

getValue.m:

function value = getValue(GenericClassInstance)

value = GenericClassInstance.classVariable;

setValue.m:

function GenericClassInstance = setValue(GenericClassInstance,newValue)

GenericClassInstance.classVariable = newValue;

display.m: This method overloads the "disp()" command

disp(sprintf('%f',GenericClassInstance.classVariable));

 

Sample Usage:

3.000000

>> myClass = setValue(myClass,pi)

ans =

 

 

@GenericClass2

GenericClass2.m: This is the classdef, it includes the class constructor as well as class variables and methods.

properties

end %methods

getValue.m:

function value = getValue(GenericClassInstance)

value = GenericClassInstance.classVariable;

display.m: This method overloads the "disp()" command

disp(sprintf('%f',GenericClassInstance.classVariable));

 

Sample Usage:

3.000000

>> setValue(myClass,pi)

ans =

 

 

=={{header|MiniScript}}==

Weapon = { "name": "Sword", "damage": 3 }

Weapon.slice = function()

wep.name = "Lance"

 

 

=={{header|MiniZinc}}==

MiniZinc does not have classes, but they can be simulated using functions with constraints:

var int: Rectangle(var int: width, var int: height) =

let {

 

% print the area of the rectangle

=={{header|Nanoquery}}==

declare name

// display the name value

 

=={{header|Nemerle}}==

{

public this() { } // the constructor in Nemerle is always named 'this'

def myInstance = MyClass(); // no 'new' keyword needed

myInstance.MyVariable = 42; // set MyVariable

 

=={{header|NetRexx}}==

 

properties private -- class scope

method test(s=boolean)

mies = 3

 

=={{header|Nim}}==

{{trans|Python}}

name: int

 

echo person1.name, " ", person1.gender, " ", person1.age # Jane female 50

var person2 = initMyOtherClass("John", male, 23)

 

=={{header|Oberon-2}}==

{{works with|OO2C|2.1.11}}

 

TYPE

END Increment;

 

 

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;

}

}

 

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

:''Note: This is not part of standard Pascal, but Turbo Pascal specific''

 

MyClass = object

variable: integer;

instance.done;

dispose(pInstance, done);

 

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

{{works with|GNUstep}}

Interface:

static int myClassVariable = 0;

 

- (int)variable; // Typical accessor - you should use the same name as the variable

 

 

Implementation:

 

 

// Was not declared because init is defined in NSObject

}

 

 

Using the class:

 

MyClass *mc = [[MyClass alloc] init];

 

// Sending a message

 

=={{header|OCaml}}==

object (self)

val mutable variable = 0

method some_method = variable <- 1

 

Using the class:

=={{header|Oforth}}==

Class creation

 

Usage : instantiation

 

=={{header|Ol}}==

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

 

::method print

expose radius

 

=={{header|OxygenBasic}}==

 

 

Class MyObject

 

del v

 

=={{header|Oz}}==

Classes are created at runtime and first-class values.

class Something

feat

 

%% call a method

 

=={{header|Pascal}}==

{{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;

$self->{variable} = 1;

}

 

This is the same using the [http://search.cpan.org/perldoc?Moose Moose] object system:

package MyClass;

use Moose;

$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);

$self->variable(1);

}

 

All of the above classes can be used the same way:

 

$instance->some_method; # invoke method on object instance

 

=={{header|Phix}}==

{{libheader|Phix/Class}}

<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: #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>

{{out}}

<pre>

=={{header|PHL}}==

 

 

extern printf;

printf("obj.myField: %i\n", obj::get_myField);

return 0;

 

=={{header|PHP}}==

public static $classVar;

public $instanceVar; // can also initialize it here

}

}

<!-- TODO ;; 2008-01-24 07:35 fill this in when i get a few spare moments

/*

 

=={{header|PicoLisp}}==

# dx dy

 

 

(println # Create a rectangle, and print its area

 

=={{header|Pop11}}==

Object system is implemented as a library, so we must first load it.

define :class MyClass;

slot value = 1;

 

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

12 -> value(instance1);

;;; Print it

 

We can add methods at any time (even after creating an instance):

 

0 -> value(x);

enddefine;

reset(instance1);

;;; Print it

 

=={{header|Portugol}}==

{{trans|D}}

programa {

inclua biblioteca Objetos --> obj

}

 

 

=={{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

}

'@

{{works with|PowerShell|5}}

<br>

<b>Basic syntax</b>

class MyClass

{

}

}

<b>Example class</b>

class Banana

{

}

}

<b>Using the example class</b>

$MyBanana = [banana]::New()

$YourBanana = [banana]::New( $True )

If ( -not $MyBanana.IsReadyToEat() -and $YourBanana.IsReadyToEat() )

{ $MySecondBanana = $YourBanana }

 

=={{header|Processing}}==

{

// instance variable:

// 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:

{{out}}

<pre>Hello from the programming language Processing</pre>

=={{header|PureBasic}}==

===Generic version===

Get.i()

Set(Value.i)

*Foo\Set(341)

MessageRequester("Info", "Foo = " + *Foo\ToString() )

 

===Simple OOP Version===

Using the open-source precompiler [http://www.development-lounge.de/viewtopic.php?t=5915 SimpleOOP].

Private Value.i

*Demo.foo = NewObject.foo()

*Demo\Set(4)

 

=={{header|Python}}==

name2 = 2 # Class attribute

 

print person1.age # Raises AttributeError exception!

person2 = MyOtherClass("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.

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).

===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"

type="l", ...)

}

 

===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",

type="l", ...)

})

 

=={{header|Racket}}==

Racket programs heavily use functions, but classes and objects are available as well:

 

#lang racket

 

;; constructing an instance

(new fish% [size 50])

 

=={{header|Raku}}==

(formerly Perl 6)

{{works with|Rakudo|2015.12}}

 

my Camel $a .= new;

 

my Camel $b .= new: humps => 2;

 

A more complex example:

 

has Int $!age; # With the ! twigil, no public accessor method is generated

has Str $.name;

my Butterfly $b .= new(name => 'Osgood', age => 4);

say "Name: {$b.name}, Color: {$b.color}";

 

=={{header|RapidQ}}==

Variable AS INTEGER

 

 

' invoke the method

 

=={{header|Raven}}==

Build classes:

'I am Alpha.' as greeting

define say_hello

 

class Beta extend Alpha

 

Execute classes to create objects:

 

Call methods:

 

Result:

 

=={{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.

 

Class NumberContainer

Private TheNumber As Integer

End Sub

End Class

 

Dim num As New NumberContainer(1) ' call the constructor

num.Number = num.Number + 5 ' call both Number methods

 

=={{header|REBOL}}==

Title: "Classes"

URL: http://rosettacode.org/wiki/Classes

 

print "Howdy, Pecos!" pecos/hi

 

{{out}}

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

 

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

y + nl + # print the y attribute

z + nl # print the z attribute

 

=={{header|Ruby}}==

def initialize

my_class = MyClass.new #allocates an object and calls it's initialize method, then returns it.

 

=={{header|Rust}}==

struct MyClass {

variable: i32, // member variable = instance variable

// Both instances are automatically deleted when their scope ends.

}

 

=={{header|Sather}}==

readonly attr x:INT; -- give a public getter, not a setter

private attr y:INT; -- no getter, no setter

return y + s;

end;

 

main is

test ::= #CLASSTEST(1, 2, 3);

#OUT + test.getPrivateY(0) + "\n";

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.

*/

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))

(else (error "Unknown request -- MAKE-ACCOUNT"

m))))

 

=={{header|Sidef}}==

method add(num) {

instance_var += num;

var obj = MyClass(3); # `instance_var` will be set to 3

obj.add(5); # calls the add() method

 

=={{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;

myObject :- NEW MyClass(5);

myObject.doMyMethod(2)

{{out}}

<pre> 5 + 2 = 7</pre>

=={{header|Slate}}==

Slate objects operate as prototypes with multi-methods:

MyPrototype traits addSlot: #classVar.

 

[

x instanceVar = 1 /\ (x classVar = 3)

 

=={{header|Smalltalk}}==

instanceVariableNames: 'instanceVar'

classVariableNames: 'classVar'

^self instanceVar = 1; classVar = 3 ! !

 

 

=={{header|SuperCollider}}==

 

 

 

 

 

Call it:

 

SpecialObject.randomizeAll;

a = SpecialObject(8);

a.coordinates;

 

=={{header|Swift}}==

 

// stored property

self.variable = 1

}

Instantiate this class using:

 

=={{header|Tcl}}==

{{works with|Tcl|8.6}} or {{libheader|TclOO}}

oo::class create summation {

variable v

puts "Add $i to get [$sum add $i]"

}

 

=={{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.

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>

 

=={{header|Transd}}==

 

class Point : {

(for p in v do (print p))

) )

{{out}}

<pre>

 

=={{header|TXR}}==

cached-area

 

 

(:method calc-area (self)

 

{{out}}

{{works with|ksh93}}

ksh93 has "type variables" which essentially declares a class.

integer sum

 

s.add $i

done

 

=={{header|Vala}}==

// Instance variable

public int variable;

instance.variable = 84;

print("%d\n", instance.variable);

 

=={{header|VBA}}==

This is the contents of a class module "Foo" (like in the Visual Basic .NET example below):

 

Private m_bar As Integer

 

'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

 

===Using an object===

Objects (e.g. of class Foo) are created and used in "normal" modules.

'declare and create separately

Dim f As Foo

'this will trigger one or two "object destroyed" messages

'depending on whether f0 was created...

 

{{out}}

=={{header|Visual Basic .NET}}==

===Defining a class===

Private m_Bar As Integer

 

End Function

 

 

===Using an object===

Dim foo1 As Foo

foo1 = New Foo

'Reading/writing properties

Console.WriteLine(foo4.Bar)

 

=={{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

ENDPROC

ENDDEFINE

{{out}}

<pre>

 

=={{header|Wren}}==

// Constructs a Bear instance passing it a name

// which is stored in the field _name

System.print("The bear is called %(b.name).")

// Make a noise.

 

{{out}}

===UASM 2.52===

Details about the UASM class extention can be found [http://www.terraspace.co.uk/uasm252_ext.pdf here].

option casemap:none

 

 

end

{{out}}

<pre>

 

=={{header|XBS}}==

construct=func(self,Name,Age,Gender){

self:Name=Name;

log(John::ToString());

set Jane = new Person with ["Jane",20,"Female"]

{{out}}

<pre>

 

=={{header|XLISP}}==

(INSTANCE-VARIABLES NAME YEAR))

 

 

(DISPLAY (LISP 'DESCRIBE))

{{out}}

<pre>(THE PROGRAMMING LANGUAGE LISP WAS CREATED IN 1958)</pre>

 

=={{header|zkl}}==

println("starting construction"); // all code outside functions is wrapped into the constructor

var v; // instance data for this class

c1:=C(5); // create a new instance of C

c2:=c1("hoho"); // create another instance of C

{{out}}

<pre>

Void 5 hoho

</pre>

C.init(456); // initialize base class without creating instance

{{out}}

<pre>

 

=={{header|zonnon}}==

module Graphics;

type

writeln("Abs: ":4,p.Abs():3," Ord: ":5,p.Ord():3);

end Main.

{{out}}

<pre>