Inheritance/Single: Difference between revisions

{{trans|Python}}

{

}

T Collie(Dog)

{

=={{header|ActionScript}}==

// ...

// ...

// ...

// ...

// ...

=={{header|Ada}}==

type Animal is tagged private;

type Dog is new Animal with private;

type Lab is new Dog with null record;

type Collie is new Dog with null record;

=={{header|Aikido}}==

//functions go here...

//functions go here...

//functions go here...

//functions go here...

//functions go here...

=={{header|AmigaE}}==

OBJECT animal

ENDOBJECT

OBJECT collie OF dog

ENDOBJECT

=={{header|AppleScript}}==

end script

script Collie

property parent : Dog

=={{header|AutoHotkey}}==

AutoHotkey_L is prototype-based. However, for convenience, class-syntax may be used to create a base object.

MsgBox, % "A " dog.__Class " is a " dog.base.base.__Class " and is part of the " dog.kingdom " kingdom."

}

class Collie extends Dog {

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

{{works with|BBC BASIC for Windows}}

DIM Animal{method}

DIM Collie{method}

PROC_inherit(Collie{}, Dog{})

=={{header|C}}==

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

{

/* ... */

/* ... */

// ...

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

{

// ...

{

// ...

=={{header|ChucK}}==

//functions go here...

//functions go here...

//functions go here...

//functions go here...

//functions go here...

=={{header|Clojure}}==

This is not very useful in clojure

(gen-class :name Dog :extends Animal)

(gen-class :name Cat :extends Animal)

(gen-class :name Lab :extends Dog)

More useful:

(derive ::cat ::animal)

(derive ::lab ::dog)

use:

true

user> (isa? ::dog ::cat)

false

user> (isa? ::collie ::animal)

=={{header|COBOL}}==

*> ...

END CLASS Animal.

*> ...

=={{header|Coco}}==

class Cat extends Animal

class Dog extends Animal

class Lab extends Dog

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:

(@name) ->

sam.move!

=={{header|Comal}}==

{{works with|UniComal}}

{{works with|AmiComal}}

DIM Species$ OF 20

ENDSTRUC Animal

Race$:="Collie"

ENDFUNC New

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

Using CLOS classes, we have the following:

(defclass dog (animal) ())

(defclass lab (dog) ())

(defclass collie (dog) ())

Alternatively, since there is no multiple inheritance in the task requirement, structures could also be used:

(defstruct (dog (:include animal)))

(defstruct (lab (:include dog)))

(defstruct (collie (:include dog)))

(Structures are less flexible than CLOS objects but often somewhat more efficiently implemented, due to those restrictions.)

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.

;;; ASN.1 serialization logic specialized for animal class

(defmethod serialize-to-asn-1 ((a animal))

(defmethod serialize-to-asn-1 ((s string))

#| ... #|

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.

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

TYPE

Animal = ABSTRACT RECORD (* *) END;

Lab = RECORD (Dog) (* *) END;

Collie = RECORD (Dog) (* *) END;

=={{header|D}}==

// ...

}

}

=={{header|Delphi}}==

Animal = class(TObject)

private

Cat = class(Animal);

Collie = class(Dog);

=={{header|DWScript}}==

Animal = class(TObject)

private

type Cat = class(Animal) end;

type Collie = class(Dog) end;

=={{header|E}}==

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.

def stamp {

to audit(audition) {

}

return [guard, stamp]

Setting up the task's specified tree:

def [Cat, CatStamp] := makeType("Cat", [AnimalStamp])

def [Lab, LabStamp] := makeType("Lab", [DogStamp])

Some example objects:

def tom implements CatStamp {}

Testing against the types:

# value: <fido>

? brick :Animal

=={{header|Eiffel}}==

ANIMAL

DOG

inherit

ANIMAL

CAT

inherit

ANIMAL

LAB

inherit

DOG

COLLIE

inherit

DOG

=={{header|Elena}}==

ELENA 4.x :

{

// ...

{

// ...

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

class // explicit syntax needed for empty class

end

type Cat() =

=={{header|Factor}}==

TUPLE: dog < animal ;

TUPLE: cat < animal ;

TUPLE: lab < dog ;

=={{header|Fancy}}==

# ...

}

class Collie : Dog {

# ...

=={{header|Fantom}}==

{

}

class Collie : Dog

{

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

:: Animal class end-class {} ;

:: Cat extends Animal end-extends {} ;

:: Lab extends Dog end-extends {} ;

Needs the FMS2 library code located here:

https://github.com/DouglasBHoffman/FMS2

:class Animal ;class

:class Cat <super Animal ;class

:class Lab <super Dog ;class

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

type animal

end type collie

=={{header|FreeBASIC}}==

Type Animal Extends Object ' to enable virtual methods etc. if needed

Type Collie Extends Dog

' ...

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

type animal struct {

pet.color = "yellow"

}

=={{header|Groovy}}==

//contents go here...

//contents go here...

//contents go here...

//contents go here...

//contents go here...

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

class Animal a => Cat a

class Animal a => Dog a

class Dog a => Lab a

=={{header|Haxe}}==

// ...

// ...

// ...

// ...

// ...

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

This example only works in Unicon.

class Animal ()

end

class Collie : Dog ()

end

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

A cat is a kind of animal.

A dog is a kind of animal.

A collie is a kind of dog.

"Animal" is actually a predefined kind in Inform 7, so its definition here is redundant (but legal).

=={{header|Io}}==

Cat := Animal clone

Dog := Animal clone

Collie := Dog clone

=={{header|J}}==

Here is how this would normally be done:

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

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:

coinsert_Cat_ 'Animal'

coinsert_Lab_ 'Dog'

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

//functions go here...

//functions go here...

//functions go here...

//functions go here...

//functions go here...

=={{header|JavaScript}}==

JavaScript is a class-free, object-oriented language, and as such, it uses prototypal inheritance instead of classical inheritance.

// ...

// ...

}

// ...

}

// ...

}

// ...

}

var lab = new Lab();

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

abstract type Animal end

abstract type Dog <: Animal end

struct Lab <: Dog end

struct Collie <: Dog end

=={{header|Kite}}==

#Method goes here

];

#Method goes here

];

=={{header|Kotlin}}==

open class Animal {

println("Bella is a $bella")

println("Casey is a $casey")

{{out}}

=={{header|Lasso}}==

data public gender::string

}

#myanimal -> gender = 'Male'

-> Male

Latitude is a prototype-oriented language, so defining a subclass is equivalent to constructing an instance.

Animal ::= Object clone tap {

;; Methods go here...

Collie ::= Dog clone tap {

;; Methods go here...

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

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

property ancestor

me.ancestor = script("Animal").new()

return me

property ancestor

me.ancestor = script("Animal").new()

return me

property ancestor

me.ancestor = script("Dog").new()

return me

property ancestor

me.ancestor = script("Dog").new()

return me

=={{header|Lisaac}}==

+ name := ANIMAL;

+ name := CAT;

Section Inherit

- parent : ANIMAL := ANIMAL;

+ name := DOG;

Section Inherit

- parent : ANIMAL := ANIMAL;

+ name := LAB;

Section Inherit

- parent : DOG := DOG;

+ name := COLLIE;

Section Inherit

- parent : DOG := DOG;

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

:- object(thing,

instantiates(thing)).

specializes(dog)).

...

=={{header|Lua}}==

Lua has no in-built formal OOP mechanism, though there are many possible ways of implementing work-alikes.

classname = "Class aka Object aka Root-Of-Tree",

new = function(s,t)

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)

{{out}}

<pre>Animal:speak(): (Animal has no voice)

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

Module CheckIt {

Class Animal {

}

CheckIt

=={{header|Neko}}==

var Dog = $new(null);

var Collie = $new(null);

=={{header|Nemerle}}==

// ...

}

class Cat: Animal {

// ...

=={{header|NetRexx}}==

For brevity, all classes are defined within the same source file. Normally classes exist as separate source units.

options replace format comments java crossref symbols binary

-- Do Collie specific set-up

return

{{out}}

<pre>

=={{header|Nim}}==

Animal = object of RootObj

Dog = object of Animal

Cat = object of Animal

Lab = object of Dog

=={{header|Oberon}}==

Tested with [https://miasap.se/obnc OBNC].

TYPE

END Animals.

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

Works with oo2c Version 2

MODULE Animals;

TYPE

END Animals.

=={{header|Objeck}}==

{ #~ ... ~# }

class Cat from Animal

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

{

// ...

}

// ...

=={{header|OCaml}}==

object (self)

(*functions go here...*)

object (self)

inherit animal

(*functions go here...*)

object (self)

inherit animal

(*functions go here...*)

object (self)

inherit dog

(*functions go here...*)

object (self)

inherit dog

(*functions go here...*)

=={{header|Oforth}}==

Animal Class new: Cat

Animal Class new: Dog

Dog Class new: Lab

=={{header|ooRexx}}==

-- subclass of object by default

::class animal

::class collie subclass dog

=={{header|OxygenBasic}}==

class animal

method show() as string

Collie c

print c.show 'result: Animal Dog Collie

=={{header|Oz}}==

%% ...

end

class Cat from Animal

%% ...

=={{header|Pascal}}==

=={{header|Perl}}==

#functions go here...

use Animal;

@ISA = qw( Animal );

#functions go here...

use Animal;

@ISA = qw( Animal );

#functions go here...

use Dog;

@ISA = qw( Dog );

#functions go here...

use Dog;

@ISA = qw( Dog );

#functions go here...

The same using the [http://search.cpan.org/perldoc?MooseX::Declare MooseX::Declare] module:

class Animal {

class Collie extends Dog {

# methods go here...

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

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

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

=={{header|PHP}}==

// functions go here...

}

class Collie extends Dog {

// functions go here...

=={{header|PicoLisp}}==

(class +Dog +Animal)

(class +Lab +Dog)

+Animal

+Cat

+Dog

+Collie

=={{header|PowerShell}}==

{{works with|PowerShell|5}}

class Animal {}

class Dog : Animal {}

class Lab : Dog {}

class Collie : Dog {}

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

Eat()

Sleep()

Interface Collie Extends Dog

HeardSheep()

===Simple OOP Version===

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

EndClass

*Lassie.Collie = NewObject.Collie

*Lassie\Bark()

=={{header|Python}}==

Unrevised style classes:

pass #functions go here...

class Collie(Dog):

New style classes:

class Animal(object):

buddy = Labrador()

buddy.kill()

{{out}}

<pre>

===S3===

Inheritance is implemented by setting the object's class attribute with a character vector.

===S4===

Inheritance is implemented by using the 'contains' argument in setClass

setClass("Dog", representation(), prototype(), contains="Animal")

setClass("Cat", representation(), prototype(), contains="Animal")

setClass("Collie", representation(), prototype(), contains="Dog")

=={{header|Racket}}==

#lang racket

(check-true (is-a? (new dog%) animal%))

(check-false (is-a? (new collie%) cat%))

=={{header|Raku}}==

{{works with|Rakudo|2015-09-16}}

class Dog is Animal {}

class Cat is Animal {}

say Collie.^parents; # undefined type object

{{out}}

<pre>((Dog) (Animal))

=={{header|REBOL}}==

Title: "Inheritance"

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

print ["Cat has" Cat/legs "legs."]

{{out}}

=={{header|Ring}}==

Class Animal

Class Dog from Animal

Class Lab from Dog

Class Collie from Dog

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

#functions go here...

def self.inherited(subclass)

class Collie < Dog

#functions go here...

{{out}}