Classes: Difference between revisions

[[Category:Object oriented]]

[[Category:Type System]]

[[Category:Encyclopedia]]

 

 

 

* single-dispatch languages are those that allow only one argument or result to control the dispatch. Usually it is the first parameter, often hidden, so that a prefix notation ''x''.''f''() is used instead of mathematical ''f''(''x'').

* multiple-dispatch languages allow many arguments and/or results to control the dispatch.

 

 

 

 

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

{{works with|ALGOL 68|Revision 1 - no extensions to language used}}

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - had to remove calls to ''space'' and even then code generates "Run time fault (aborting): attempt to jump to missing ELSE/OUT clause"

}}

For further details:

* [http://archive.computerhistory.org/resources/text/algol/algol_bulletin/A26/P22.HTM Ross, D.T., "Features Essential for a Workable Algol X," ALGOL Bulletin, No. 26, August 1967, pp. 6-12, and ACM SIGPLAN Notices, Vol.2, No.11, November 1967.]

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

<pre>

John: Male *

</pre>

=={{header|AmigaE}}==

varA, varP

ENDOBJECT

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

END obj

 

=={{header|BASIC}}==

{{works with|QuickBasic|4.5}}

DECLARE SUB MyClassDelete (pthis AS MyClass)

DECLARE SUB MyClassSomeMethod (pthis AS MyClass)

DECLARE SUB MyClassInit (pthis AS MyClass)

 

DIM obj AS MyClass

SUB MyClassSomeMethod (pthis AS MyClass)

pthis.Variable = 1

 

{{works with|gcc|4.0.2}}

{

int variable;

MyClass MyClass_new()

{

pthis->variable = 0;

return pthis;

void MyClass_delete(MyClass* pthis)

{

{

free(*pthis);

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

 

 

 

((radius :initarg :radius

:initform 1.0

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

> (area *c*)

 

 

 

 

 

variable = 1;

}

 

// getter method

}

 

// setter method

}

}

 

 

// invoke the method

 

 

// set the variable using setter method

 

 

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

@@class_var = []

 

}

 

 

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

 

 

 

 

 

 

 

=={{header|Go}}==

 

import "fmt"

 

}

 

}

 

}

 

func main() {

 

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

'''

 

 

<pre>This stuff is flangulating its guts:

I have made mistakes in the past.

and neither do we.

-- President George W. Bush</pre>

=={{header|Haskell}}==

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

 

=={{header|J}}==

'''Class definition:'''

 

exampleMethod=: monad define

)

 

 

'''Instantiation:'''

 

=={{header|Java}}==

 

// instance variable

* The constructor

*/

// creates a new instance

}

* A method

*/

this.variable = 1;

}

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

The reason Car shows as instanceof Truck is because we've overwritten Truck.prototype with Car.prototype. It's probably not the best way to do it, but it suffices for most cases.

 

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

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

{

return self;

}

}

 

 

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

Classes are created at runtime and first-class values.

class Something

feat

 

%% call a method

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

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

Get.i()

Set(Value.i)

*Foo\Set(341)

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

 

 

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

Title: "Classes"

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

]

 

print "Howdy, Pecos!" pecos/hi

 

<pre>Say 'hello', boys:

Tex : Howdy!

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

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

=={{header|Ruby}}==

def initialize

@instance_var = 0

end

end

 

end

 

 

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

*/

}

 

}

 

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

 

 

 

 

 

 

 

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