Polymorphism: Difference between revisions

 

=={{header|ActionScript}}==

{

public class Point

}

}

public class Circle extends Point

{

}

}

 

=={{header|Ada}}==

This example is constructed using a parent package and a child package. The parent package defines the Point type. The child package defines the Circle type.

type Point is tagged private;

procedure Print(Item : in Point);

Y : Integer := 0;

end record;

 

package body Shapes is

end Create;

 

The following is the child package defining the Circle type.

type Circle is new Point with private;

procedure Print(Item : Circle);

R : Integer := 0;

end record;

 

package body Shapes.Circles is

end Create;

 

The following procedure is an entry point for a program, serving the same purpose as the main function in C.

use Shapes;

 

P.Print;

C.Print;

 

=={{header|Aikido}}==

class Point (protected x=0.0, protected y=0.0) {

public function print {

c.print()

 

 

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

{{works with|ALGOL 68G|Any - tested with release 2.8.win32}}

 

# define the CIRCLE and POINT modes #

PRINT c1; newline( stand out )

 

{{out}}

<pre>

=={{header|Arturo}}==

 

init: [

ensure -> is? :floating this\x

 

print p

 

{{out}}

{{works with|AutoHotkey 1.1}}

AutoHotkey does not support private or protected properties and thus does not need assignment and accessor methods. Assignment and accessor methods, as well as direct assignment and access, are shown. For more information see [http://ahkscript.org/docs/Objects.htm Objects].

MyPoint.Print()

MyCircle := new Circle(4, 7, 9)

this.r := aValue

}

 

=={{header|BASIC}}==

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

{{works with|BBC BASIC for Windows}}

REM Create parent class with void 'doprint' method:

PROC(mycircle.doprint)

PROC_discard(mycircle{})

{{out}}

<pre>

 

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

class Point

{

c.print();

}

 

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

#include <cstdlib>

 

 

return EXIT_SUCCESS;

 

'''Pattern:''' [[CRTP|Curiously Recurring Template Pattern]]

 

#include <cstdlib>

 

delete c;

return 0;

 

=={{header|Ceylon}}==

consolePrint = print

}

}

}

 

=={{header|Clojure}}==

Clojure 1.2.

 

(print-it [this] "Prints out the Printable."))

(defn create-circle

"Redundant consturctor function."

 

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

((x :initarg :x :initform 0 :accessor x)

(y :initarg :y :initform 0 :accessor y)))

(c (make-instance 'circle :radius 5)))

(print-shape p)

 

=={{header|D}}==

 

class Point {

writeln(p);

writeln(c);

 

=={{header|Delphi}}==

{ TPoint }

 

begin

ShowMessage('MyPoint');

 

MyPoint: TMyPoint;

Circle: TCircle;

FreeAndNil(MyPoint);

end;

 

=={{header|E}}==

def point implements pbc {

to __printOn(out) { out.print(`<point $x,$y>`) }

}

return circle

 

(It is unidiomatic to have mutation operations on an object of this sort in E, so this example has variation operations instead. __optUncall is used for serialization, and is the closest analogue to a copy constructor. E does not have destructors, but only post-mortem finalizers (which are registered after the object is created). The "extends" is only implementation inheritance; it is not necessary to enable polymorphism.)

 

def c := makeCircle(1, 1, 2)

println(p)

 

=={{header|EchoLisp}}==

(struct Point ((real:x 0) (real:y 0)))

(struct Circle ((real:x 0) (real:y 0) (real:r 1)))

(print (Circle 0 0 10))

→ ⭕️ center:[0 0] radius:10 diameter:62.83185307179586

 

=={{header|Eiffel}}==

 

POINT

inherit

Result := "Point: x = " + x.out + " y = " + y.out

end

 

 

CIRCLE

 

non_negative_radius: r >= 0

 

 

 

APPLICATION

 

end

 

 

{{out}}

Solution of this problem in Ela is similar to Haskell, as soon as Ela shares with Haskell the same features - namely, classes (typeclasses) and algebraic types.

 

instance Show Point where

circleZ = Circle 0 0

 

Class Show is defined in prelude and is effectively an abstraction for all "printable" entities.

Normally, algebraic types are analyzed using pattern matching, however, it is possible to provide a support for an "accessor style" approach by providing an instance for class Name (which is also defined in prelude). With this instance it is possible to write code like so:

 

 

=={{header|Elena}}==

ELENA 5.0 :

class Point

p.print();

c.print()

{{out}}

<pre>

Due to the use of optional parameters, we only need one constructor for every class. No accessors are necessary because we use public read-only properties. (Mutable properties are possible, too, but should be avoided in idiomatic code.)

 

abstract member Print : unit -> unit

 

interface Printable with

member t.Print() =

 

=={{header|Factor}}==

 

GENERIC: print ( shape -- )

C: <circle> circle

 

 

=={{header|Forth}}==

{{works with|4tH|3.62.0}}

There are numerous, mutually incompatible object oriented frameworks for Forth. This one works with the FOOS preprocessor extension of [[4tH]]. Variadic functions in Forth are usually implemented by passing the number of parameters. Since it is highly unlikely that objects are allocated that low in memory it works. Note that X, Y and Z are passed in reverse order, which is quite common for any Forth program.

include 4pp/lib/foos.4pp

 

Circle2 => print

Circle1 new Circle Circle3

 

 

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

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

 

:class point

.. c1.radius ? \ print just radius

p1 get .. c1.center put \ change just center using a point

 

=={{header|Fortran}}==

Fortran provides OO features with the type mechanism. This example works with the Intel 11.1.069 compiler.

module geom

 

end program inh

 

 

=={{header|Go}}==

 

import "fmt"

}

 

 

=={{header|Golo}}==

----

This module demonstrates Golo's version of polymorphism.

shape: print()

}

 

=={{header|Groovy}}==

@TupleConstructor(force = true)

@ToString(includeNames = true)

void print() { println toString() }

Number r

Test Code:

def c = new Circle(x: 4, y: 3, r: 5)

 

v2.print()

assert v1 == v2

{{out}}

<pre>Verifying Point(x:3, y:4) == Point(x:3, y:4)

Polymorphism is achieved through the type class Show

 

instance Show Point where

show (Point x y) = "Point at "++(show x)++","++(show y)

 

--Constructor that sets x and r to 0

 

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

There is no destructor, as Unicon manages object destruction itself. The copy constructor is emulated by a method. Notice the 'initially' clauses. These act like constructors, in that they accept input parameters during instance construction. These parameters are null if not used, and so the initial field values are set to 0 if the entered value is null (tested using the '/' symbol).

 

# make a new copy of this instance

method copy ()

c4.print ()

end

 

=={{header|Inform 7}}==

Accessors are not needed since property values are public. Constructors and destructors are not needed since objects are statically allocated and initialized.

 

 

A point is a kind of thing.

print the origin;

print the circle of power;

 

=={{header|J}}==

 

create=: monad define

'X Y'=:2{.y

smoutput 'Point ',":X,Y

)

 

coinsert 'Point'

create=: monad define

print=: monad define

smoutput 'Circle ',":X,Y,R

 

=={{header|Java}}==

 

protected int x, y;

public Point() { this(0); }

c.print();

}

 

=={{header|JavaScript}}==

* var p = new Point(x,y);

* var p = new Point(a_point);

var out = "Circle(" + this.x + "," + this.y + "," + this.r + ")";

print(out);

 

=={{header|jq}}==

 

def Point(x;y): {"type": "Point", "x": x, "y": y};

def Point(x): Point(x;0);

else empty

end;

 

In practice, it's unlikely one would want to write accessors, as .x will retrieve "x", etc; similar remarks apply to setters (.x = VALUE). `.` will copy, and `empty` could serve as a kind of destructor, in that `Point(0;0) | empty` produces the empty stream.

For the sake of illustration, one could define a polymorphic "setter" as follows:

 

# keyname should be (or evaluate to) a string

def set(keyname; value):

else error("set: invalid type: \(.)")

end;

Example:

Circle(0;1;2) | .x = 1 | print

 

=={{header|Julia}}==

 

{{works with|Julia|0.6}}

x::Float64

y::Float64

setr(c::Circle, r) = (c.r = r)

 

 

=={{header|Kotlin}}==

 

In the JVM version of Kotlin, it is possible to declare a destructor in the guise of a 'finalize' method though there is no guarantee that this will actually be called by the garbage collector (or, if it is called, when this will be) and consequently many programmers feel it is more trouble than its worth.

 

open class Point(var x: Int, var y: Int) {

c.print() // change radius

/* note that finalizers for p and c are not called */

 

{{out}}

=={{header|Lua}}==

Lua does not have a standard definition of objects or classes, so a basic and typical protoctype-based OOP model will be used. In Lua all objects are tables, and through the use of metatables, polymorphism can be achieved in many ways, this is only one of them.

local Point = {x = 0, y = 0}

 

function Circle:copy()

return Circle:new{x = self.x, y = self.y, r = self.r}

 

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

In following examples there is a block for temporary objects. We make a MM as a group, and at the exit of the block, group erased, so next time we make a new one.

Syntax:

\\ block For This {}, or For object [, object2] { }, where object is a group, or a pointer to group, or an item from an array contains a group

\\ This is "this context".

\\ can be nested, but if we use object then we can use dots to access members of it. If we use a second one then we have to use double dots (..x for second object, for access to x member)

}

 

 

 

Class PointA {

Property x=0~

rA.Print

 

 

Changes for PointA, we use variables, for Circle R has a limit of 1000. We use Stack object, and Inventory for copies of named groups, they changed to float groups.

Class PointA {

X=0~, Y=0~

NN(3).Print

 

 

=={{header|NetRexx}}==

'''Note:''' Based on default values in method prototypes, NetRexx will automatically generate intermediate constructors and methods, thus ensuring that none are omitted.

 

options replace format comments java crossref savelog symbols binary

Rexx(getR()).format(null, 3)')'

return str

{{out}}

<pre>

 

Similar to the Python solution:

Point = object

x, y: float

 

c1.center.x = 12

{{out}}

<pre>p1: (x: 0.0, y: 0.0)

 

=={{header|Objeck}}==

bundle Default {

class Point {

}

}

 

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

 

@interface RCPoint : NSObject {

}

return 0;

 

=={{header|OCaml}}==

object (self)

val mutable x = x

c#set_x 10.0;

print c;

 

=={{header|Oforth}}==

 

 

Point method: initialize(x, y) x := x y := y ;

Point method: _x @x ;

Circle method: << "(" << @x << ", " << @y << ", " << @r << ")" << ;

 

 

Usage :

| p c |

Point new(3, 4) ->p

c println

System.Out "Attributes of this circle are : " << c _x << ", " << c _y << " and " << c _r << cr

 

{{out}}

ooRexx supports traditional class-based polymorphism. The polymorphic methods can be part of the main class sequence or brought in using mixins for multiple inheritance situations. Here is a simple example using point and circle classes in a hierarchy.

 

p = .point~new(3,2)

c = .circle~new(,2,6)

say "A circle of radius" radius "centered at location ("||self~x","self~y")"

 

{{out}}

<pre>

Method binding in ooRexx is late and dynamic. In many situations, polymorphism can be achieved merely by providing an expected method. It is not necessary for an object to be of a particular class hierarchy. In the example below, both point and circle implement a print method, but there is no class relationship between these classes other than what they inherit from the object class.

 

p = .point~new(3,2)

c = .circle~new(,2,6)

say "A circle of radius" radius "centered at location ("||x","y")"

 

{{out}}

<pre>

 

A compact format for the methods is used to improve layout.

type tpoint float xx,yy

type tcircle float xx,yy,rr

 

del ca : del cb : del cc

 

=={{header|Oz}}==

No accessors because we use immutable public attributes ("features").

 

feat

x

")"}

end

 

=={{header|Pascal}}==

=={{header|Perl}}==

What polymorphic function means in the context of Perl is as clear as mud. subs already can take anything as parameter by default. Destructors are automatic, so I dropped them.

package Point;

use Class::Spiffy -base;

my $c = Circle->new(r => 4);

print $c->r, "\n"; # accessor autogenerated

 

=={{header|Phix}}==

There are no private members here; for that I would write something that returns integer ids to the outside world.

 

<span style="color: #008080;">type</span> <span style="color: #000000;">point</span><span style="color: #0000FF;">(</span><span style="color: #004080;">object</span> <span style="color: #000000;">o</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">return</span> <span style="color: #004080;">sequence</span><span style="color: #0000FF;">(</span><span style="color: #000000;">o</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">and</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">o</span><span style="color: #0000FF;">)=</span><span style="color: #000000;">2</span> <span style="color: #008080;">and</span> <span style="color: #004080;">atom</span><span style="color: #0000FF;">(</span><span style="color: #000000;">o</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">])</span> <span style="color: #008080;">and</span> <span style="color: #004080;">atom</span><span style="color: #0000FF;">(</span><span style="color: #000000;">o</span><span style="color: #0000FF;">[</span><span style="color: #000000;">2</span><span style="color: #0000FF;">])</span>

<span style="color: #0000FF;">?</span><span style="color: #000000;">c1</span>

<span style="color: #0000FF;">?</span><span style="color: #000000;">c2</span>

 

{{out}}

{{libheader|Phix/Class}}

 

<span style="color: #008080;">class</span> <span style="color: #000000;">Point</span>

<span style="color: #004080;">atom</span> <span style="color: #000000;">x</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">y</span>

<span style="color: #000000;">c2</span><span style="color: #0000FF;">.</span><span style="color: #000000;">show</span><span style="color: #0000FF;">()</span>

<span style="color: #000000;">c3</span><span style="color: #0000FF;">.</span><span style="color: #000000;">show</span><span style="color: #0000FF;">()</span>

 

{{out}}

Point class definition.

 

class Point

{

}

}

 

Circle class definition.

 

class Circle extends Point

{

}

}

 

Usage:

 

$point = new Point( 1, 5 );

$circle = new Circle( 1, 5, 6 );

// or

echo $circle;

 

Will result in:

 

=={{header|PicoLisp}}==

# x y

 

 

(dm print> ()

P (new '(+Point) 3 4)

C (new '(+Circle) 10 10 5) )

 

(print> P)

{{out}}

<pre>Point 3,4

So it is enough to define classes and the print method.

 

define :class Point;

slot x = 0;

define :method print(p : Circle);

printf('Circle(' >< x(p) >< ', ' >< y(p) >< ', ' >< r(p) >< ')\n');

 

To test we can use the following code:

 

lvars instance1 = newPoint();

lvars instance2 = newCircle();

;;; Use print method

print(instance1);

 

=={{header|Prolog}}==

The Copy constructor, assignment and destructor operations are not needed as terms can be copied and assigned using unification as part of the language.

 

point_construct(X, Y, point(X1,Y1)) :-

default(X, X1),

Y1 is Y * 2,

shape_x_y_set(T, X1, Y1, T1),

{{out}}

<pre>

=={{header|PureBasic}}==

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

BeginProtect

EndMethod

Testcode

*circle.Circle = NewObject.Circle

 

*circle\Print()

CloseConsole()

 

=={{header|Python}}==

For the print function, use the standard __repr__ methods, used when printing an object. Destructors are not needed of course.

 

def __init__(self, x=0.0, y=0.0):

self.x = x

def __repr__(self):

return '<Circle 0x%x x: %f y: %f radius: %f>' % (

 

Usage example:

 

Or, using inheritance like some of the other solutions:

def __init__(self, x=0.0, y=0.0):

self.x = x

def __repr__(self):

return '<Circle 0x%x x: %f y: %f radius: %f>' % (

 

Usage example:

The task calls for the creation of mutable types i.e. that you are allowed to change the values of x, y, or r of a Point or Circle after they have been created.

If this is not needed, then the Python namedtuple is a good way to create immutable classes with named fields such as these.

>>> class Point(namedtuple('Point', 'x y')):

def __new__( _cls, x=0, y=0 ):

p.x = 10.81

AttributeError: can't set attribute

 

And if you don't need default arguments, this becomes:

>>> Circle = namedtuple('Circle', 'x y r')

>>> Point(3, 4)

>>> Circle(x=1, y=2, r=3)

Circle(x=1, y=2, r=3)

 

=={{header|R}}==

Copy constructors are not needed, since objects are copied by value.

Neither are destructors needed (just use the rm function).

representation(

x="numeric",

cat("This is a circle, with radius", x@r, "and centre (", x@centre@x, ",", x@centre@y, ").\n")

})

 

=={{header|Racket}}==

"Fields" come with accessors and mutators for free.

 

#lang racket

(define point%

(define/override (custom-write out) (write (show) out))

(define/override (custom-display out) (display (show) out))))

{{out}}

<pre>

To create only readonly accessors for better encapsulation, leave out all the "is rw" traits.

Here we demonstrate that accessors can behave like variables and may be assigned.

has Real $.x is rw = 0;

has Real $.y is rw = 0;

$c.p.y = (-10..10).pick;

$c.r = (0..10).pick;

In this case we define the Str coercion method polymorphically, which is used by say or print to format the contents of the object.

We could also have defined print methods directly.

We could have factored this method out to a common role and composed it into each class.

We could also have defined multi subs outside of the class, like this:

 

=={{header|Ruby}}==

The <tt>Kernel#dup</tt> method can be used as a copy constructor.

 

attr_accessor :x,:y

def initialize(x=0, y=0)

"Circle at #{x},#{y} with radius #{r}"

end

Example:

puts Point.new # => Point at 0,0

p = Point.new(1, 2)

d.r = 7.5

puts c # => Circle at 4,5 with radius 6

 

=={{header|Scala}}==

{{Out}}Best seen running in your browser either by [https://scalafiddle.io/sf/altUDTl/0 ScalaFiddle (ES aka JavaScript, non JVM)] or [https://scastie.scala-lang.org/ohfeM4nvTZyeOTYYWHaNgQ Scastie (remote JVM)].

 

class Point(x: Int = 0, y: Int = 0) {

println(e, " changed radius")

 

 

=={{header|Seed7}}==

Note that a Seed7 constructor does not need to have the name of the type (a new Point could be created with a function called abc).

Seed7 defines copy constructor, assignment and destructor automatically.

 

const type: GraphicObj is new interface;

graph := circ;

print(graph);

 

{{out}}

 

We create four named objects, two of which we put in the traits namespace and two in a general prototype namespace. This would normally be done in the UI.

parent* = traits clonable.

printString = ('Point(', x asString, ':', y asString, ')').

center <- point copy.

r <- 0

 

=={{header|Sidef}}==

 

}

func pp(Circle obj) {

say "Circle at #{obj.x},#{obj.y} with radius #{obj.r}";

 

Example:

var p = Point(1, 2); # create a point

pp(p); # => Point at 1,2

d.r = 7.5; # and change the radius to 7.5

pp(c); # => Circle at 4,5 with radius 6

 

=={{header|SIMPOL}}==

The <code>embed</code> keyword in the type definition states that the type itself can be embedded in another type (any type can be placed as a reference in another type).

 

embed

integer x

 

result = p.print() + "{d}{a}" + c.print() + "{d}{a}"

 

[[SIMPOL]] does not currently have access to stdin, stdout, and stderr,

=={{header|Smalltalk}}==

Like Python and Ruby, these objects do not need to be related in order to have polymorphic methods.

instanceVariableNames: 'x y'

classVariableNames: ''

!Circle methodsFor: 'polymorphism test'!

print

 

''TODO: more idiomatic mechanism for presenting objects as strings.''

 

=={{header|Swift}}==

var x: Int

var y: Int

println(p.x) // 1

p.x = 8

 

=={{header|Tcl}}==

We only do so here for convenience.

In addition, Tcl's arguments to commands, procedures and methods are all fully polymorphic by default.

oo::class create Point {

variable X Y

foreach o $objects {

$o print

 

=={{header|Wollok}}==

class Point {

var x

c.print()

}

 

=={{header|Wren}}==

 

The following program uses the same examples as the Kotlin entry.

construct new(x, y) {

_x = x

Circle.new(4, 5, 6), Circle.fromCircle(Circle.new(7, 8, 9))

]

 

{{out}}

=={{header|zkl}}==

Written for brevity

fcn init(xyOrPoint=0,_=0){

if(Point.isInstanceOf(xyOrPoint)) set(xyOrPoint);

c:=Circle(1,2,3);

c.println(); c.center.println();

{{out}}

<pre>