Classes: Difference between revisions

[[Category:Type System]]

[[Category:Encyclopedia]]

 

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.

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

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

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

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

{{trans|python}}

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>

Jane: Female +23

</pre>

=={{header|AmigaE}}==

varA, varP

ENDOBJECT

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

END obj

=={{header|Arturo}}==

 

 

 

 

 

 

 

 

 

 

 

 

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

 

 

 

 

 

{{works with|BBC BASIC for Windows}}

REM Declare the class:

REM Discard the instance:

 

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

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

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

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

BlackBox Component Builder

 

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

p.y:> 2

</pre>

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

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.

 

 

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.

 

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

class MyClass

{

someMethod()

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

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

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

{{works with|Win32Forth}}

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

24 72

</pre>

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

 

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&mdash;the interface type and the type satisfying the interface&mdash;are distinct.

=={{header|Groovy}}==

A class:

class Stuff {

/** Heare bee anne instance variable declared */

def guts

Stuff(injectedGuts) {

guts = injectedGuts

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

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

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

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

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:

Size: 2

A Volvo Truck drove 40cm</pre>

=={{header|Julia}}==

{{works with|Julia|0.6}}

Multiple dispatch is a core feature of the language.

 

habitat(::Mammal) = "planet Earth"

 

for a in arr

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

 

{{output}}

Habitat of a whale: ocean

Habitat of a wolf: planet Earth</pre>

=={{header|Kotlin}}==

fun treble(): Int = myInt * 3

}

val mc = MyClass(24)

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

 

{{out}}

24, 72

</pre>

=={{header|Lasso}}==

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 {

A(3)=zz()

A(3).bb

 

 

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

 

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

{{works with|Turbo Pascal|6.0}}

:''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|GCC}}

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

- : unit = ()

</pre>

=={{header|Oforth}}==

Class creation

 

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

 

::method print

expose radius

=={{header|OxygenBasic}}==

 

 

 

 

 

end method

 

end method

 

end method

 

end class

 

 

 

=={{header|Oz}}==

Classes are created at runtime and first-class values.

class Something

feat

 

%% call a method

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

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

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

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

 

[[wp:Pecos_Bill|Context...]]

 

=={{header|Ring}}==

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

 

// Create an instance in the heap.

 

// Invoke method on both istances,

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

#2 Volvo 2000 $30000 2, true true

</pre>

 

=={{header|TXR}}==

cached-area

 

 

(:method calc-area (self)

 

{{out}}

* 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

 

s.add $i

done

=={{header|Vala}}==

// Instance variable

public int variable;

instance.variable = 84;

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

=={{header|VBA}}==

===Defining a class===

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

---object destroyed---

</pre>

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

Instance 2

</pre>

 

=={{header|XLISP}}==

(INSTANCE-VARIABLES NAME YEAR))

 

 

(DISPLAY (LISP 'DESCRIBE))

{{out}}

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

=={{header|zonnon}}==

module Graphics;

type

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

end Main.

{{out}}

<pre>

Abs: 12 Ord: 12

</pre>

{{omit from|AWK|not OO}}

{{omit from|BASIC|not OO}}

{{omit from|Maxima}}

{{omit from|Metafont}}

{{omit from|Modula-2}}

{{omit from|Octave}}

{{omit from|TI-89 BASIC}}

{{omit from|Vim Script}}

{{omit from|ZX Spectrum Basic|not OO}}