Rosetta Code

Inheritance/Single: Difference between revisions

Page Discussion

Inheritance/Single (view source)

Revision as of 16:24, 27 August 2022

4,847 bytes added ,  1 year ago
m
syntax highlighting fixup automation
(→‎{{header|Lua}}: added Lua solution)
m (syntax highlighting fixup automation)
Line 67:
{{trans|Python}}
 
<langsyntaxhighlight lang="11l">T Animal
{
}
Line 81:
T Collie(Dog)
{
}</langsyntaxhighlight>
 
=={{header|ActionScript}}==
<langsyntaxhighlight lang="actionscript">public class Animal {
// ...
}</langsyntaxhighlight>
<langsyntaxhighlight lang="actionscript">public class Cat extends Animal {
// ...
}</langsyntaxhighlight>
<langsyntaxhighlight lang="actionscript">public class Dog extends Animal {
// ...
}</langsyntaxhighlight>
<langsyntaxhighlight lang="actionscript">public class Lab extends Dog {
// ...
}</langsyntaxhighlight>
<langsyntaxhighlight lang="actionscript">public class Collie extends Dog {
// ...
}</langsyntaxhighlight>
 
=={{header|Ada}}==
<langsyntaxhighlight lang="ada">package Inheritance is
type Animal is tagged private;
type Dog is new Animal with private;
Line 113:
type Lab is new Dog with null record;
type Collie is new Dog with null record;
end Inheritance;</langsyntaxhighlight>
 
=={{header|Aikido}}==
<langsyntaxhighlight lang="aikido ">class Animal{
//functions go here...
}</langsyntaxhighlight>
<langsyntaxhighlight lang="aikido ">class Dog extends Animal {
//functions go here...
}</langsyntaxhighlight>
<langsyntaxhighlight lang="aikido ">class Cat extends Animal {
//functions go here...
}</langsyntaxhighlight>
<langsyntaxhighlight lang="aikido ">class Lab extends Dog {
//functions go here...
}</langsyntaxhighlight>
<langsyntaxhighlight lang="aikido ">class Collie extends Dog {
//functions go here...
}</langsyntaxhighlight>
 
=={{header|AmigaE}}==
<langsyntaxhighlight lang="amigae">
OBJECT animal
ENDOBJECT
Line 148:
OBJECT collie OF dog
ENDOBJECT
</syntaxhighlight>
</lang>
 
=={{header|AppleScript}}==
 
<langsyntaxhighlight lang="applescript">script Animal
end script
 
Line 169:
script Collie
property parent : Dog
end script</langsyntaxhighlight>
 
=={{header|AutoHotkey}}==
Line 175:
 
AutoHotkey_L is prototype-based. However, for convenience, class-syntax may be used to create a base object.
<langsyntaxhighlight AutoHotkeylang="autohotkey">dog := new Collie
MsgBox, % "A " dog.__Class " is a " dog.base.base.__Class " and is part of the " dog.kingdom " kingdom."
 
Line 188:
}
class Collie extends Dog {
}</langsyntaxhighlight>
 
=={{header|BBC BASIC}}==
{{works with|BBC BASIC for Windows}}
<langsyntaxhighlight lang="bbcbasic"> INSTALL @lib$+"CLASSLIB"
DIM Animal{method}
Line 211:
DIM Collie{method}
PROC_inherit(Collie{}, Dog{})
PROC_class(Collie{})</langsyntaxhighlight>
 
=={{header|C}}==
Line 217:
 
=={{header|C sharp|C#}}==
<langsyntaxhighlight lang="csharp">class Animal
{
/* ... */
Line 245:
/* ... */
// ...
}</langsyntaxhighlight>
 
=={{header|C++}}==
<langsyntaxhighlight lang="cpp">class Animal
{
// ...
Line 271:
{
// ...
};</langsyntaxhighlight>
 
=={{header|ChucK}}==
<langsyntaxhighlight ChucKlang="chuck">public class Drums{
//functions go here...
}</langsyntaxhighlight>
<langsyntaxhighlight ChucKlang="chuck">public class LatinKit extends Drums{
//functions go here...
}</langsyntaxhighlight>
<langsyntaxhighlight ChucKlang="chuck">public class ElectronicKit extends Drums{
//functions go here...
}</langsyntaxhighlight>
<langsyntaxhighlight ChucKlang="chuck">public class Congas extends LatinKit{
//functions go here...
}</langsyntaxhighlight>
<langsyntaxhighlight ChucKlang="chuck">public class TechnoDrums extends ElectronicKit{
//functions go here...
}</langsyntaxhighlight>
 
=={{header|Clojure}}==
Line 294:
This is not very useful in clojure
 
<langsyntaxhighlight Clojurelang="clojure">(gen-class :name Animal)
(gen-class :name Dog :extends Animal)
(gen-class :name Cat :extends Animal)
(gen-class :name Lab :extends Dog)
(gen-class :name Collie :extends Dog)</langsyntaxhighlight>
 
More useful:
 
<langsyntaxhighlight Clojurelang="clojure">(derive ::dog ::animal)
(derive ::cat ::animal)
(derive ::lab ::dog)
(derive ::collie ::dog)</langsyntaxhighlight>
 
use:
 
<langsyntaxhighlight Clojurelang="clojure">user> (isa? ::dog ::animal)
true
user> (isa? ::dog ::cat)
false
user> (isa? ::collie ::animal)
true</langsyntaxhighlight>
 
=={{header|COBOL}}==
<langsyntaxhighlight lang="cobol"> CLASS-ID. Animal.
*> ...
END CLASS Animal.
Line 355:
 
*> ...
END CLASS Collie.</langsyntaxhighlight>
 
=={{header|Coco}}==
 
<langsyntaxhighlight lang="coco">class Animal
class Cat extends Animal
class Dog extends Animal
class Lab extends Dog
class Collie extends Dog</langsyntaxhighlight>
 
On the subject of inheritance, it is worth noting that Coco's <code>super</code> works differently from CoffeeScript's. In particular, the constructor of a subclass should generally say <code>super ...</code>, not just <code>super</code>. Here is a translation of the example from the CoffeeScript documentation:
 
<langsyntaxhighlight lang="coco">class Animal
 
(@name) ->
Line 394:
 
sam.move!
tom.move!</langsyntaxhighlight>
 
=={{header|Comal}}==
{{works with|UniComal}}
{{works with|AmiComal}}
<langsyntaxhighlight Comallang="comal"> STRUC Animal
DIM Species$ OF 20
ENDSTRUC Animal
Line 431:
Race$:="Collie"
ENDFUNC New
ENDSTRUC Collie</langsyntaxhighlight>
 
=={{header|Common Lisp}}==
Line 437:
Using CLOS classes, we have the following:
 
<langsyntaxhighlight lang="lisp">(defclass animal () ())
(defclass dog (animal) ())
(defclass lab (dog) ())
(defclass collie (dog) ())
(defclass cat (animal) ())</langsyntaxhighlight>
 
Alternatively, since there is no multiple inheritance in the task requirement, structures could also be used:
 
<langsyntaxhighlight lang="lisp">(defstruct animal)
(defstruct (dog (:include animal)))
(defstruct (lab (:include dog)))
(defstruct (collie (:include dog)))
(defstruct (cat (:include animal)))</langsyntaxhighlight>
 
(Structures are less flexible than CLOS objects but often somewhat more efficiently implemented, due to those restrictions.)
Line 457:
Furthermore, all of the "basic types" also have a class, so methods can be readily specialized to lists, integers, strings, symbols, et cetera. This is done without having to modify any class definitions.
 
<langsyntaxhighlight lang="lisp">
;;; ASN.1 serialization logic specialized for animal class
(defmethod serialize-to-asn-1 ((a animal))
Line 466:
(defmethod serialize-to-asn-1 ((s string))
#| ... #|
)</langsyntaxhighlight>
 
These classes do not have to inherit from some interface or base class which provides a prototype for the serialize-to-asn-1 method. Such a requirement has more to do with static typing than object oriented programming. Usually in languages which require such inheritance, there are also statically typed references. A class must conform to some "ASNEncodable" class so that its instances can be passed to functions which expect references to an ASN1Encodable type, which is verified at compile time.
Line 472:
=={{header|Component Pascal}}==
 
<langsyntaxhighlight lang="oberon2">
TYPE
Animal = ABSTRACT RECORD (* *) END;
Line 479:
Lab = RECORD (Dog) (* *) END;
Collie = RECORD (Dog) (* *) END;
</syntaxhighlight>
</lang>
 
=={{header|D}}==
<langsyntaxhighlight lang="d">class Animal {
// ...
}
Line 502:
}
 
void main() {}</langsyntaxhighlight>
 
=={{header|Delphi}}==
 
<syntaxhighlight lang="delphi">type
<lang Delphi>type
Animal = class(TObject)
private
Line 517:
Cat = class(Animal);
Collie = class(Dog);
Lab = class(Dog);</langsyntaxhighlight>
 
=={{header|DWScript}}==
 
<syntaxhighlight lang="delphi">type
<lang Delphi>type
Animal = class(TObject)
private
Line 532:
type Cat = class(Animal) end;
type Collie = class(Dog) end;
type Lab = class(Dog) end;</langsyntaxhighlight>
 
=={{header|E}}==
Line 540:
In E, a ''guard'' accepts, or coerces, certain objects and rejects others; its [[wp:Range (mathematics)|range]] constitutes a type. An ''auditor'' examines the implementation of an object and marks it approved; a ''stamp'' is an auditor which does no actual checking. Here, we create a guard/stamp pair; the guard accepts every stamped object. The stamp also asks for each supertype's stamp on the objects it audits.
 
<langsyntaxhighlight lang="e">def makeType(label, superstamps) {
def stamp {
to audit(audition) {
Line 557:
}
return [guard, stamp]
}</langsyntaxhighlight>
 
Setting up the task's specified tree:
 
<langsyntaxhighlight lang="e">def [Animal, AnimalStamp] := makeType("Animal", [])
 
def [Cat, CatStamp] := makeType("Cat", [AnimalStamp])
Line 567:
 
def [Lab, LabStamp] := makeType("Lab", [DogStamp])
def [Collie, CollieStamp] := makeType("Collie", [DogStamp])</langsyntaxhighlight>
 
Some example objects:
 
<langsyntaxhighlight lang="e">def fido implements LabStamp {}
def tom implements CatStamp {}
def brick {} # not an animal</langsyntaxhighlight>
 
Testing against the types:
 
<langsyntaxhighlight lang="e">? fido :Animal
# value: <fido>
 
Line 593:
 
? brick :Animal
# problem: <brick> is not a Animal</langsyntaxhighlight>
 
=={{header|Eiffel}}==
<langsyntaxhighlight lang="eiffel ">class
ANIMAL
end</langsyntaxhighlight>
<langsyntaxhighlight lang="eiffel ">class
DOG
inherit
ANIMAL
end</langsyntaxhighlight>
<langsyntaxhighlight lang="eiffel ">class
CAT
inherit
ANIMAL
end</langsyntaxhighlight>
<langsyntaxhighlight lang="eiffel ">class
LAB
inherit
DOG
end</langsyntaxhighlight>
<langsyntaxhighlight lang="eiffel ">class
COLLIE
inherit
DOG
end</langsyntaxhighlight>
 
=={{header|Elena}}==
ELENA 4.x :
<langsyntaxhighlight lang="elena">class Animal
{
// ...
Line 645:
{
// ...
}</langsyntaxhighlight>
 
=={{header|F_Sharp|F#}}==
The <code>()</code> behind the class names indicates a public default constructor; you need some type of public constructor to derive from a class.
<langsyntaxhighlight lang="fsharp">type Animal() =
class // explicit syntax needed for empty class
end
Line 663:
 
type Cat() =
inherit Animal()</langsyntaxhighlight>
 
=={{header|Factor}}==
<langsyntaxhighlight lang="factor">TUPLE: animal ;
TUPLE: dog < animal ;
TUPLE: cat < animal ;
TUPLE: lab < dog ;
TUPLE: collie < dog ;</langsyntaxhighlight>
 
=={{header|Fancy}}==
<langsyntaxhighlight lang="fancy">class Animal {
# ...
}
Line 691:
class Collie : Dog {
# ...
}</langsyntaxhighlight>
 
=={{header|Fantom}}==
<langsyntaxhighlight lang="fantom">class Animal
{
}
Line 712:
class Collie : Dog
{
}</langsyntaxhighlight>
 
=={{header|Forth}}==
{{works with|4tH|3.61.5}}
There are numerous, mutually incompatible object oriented frameworks for Forth. This one works with the FOOS preprocessor extension of [[4tH]].
<langsyntaxhighlight lang="forth">include 4pp/lib/foos.4pp
 
:: Animal class end-class {} ;
Line 723:
:: Cat extends Animal end-extends {} ;
:: Lab extends Dog end-extends {} ;
:: Collie extends Dog end-extends {} ;</langsyntaxhighlight>
 
 
Line 730:
Needs the FMS2 library code located here:
https://github.com/DouglasBHoffman/FMS2
<langsyntaxhighlight lang="forth">include FMS2LL.f
 
:class Animal ;class
Line 736:
:class Cat <super Animal ;class
:class Lab <super Dog ;class
:class Collie <super Dog ;class</langsyntaxhighlight>
 
=={{header|Fortran}}==
OO has been part of the Fortran standard since 2003 but the compilers are still playing catchup. This example builds with the Intel 11.1.069 compiler (free for personal use on linux).
 
<langsyntaxhighlight lang="fortran">module anim
 
type animal
Line 758:
end type collie
 
end module anim</langsyntaxhighlight>
 
=={{header|FreeBASIC}}==
<langsyntaxhighlight lang="freebasic">' FB 1.05.0 Win64
 
Type Animal Extends Object ' to enable virtual methods etc. if needed
Line 781:
Type Collie Extends Dog
' ...
End Type</langsyntaxhighlight>
 
=={{header|Go}}==
Go eschews most trappings of inheritance, yet it's anonymous field feature allows building one struct type upon another and accessing fields of "embedded" types without extra synax.
<langsyntaxhighlight lang="go">package main
 
type animal struct {
Line 817:
pet.color = "yellow"
}
</syntaxhighlight>
</lang>
 
=={{header|Groovy}}==
<langsyntaxhighlight lang="groovy">class Animal{
//contents go here...
}</langsyntaxhighlight>
<langsyntaxhighlight lang="groovy">class Dog extends Animal{
//contents go here...
}</langsyntaxhighlight>
<langsyntaxhighlight lang="groovy">class Cat extends Animal{
//contents go here...
}</langsyntaxhighlight>
<langsyntaxhighlight lang="groovy">class Lab extends Dog{
//contents go here...
}</langsyntaxhighlight>
<langsyntaxhighlight lang="groovy">class Collie extends Dog{
//contents go here...
}</langsyntaxhighlight>
 
=={{header|Haskell}}==
A type can't inherit properties from other types, but it can belong to any number of type classes, which may themselves be subclasses of other type classes.
 
<langsyntaxhighlight lang="haskell">class Animal a
class Animal a => Cat a
class Animal a => Dog a
class Dog a => Lab a
class Dog a => Collie a</langsyntaxhighlight>
 
=={{header|Haxe}}==
<langsyntaxhighlight lang="haxe">class Animal {
// ...
}</langsyntaxhighlight>
<langsyntaxhighlight lang="haxe">class Cat extends Animal {
// ...
}</langsyntaxhighlight>
<langsyntaxhighlight lang="haxe">class Dog extends Animal {
// ...
}</langsyntaxhighlight>
<langsyntaxhighlight lang="haxe">class Lab extends Dog {
// ...
}</langsyntaxhighlight>
<langsyntaxhighlight lang="haxe">class Collie extends Dog {
// ...
}</langsyntaxhighlight>
 
== Icon and {{header|Unicon}} ==
Line 866:
This example only works in Unicon.
 
<syntaxhighlight lang="unicon">
<lang Unicon>
class Animal ()
end
Line 881:
class Collie : Dog ()
end
</syntaxhighlight>
</lang>
 
=={{header|Inform 7}}==
<langsyntaxhighlight lang="inform7">An animal is a kind of thing.
A cat is a kind of animal.
A dog is a kind of animal.
A collie is a kind of dog.
A lab is a kind of dog.</langsyntaxhighlight>
 
"Animal" is actually a predefined kind in Inform 7, so its definition here is redundant (but legal).
Line 894:
=={{header|Io}}==
 
<langsyntaxhighlight lang="io">Animal := Object clone
Cat := Animal clone
Dog := Animal clone
Collie := Dog clone
Lab := Dog clone</langsyntaxhighlight>
 
=={{header|J}}==
Line 904:
Here is how this would normally be done:
 
<syntaxhighlight lang ="j">coclass 'Animal'</langsyntaxhighlight>
<langsyntaxhighlight lang="j">coclass 'Dog'
coinsert 'Animal'</langsyntaxhighlight>
<langsyntaxhighlight lang="j">coclass 'Cat'
coinsert 'Animal'</langsyntaxhighlight>
<langsyntaxhighlight lang="j">coclass 'Lab'
coinsert 'Dog'</langsyntaxhighlight>
<langsyntaxhighlight lang="j">coclass 'Collie'
coinsert 'Dog'</langsyntaxhighlight>
 
<code>coclass</code> specifies that following definitions will be within the named class, and <code>coinsert</code> specifies that the current class will inherit from the named classes (or object -- in J the only difference between a class and an object is its name and how you can create them -- this motivates the "co" prefix on operations which manipulate '''c'''lasses and '''o'''bjects).
Line 920:
That said, some operations in J -- including <code>coinsert</code> -- will create classes if they did not already exist. So the above may be simplified to:
 
<langsyntaxhighlight lang="j">coinsert_Dog_ 'Animal'
coinsert_Cat_ 'Animal'
coinsert_Lab_ 'Dog'
coinsert_Collie_ 'Dog'</langsyntaxhighlight>
 
That said, note that classes and objects are not "types" in J. Instead, they are components of names. In general, when we deal with objects and classes we deal with references to the underlying representation, and in J the references are names, so a collection of classes and objects, in J, would be a collection of names which refer to classes and objects. In other words, the "type" (to the degree that there is a type) would be best thought of as "name" (or, more mechanically: boxed list of characters).
 
=={{header|Java}}==
<langsyntaxhighlight lang="java">public class Animal{
//functions go here...
}</langsyntaxhighlight>
<langsyntaxhighlight lang="java">public class Dog extends Animal{
//functions go here...
}</langsyntaxhighlight>
<langsyntaxhighlight lang="java">public class Cat extends Animal{
//functions go here...
}</langsyntaxhighlight>
<langsyntaxhighlight lang="java">public class Lab extends Dog{
//functions go here...
}</langsyntaxhighlight>
<langsyntaxhighlight lang="java">public class Collie extends Dog{
//functions go here...
}</langsyntaxhighlight>
 
=={{header|JavaScript}}==
JavaScript is a class-free, object-oriented language, and as such, it uses prototypal inheritance instead of classical inheritance.
<langsyntaxhighlight lang="javascript">function Animal() {
// ...
}</langsyntaxhighlight>
 
<langsyntaxhighlight lang="javascript">function Dog() {
// ...
}
Dog.prototype = new Animal();</langsyntaxhighlight>
 
<langsyntaxhighlight lang="javascript">function Cat() {
// ...
}
Cat.prototype = new Animal();</langsyntaxhighlight>
 
<langsyntaxhighlight lang="javascript">function Collie() {
// ...
}
Collie.prototype = new Dog();</langsyntaxhighlight>
 
<langsyntaxhighlight lang="javascript">function Lab() {
// ...
}
Lab.prototype = new Dog();</langsyntaxhighlight>
 
<langsyntaxhighlight lang="javascript">Animal.prototype.speak = function() {print("an animal makes a sound")};
 
var lab = new Lab();
lab.speak(); // shows "an animal makes a sound"</langsyntaxhighlight>
 
=={{header|Julia}}==
Julia is not really an object-oriented programming language. It supports polymorphism and inheriting functionality but not structure. Thus inheritance hierarchies must be made with abstract types. Abstract types can not be instantiated and do not contain any fields. So below Dog is abstract while Collie is a concrete type which may contain fields.
<langsyntaxhighlight lang="julia">
abstract type Animal end
abstract type Dog <: Animal end
Line 984:
struct Lab <: Dog end
struct Collie <: Dog end
</syntaxhighlight>
</lang>
 
=={{header|Kite}}==
<langsyntaxhighlight Kitelang="kite">class Animal [
#Method goes here
];
Line 1,002:
#Method goes here
];
</syntaxhighlight>
</lang>
 
=={{header|Kotlin}}==
<langsyntaxhighlight lang="scala">// version 1.0.6
 
open class Animal {
Line 1,036:
println("Bella is a $bella")
println("Casey is a $casey")
}</langsyntaxhighlight>
 
{{out}}
Line 1,047:
 
=={{header|Lasso}}==
<langsyntaxhighlight Lassolang="lasso">define animal => type {
data public gender::string
}
Line 1,070:
 
#myanimal -> gender = 'Male'
#myanimal -> gender</langsyntaxhighlight>
-> Male
 
Line 1,077:
Latitude is a prototype-oriented language, so defining a subclass is equivalent to constructing an instance.
 
<langsyntaxhighlight lang="latitude">
Animal ::= Object clone tap {
;; Methods go here...
Line 1,096:
Collie ::= Dog clone tap {
;; Methods go here...
}.</langsyntaxhighlight>
 
We <code>clone</code> the parent and then <code>tap</code> the new instance to add functionality to it. Note that we use <code>::=</code> here rather than the usual <code>:=</code>, as the former implicitly defines an appropriate <code>toString</code> method representative of the new "class".
Line 1,102:
=={{header|Lingo}}==
In Lingo Classes are represented by "parent scripts". Instead of using new() as in the code below, child classes can also use rawNew() when creating an instance of their parent classes. rawNew() creates an instance of a class without calling its initialization function 'new' (constructor).
<langsyntaxhighlight lang="lingo">-- parent script "Animal"
-- ...</langsyntaxhighlight>
 
<langsyntaxhighlight lang="lingo">-- parent script "Dog"
property ancestor
 
Line 1,111:
me.ancestor = script("Animal").new()
return me
end</langsyntaxhighlight>
<langsyntaxhighlight lang="lingo">-- parent script "Cat"
property ancestor
 
Line 1,119:
me.ancestor = script("Animal").new()
return me
end</langsyntaxhighlight>
 
<langsyntaxhighlight lang="lingo">-- parent script "Lab"
property ancestor
 
Line 1,127:
me.ancestor = script("Dog").new()
return me
end</langsyntaxhighlight>
 
<langsyntaxhighlight lang="lingo">-- parent script "Collie"
property ancestor
 
Line 1,135:
me.ancestor = script("Dog").new()
return me
end</langsyntaxhighlight>
 
=={{header|Lisaac}}==
<langsyntaxhighlight Lisaaclang="lisaac">Section Header
+ name := ANIMAL;
// ...</langsyntaxhighlight>
<langsyntaxhighlight Lisaaclang="lisaac">Section Header
+ name := CAT;
Section Inherit
- parent : ANIMAL := ANIMAL;
// ...</langsyntaxhighlight>
<langsyntaxhighlight Lisaaclang="lisaac">Section Header
+ name := DOG;
Section Inherit
- parent : ANIMAL := ANIMAL;
// ...</langsyntaxhighlight>
<langsyntaxhighlight Lisaaclang="lisaac">Section Header
+ name := LAB;
Section Inherit
- parent : DOG := DOG;
// ...</langsyntaxhighlight>
<langsyntaxhighlight Lisaaclang="lisaac">Section Header
+ name := COLLIE;
Section Inherit
- parent : DOG := DOG;
// ...</langsyntaxhighlight>
 
=={{header|Logtalk}}==
There is no "class" keyword in Logtalk; an "object" keyword is used instead (Logtalk objects play the role of classes, meta-classes, instances, or prototypes depending on the relations with other objects).
<langsyntaxhighlight lang="logtalk">
:- object(thing,
instantiates(thing)).
Line 1,192:
specializes(dog)).
...
:- end_object.</langsyntaxhighlight>
 
=={{header|Lua}}==
Lua has no in-built formal OOP mechanism, though there are many possible ways of implementing work-alikes.
<langsyntaxhighlight lang="lua">Class = {
classname = "Class aka Object aka Root-Of-Tree",
new = function(s,t)
Line 1,225:
print("max's parent's parent's parent is (class): " .. max.parent.parent.parent.classname)
print("max's parent's parent's parent's parent is (class): " .. max.parent.parent.parent.parent.classname)
print("max's parent's parent's parent's parent's parent is (nil reference): " .. tostring(max.parent.parent.parent.parent.parent))</langsyntaxhighlight>
{{out}}
<pre>Animal:speak(): (Animal has no voice)
Line 1,241:
 
=={{header|M2000 Interpreter}}==
<syntaxhighlight lang="m2000 interpreter">
<lang M2000 Interpreter>
Module CheckIt {
Class Animal {
Line 1,260:
}
CheckIt
</syntaxhighlight>
</lang>
 
=={{header|Neko}}==
<langsyntaxhighlight Nekolang="neko">var Animal = $new(null);
 
var Dog = $new(null);
Line 1,275:
 
var Collie = $new(null);
$objsetproto(Collie, Dog);</langsyntaxhighlight>
 
=={{header|Nemerle}}==
<langsyntaxhighlight lang="nemerle">class Animal {
// ...
}
Line 1,296:
class Cat: Animal {
// ...
}</langsyntaxhighlight>
 
=={{header|NetRexx}}==
Line 1,302:
 
For brevity, all classes are defined within the same source file. Normally classes exist as separate source units.
<langsyntaxhighlight NetRexxlang="netrexx">/* NetRexx */
options replace format comments java crossref symbols binary
 
Line 1,357:
-- Do Collie specific set-up
return
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,370:
 
=={{header|Nim}}==
<langsyntaxhighlight lang="nim">type
Animal = object of RootObj
Dog = object of Animal
Cat = object of Animal
Lab = object of Dog
Collie = object of Dog</langsyntaxhighlight>
 
=={{header|Oberon}}==
Tested with [https://miasap.se/obnc OBNC].
<langsyntaxhighlight Oberonlang="oberon">MODULE Animals;
 
TYPE
Line 1,389:
 
END Animals.
</syntaxhighlight>
</lang>
 
=={{header|Oberon-2}}==
Works with oo2c Version 2
<langsyntaxhighlight lang="oberon2">
MODULE Animals;
TYPE
Line 1,412:
 
END Animals.
</syntaxhighlight>
</lang>
 
=={{header|Objeck}}==
<langsyntaxhighlight lang="objeck">class Animal
{ #~ ... ~# }
Line 1,428:
class Cat from Animal
{ #~ ... ~# }</langsyntaxhighlight>
 
=={{header|Objective-C}}==
<langsyntaxhighlight lang="objc">@interface Animal : NSObject
{
// ...
Line 1,464:
}
// ...
@end</langsyntaxhighlight>
 
=={{header|OCaml}}==
<langsyntaxhighlight lang="ocaml">class animal =
object (self)
(*functions go here...*)
end</langsyntaxhighlight>
<langsyntaxhighlight lang="ocaml">class dog =
object (self)
inherit animal
(*functions go here...*)
end</langsyntaxhighlight>
<langsyntaxhighlight lang="ocaml">class cat =
object (self)
inherit animal
(*functions go here...*)
end</langsyntaxhighlight>
<langsyntaxhighlight lang="ocaml">class lab =
object (self)
inherit dog
(*functions go here...*)
end</langsyntaxhighlight>
<langsyntaxhighlight lang="ocaml">class collie =
object (self)
inherit dog
(*functions go here...*)
end</langsyntaxhighlight>
 
=={{header|Oforth}}==
 
<langsyntaxhighlight Oforthlang="oforth">Object Class new: Animal
Animal Class new: Cat
Animal Class new: Dog
Dog Class new: Lab
Dog Class new: Collie</langsyntaxhighlight>
 
=={{header|ooRexx}}==
<syntaxhighlight lang="oorexx">
<lang ooRexx>
-- subclass of object by default
::class animal
Line 1,512:
 
::class collie subclass dog
</syntaxhighlight>
</lang>
 
=={{header|OxygenBasic}}==
<langsyntaxhighlight lang="oxygenbasic">
class animal
method show() as string
Line 1,553:
Collie c
print c.show 'result: Animal Dog Collie
</syntaxhighlight>
</lang>
 
=={{header|Oz}}==
<langsyntaxhighlight lang="oz">class Animal
%% ...
end
Line 1,574:
class Cat from Animal
%% ...
end</langsyntaxhighlight>
 
=={{header|Pascal}}==
Line 1,581:
=={{header|Perl}}==
 
<langsyntaxhighlight lang="perl">package Animal;
#functions go here...
1;</langsyntaxhighlight>
 
<langsyntaxhighlight lang="perl">package Dog;
use Animal;
@ISA = qw( Animal );
#functions go here...
1;</langsyntaxhighlight>
 
<langsyntaxhighlight lang="perl">package Cat;
use Animal;
@ISA = qw( Animal );
#functions go here...
1;</langsyntaxhighlight>
 
<langsyntaxhighlight lang="perl">package Lab;
use Dog;
@ISA = qw( Dog );
#functions go here...
1;</langsyntaxhighlight>
 
<langsyntaxhighlight lang="perl">package Collie;
use Dog;
@ISA = qw( Dog );
#functions go here...
1;</langsyntaxhighlight>
 
The same using the [http://search.cpan.org/perldoc?MooseX::Declare MooseX::Declare] module:
 
<langsyntaxhighlight lang="perl">use MooseX::Declare;
 
class Animal {
Line 1,627:
class Collie extends Dog {
# methods go here...
}</langsyntaxhighlight>
 
=={{header|Phix}}==
{{libheader|Phix/Class}}
Add (private|public) fields and methods as needed. Make Animal and Dog abstract (ie use "abstract class") to prevent instantiation.
<!--<langsyntaxhighlight Phixlang="phix">(notonline)-->
<span style="color: #008080;">without</span> <span style="color: #008080;">js</span> <span style="color: #000080;font-style:italic;">-- (class)</span>
<span style="color: #008080;">class</span> <span style="color: #000000;">Animal</span>
Line 1,645:
<span style="color: #008080;">class</span> <span style="color: #000000;">Collie</span> <span style="color: #008080;">extends</span> <span style="color: #000000;">Dog</span> <span style="color: #008080;">end</span> <span style="color: #008080;">class</span>
<span style="color: #008080;">class</span> <span style="color: #000000;">Cat</span> <span style="color: #008080;">extends</span> <span style="color: #000000;">Animal</span> <span style="color: #008080;">end</span> <span style="color: #008080;">class</span>
<!--</langsyntaxhighlight>-->
 
=={{header|PHP}}==
<langsyntaxhighlight lang="php">class Animal {
// functions go here...
}
Line 1,666:
class Collie extends Dog {
// functions go here...
}</langsyntaxhighlight>
 
=={{header|PicoLisp}}==
<langsyntaxhighlight PicoLisplang="picolisp">(class +Animal)
 
(class +Dog +Animal)
Line 1,677:
(class +Lab +Dog)
 
(class +Collie +Dog)</langsyntaxhighlight>
<langsyntaxhighlight PicoLisplang="picolisp">: (dep '+Animal)
+Animal
+Cat
+Dog
+Collie
+Lab</langsyntaxhighlight>
 
=={{header|PowerShell}}==
{{works with|PowerShell|5}}
<syntaxhighlight lang="powershell">
<lang PowerShell>
class Animal {}
class Dog : Animal {}
Line 1,693:
class Lab : Dog {}
class Collie : Dog {}
</syntaxhighlight>
</lang>
 
=={{header|PureBasic}}==
Although PureBasic is mostly used for procedural coding it has both the ability to interact with object oriented libraries and code and also the capacity to write it if needed.
===Native version===
<langsyntaxhighlight PureBasiclang="purebasic">Interface Animal
Eat()
Sleep()
Line 1,718:
Interface Collie Extends Dog
HeardSheep()
EndInterface</langsyntaxhighlight>
===Simple OOP Version===
Using the open-source precompiler [http://www.development-lounge.de/viewtopic.php?t=5915 SimpleOOP].
<langsyntaxhighlight PureBasiclang="purebasic">Class Animal
EndClass
 
Line 1,747:
*Lassie.Collie = NewObject.Collie
*Lassie\Bark()
*Lassie\Fetch()</langsyntaxhighlight>
 
=={{header|Python}}==
Unrevised style classes:
<langsyntaxhighlight lang="python">class Animal:
pass #functions go here...
 
Line 1,764:
 
class Collie(Dog):
pass #functions go here...</langsyntaxhighlight>
 
New style classes:
<langsyntaxhighlight lang="python">import time
 
class Animal(object):
Line 1,813:
buddy = Labrador()
buddy.kill()
print "Felix has",felix.lives, "lives, ","Buddy is %salive!"%("" if buddy.alive else "not ")</langsyntaxhighlight>
{{out}}
<pre>
Line 1,822:
===S3===
Inheritance is implemented by setting the object's class attribute with a character vector.
<langsyntaxhighlight Rlang="r">aCollie <- "woof"
class(aCollie) <- c("Collie", "Dog", "Animal")</langsyntaxhighlight>
===S4===
Inheritance is implemented by using the 'contains' argument in setClass
<langsyntaxhighlight Rlang="r">setClass("Animal", representation(), prototype())
setClass("Dog", representation(), prototype(), contains="Animal")
setClass("Cat", representation(), prototype(), contains="Animal")
setClass("Collie", representation(), prototype(), contains="Dog")
setClass("Lab", representation(), prototype(), contains="Dog")</langsyntaxhighlight>
 
=={{header|Racket}}==
 
<langsyntaxhighlight lang="racket">
#lang racket
 
Line 1,848:
(check-true (is-a? (new dog%) animal%))
(check-false (is-a? (new collie%) cat%))
</syntaxhighlight>
</lang>
 
=={{header|Raku}}==
Line 1,854:
 
{{works with|Rakudo|2015-09-16}}
<syntaxhighlight lang="raku" perl6line>class Animal {}
class Dog is Animal {}
class Cat is Animal {}
Line 1,861:
 
say Collie.^parents; # undefined type object
say Collie.new.^parents; # instantiated object</langsyntaxhighlight>
{{out}}
<pre>((Dog) (Animal))
Line 1,869:
 
=={{header|REBOL}}==
<langsyntaxhighlight REBOLlang="rebol">REBOL [
Title: "Inheritance"
URL: http://rosettacode.org/wiki/Inheritance
Line 1,894:
print ["Cat has" Cat/legs "legs."]
 
print ["Lab says:" Lab/says]</langsyntaxhighlight>
 
{{out}}
Line 1,901:
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">
Class Animal
Class Dog from Animal
Line 1,907:
Class Lab from Dog
Class Collie from Dog
</syntaxhighlight>
</lang>
 
=={{header|Ruby}}==
<code>inherited</code> is a method defined on an instance of a <code>Class</code> object. It is invoked when a new subclass of the current class is defined (i.e. at the <code>end</code> statement of a <code>class</code> definition).
<langsyntaxhighlight lang="ruby">class Animal
#functions go here...
def self.inherited(subclass)
Line 1,932:
class Collie < Dog
#functions go here...
end</langsyntaxhighlight>
 
{{out}}
Line 1,942:
=={{header|Rust}}==
A type can't inherit properties from other types, but it can implmement any number of traits, which may themselves be subtraits of other traits.
<langsyntaxhighlight Rustlang="rust">trait Animal {}
trait Cat: Animal {}
trait Dog: Animal {}
trait Lab: Dog {}
trait Collie: Dog {}</langsyntaxhighlight>
 
=={{header|Scala}}==
Line 1,957:
any (or all) of the <code>class</code> keywords below can be replaced with <code>trait</code>
 
<langsyntaxhighlight lang="scala">class Animal
class Dog extends Animal
class Cat extends Animal
class Lab extends Dog
class Collie extends Dog</langsyntaxhighlight>
 
=={{header|Seed7}}==
Line 1,967:
The example below defines a hierarchy of implementation types.
 
<langsyntaxhighlight lang="seed7">$ include "seed7_05.s7i";
 
const type: Animal is new struct
Line 1,987:
const type: Cat is sub Animal struct
# ...
end struct;</langsyntaxhighlight>
 
=={{header|Self}}==
Self is a class-free, object-oriented language, and as such, it uses prototypal inheritance instead of classical inheritance. This is an example of the relevant excerpts from a Self transporter fileout. Normally the object tree would be built and navigated within the graphical Self environment.
<langsyntaxhighlight lang="self">animal = ()</langsyntaxhighlight>
<langsyntaxhighlight lang="self">dog = (| parent* = animal |)</langsyntaxhighlight>
<langsyntaxhighlight lang="self">cat = (| parent* = animal |)</langsyntaxhighlight>
<langsyntaxhighlight lang="self">lab = (| parent* = dog |)</langsyntaxhighlight>
<langsyntaxhighlight lang="self">collie = (| parent* = dog |)</langsyntaxhighlight>
 
=={{header|Sidef}}==
<langsyntaxhighlight lang="ruby">class Animal {};
class Dog << Animal {};
class Cat << Animal {};
class Lab << Dog {};
class Collie << Dog {};</langsyntaxhighlight>
 
=={{header|Simula}}==
<langsyntaxhighlight lang="simula">begin
 
class Animal;
Line 2,029:
end;
 
end</langsyntaxhighlight>
 
=={{header|Slate}}==
<langsyntaxhighlight lang="slate">define: #Animal &parents: {Cloneable}.
define: #Dog &parents: {Animal}.
define: #Cat &parents: {Animal}.
define: #Lab &parents: {Dog}.
define: #Collie &parents: {Dog}.</langsyntaxhighlight>
 
=={{header|Smalltalk}}==
This is an example of the object serialization format used by many varieties of Smalltalk. Normally the class tree would be defined and navigated via a class browser within a graphical Smalltalk environment.
<langsyntaxhighlight lang="smalltalk">Object subclass: #Animal
instanceVariableNames: ' ' "* space separated list of names *"
classVariableNames: ' '
Line 2,062:
 
!Dog subclass: #Collie
"* etc. *" !</langsyntaxhighlight>
 
=={{header|Swift}}==
<langsyntaxhighlight lang="swift">class Animal {
// ...
}
Line 2,083:
class Cat : Animal {
// ...
}</langsyntaxhighlight>
 
=={{header|Tcl}}==
{{works with|Tcl|8.6}} or {{libheader|TclOO}}
<langsyntaxhighlight lang="tcl">package require TclOO
oo::class create Animal {
# ...
Line 2,106:
superclass Dog
# ...
}</langsyntaxhighlight>
 
=={{header|TXR}}==
Line 2,112:
====Inheritance among symbolic exception tags====
 
<langsyntaxhighlight lang="txr">@(defex cat animal)
@(defex lab dog animal)
@(defex collie dog)</langsyntaxhighlight>
 
The second line is a shorthand which defines a lab to be a kind of dog, and at the same time a dog to be a kind of animal.
Line 2,120:
If we throw an exception of type <code>lab</code>, it can be caught in a catch for a <code>dog</code> or for an <code>animal</code>. Continuing with the query:
 
<langsyntaxhighlight lang="txr">@(try)
@ (throw lab "x")
@(catch animal (arg))
@(end)</langsyntaxhighlight>
 
{{out}} Test:
Line 2,131:
====OOP Inheritance in TXR Lisp====
 
<langsyntaxhighlight lang="txrlisp">(defstruct animal nil
name
(:method get-name (me)
Line 2,153:
(pet2 (new cat name "Max")))
pet1.(speak)
pet2.(speak))</langsyntaxhighlight>
 
{{out}}
Line 2,161:
 
=={{header|Visual Basic .NET}}==
<langsyntaxhighlight lang="vbnet">Class Animal
' ...
End Class
Line 2,183:
Inherits Animal
' ...
End Class</langsyntaxhighlight>
 
=={{header|Vorpal}}==
<langsyntaxhighlight lang="vorpal">pet = new()
cat = new(pet)
dog = new(pet)
fido = new(dog)
felix = new(cat)</langsyntaxhighlight>
 
=={{header|Wren}}==
<langsyntaxhighlight lang="ecmascript">class Animal {
// methods
}
Line 2,211:
class Collie is Dog {
// methods
}</langsyntaxhighlight>
 
=={{header|XLISP}}==
<langsyntaxhighlight lang="lisp">(define-class animal)
 
(define-class dog
Line 2,226:
 
(define-class lab
(super-class dog))</langsyntaxhighlight>
A REPL session:
<langsyntaxhighlight lang="lisp">[1] (cat 'superclass)
 
#<Class:ANIMAL #x57094c8>
Line 2,248:
IVARCNT = 0
IVARTOTAL = 0
#<Class:DOG #x57094c8></langsyntaxhighlight>
 
=={{header|zkl}}==
<langsyntaxhighlight lang="zkl">class Animal{}
class Dog(Animal){} class Cat(Animal){}
class Lab(Dog){} class Collie(Dog){}
Collie.linearizeParents</langsyntaxhighlight>
{{out}}
<pre>
Thundergnat
10,327

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/327729"