Abstract type: Difference between revisions

'''Task''': show how an abstract type can be declared in the language. If the language makes a distinction between interfaces and partially implemented types illustrate both.

 

 

=={{header|AArch64 Assembly}}==

 

=={{header|ABAP}}==

=== Abstract Class ===

public section.

methods method1 abstract importing iv_value type f exporting ev_ret type i.

ev_ret = iv_a + iv_b.

endmethod.

 

=== Interfaces ===

2. Variables must be static final. The values may be computed at run time.

3. No static initialiser blockers. No static initialiser helper methods.

methods: method1 importing iv_value type f exporting ev_ret type i,

method2 importing iv_name type string exporting ev_ret type i,

add importing iv_a type i iv_b type i exporting ev_ret type i.

 

=={{header|ActionScript}}==

While ActionScript does not support explicit abstract classes, it does have interfaces. Interfaces in ActionScript may not implement any methods and all methods are public and implicitly abstract. Interfaces can extend other interfaces, and interfaces may be multiply inherited.

{

public interface IInterface

function method2(arg1:Array, arg2:Boolean):uint;

}

 

Abstract types can also be simulated using the built-in <code>flash.utils.getQualifiedClassName()</code> function in the constructor to check that the runtime type is an inhertied class, and throwing exceptions from "abstract" methods which can be overridden by inheritors to disable them. If any inheriting class does not implement an abstract method, the error will not be thrown until the non-implemented method is called.

package {

import flash.utils.getQualifiedClassName;

}

}

 

Inheriting this class:

package {

 

}

}

 

=={{header|Ada}}==

===Interface===

Interfaces in [[Ada]] may have no components or implemented operation except for ones implemented as null operations. Interfaces can be multiply inherited.

procedure Enqueue (Lounge : in out Queue; Item : in out Element) is abstract;

Interfaces can be declared synchronized or task when intended implementations are to be provided by protected objects or [[task]]s. For example:

===Abstract type===

Abstract types may provide components and implementation of their operations. Abstract types are singly inherited.

...

type Node is abstract new Ada.Finalization.Limited_Controlled and Queue with record

overriding procedure Dequeue (Lounge : in out Node; Item : in out Element);

overriding procedure Enqueue (Lounge : in out Node; Item : in out Element);

Here Node is an abstract type that is inherited from Limited_Controlled and implements a node of a [[Doubly-Linked List (element) | doubly linked list]]. It also implements the interface of a queue described above, because any node can be considered a head of the queue of linked elements. For the operation Finalize an implementation is provided to ensure that the element of a list is removed from there upon its finalization. The operation itself is inherited from the parent type Limited_Controlled and then overridden. The operations Dequeue and Enqueue of the Queue interface are also implemented.

 

Using [http://wiki.portal.chalmers.se/agda/agda.php?n=ReferenceManual.Records records] for storing the interface methods and [http://wiki.portal.chalmers.se/agda/pmwiki.php?n=ReferenceManual.InstanceArguments instance arguments] (which are [http://wiki.portal.chalmers.se/agda/pmwiki.php?n=ReferenceManual.ModellingTypeClassesWithInstanceArguments similar] to Haskell type classes) for overloading:

 

 

open import Function

-- say (cat crazy!) => "meeeoooowwwww!!!"

-- say (cat plain-cat) => "meow!"

 

There is <code>dog</code> and <code>cat</code> is objects of different types for which the interface method is implemented.

An abstract class contains functions that have no body defined. You cannot instantiate a class that contains abstract functions.

 

public function method1...

public function method2...

 

Interfaces in Aikido define a set of functions, operators, classes, interfaces, monitors or threads (but no variables) that must be implemented by a class implementing the interface.

function isFatal : integer

function operate (para : integer = 0)

operator -> (stream, isout)

 

=={{header|AmigaE}}==

In AmigaE, abstract methods are supported but interfaces are not.

 

OBJECT fruit

ENDOBJECT

FORALL({x},[NEW a, NEW o],`x.color())

ENDPROC

prints to the console:

 

 

=={{header|Apex}}==

// Interface

public interface PurchaseOrder {

public override Integer abstractMethod() { return 5; }

}

 

=={{header|Argile}}==

{{works with|Argile|1.0.0}}

 

(: abstract class :)

foobar (new Sub 34) (: prints 46 :)

foobar (new Sub) (: prints 11 :)

 

 

 

=={{header|AutoHotkey}}==

{{works with | AutoHotkey_L}}

static color

If !color

msgbox % blue.GetRGB() ; displays 255

return

 

{{works with|BBC BASIC for Windows}}

BBC BASIC is a procedural language with no built-in OO features. The CLASSLIB library implements simple Object Classes with multiple inheritance; an abstract class may be created without any instantiation, the sole purpose of which is for other classes to inherit from it. At least one member or method must be declared, but no error will be generated if there is no implementation:

REM Declare a class with no implementation:

REM Test by calling the method:

 

=={{header|C}}==

 

The header file for the abstract class, interfaceAbs.h

#define INTERFACE_ABS

 

do { if (c) { free((c)->instData); free(c); } } while(0);

That will define the abstract class. The next section declares a public interface for a class providing the interface of the abstract class. This class is Silly and

the code is in file silly.h. Note the actual structure of the class is not provided

here. We don't want it visible.

#define SILLY_H

#include "intefaceAbs.h"

extern AbsCls Silly_Instance(void *);

 

Ok. Now it is necessary to provide the implementation of the realizable class.

This code should be in silly.c.

#include <string.h>

#include <stdio.h>

}

 

That last macro, ABSTRACT_METHODS may need a little explanation. First note that macros do a string substitution of the parameter values into the arguments of the defined macro, with a little hitch. In the macro definition the ' ## ' expression is special. Here cName ## _Iface gets converted to Silly_Iface, as 'Silly' replaces cName. So the macro call declares an instance of the class record, and defines a constructor named Silly_Instance, which takes a Silly structure as an arguments

and uses the class record it previously set up as well.

 

Now all's left is some example code that uses all this stuff.

#include "silly.h"

 

return 0;

}

 

{

public abstract void method1();

return 0;

}

 

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

You can declare a virtual function to not have an implementation (called "pure virtual function") by the following "<tt>= 0</tt>" syntax after the method declaration. A class containing at least one pure virtual function (or inheriting one and not overriding it) cannot be instantiated.

public:

virtual int method1(double value) = 0;

return a+b;

}

Because C++ allows multiple inheritance of classes, no distinction is made between interfaces and abstract classes.

 

In Caché, abstract and data type classes cannot be instantiated directly - there must be a 'concrete subclass' that extends them as well as the '%RegisteredObject' class in order to instantiate an object, see example below.

 

{

Parameter SHAPE = 1;

Write ..%ClassName()_$Case(..%Extends(..%PackageName()_".Shape"), 1: " is a ", : " is not a ")_"shape"

}

 

Data type classes differ because they cannot contain properties, see example below.

 

{

Parameter SHAPE = 1;

Write ..%ClassName()_$Case(..%Extends(..%PackageName()_".Shape"), 1: " is a ", : " is not a ")_"shape"

}

 

Both class types can contain implementation code. Caché allows multiple inheritance of classes, so no distinction is made between abstract classes and interfaces.

Using defprotocol, we can define what is essentially an interface.

 

 

=={{header|COBOL}}==

===Interface===

{{trans|F#}}

PROCEDURE DIVISION.

METHOD-ID. perimeter.

DATA DIVISION.

END METHOD perimeter.

METHOD-ID. shape-area.

DATA DIVISION.

 

CLASS-ID. Rectangle.

INTERFACE Shape.

OBJECT IMPLEMENTS Shape.

DATA DIVISION.

PROCEDURE DIVISION.

METHOD-ID. perimeter.

DATA DIVISION.

01 ret USAGE FLOAT-LONG.

PROCEDURE DIVISION RETURNING ret.

END METHOD perimeter.

METHOD-ID. shape-area.

DATA DIVISION.

01 ret USAGE FLOAT-LONG.

PROCEDURE DIVISION RETURNING ret.

END METHOD shape-area.

END OBJECT.

 

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

In Common Lisp, classes do not implement methods, but methods specialized for particular kinds of arguments may be defined for generic functions. Since we can programmatically determine whether methods are defined for a list of arguments, we can simulate a kind of abstract type. We define an abstract type <code>kons</code> to which an object belongs if methods for <code>kar</code> and <code>kdr</code> are defined for it. We define a type predicate <code>konsp</code> and a type <code>kons</code> in terms of the type predicate.

 

(:documentation "Return the kar of a kons."))

 

 

(deftype kons ()

 

We can make the built-in types <code>cons</code> and <code>integer</code> <code>kons</code>es. We start with <code>cons</code>, using the obvious definitions.

 

(car cons))

 

(typep (cons 1 2) 'kons) ; => t

(kar (cons 1 2)) ; => 1

 

For integers, we'll define the <code>kar</code> of <var>n</var> to be <var>1</var> and the <code>kdr</code> of <var>n</var> to be <var>n - 1</var>. This means that for an integer <var>n</var>, <var>n</var> = <code>(+ (kar <var>n</var>) (kdr <var>n</var>))</code>.

 

1)

 

(typep 45 'kons) ; => t

(kar 45) ; => 1

 

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

(* Abstract type *)

Object = POINTER TO ABSTRACT RECORD END;

x,y: REAL

END;

...

(* Abstract method of Object *)

PROCEDURE (dn: Object) Show*, NEW, ABSTRACT;

StdLog.Real(p.y);StdLog.String(");");StdLog.Ln

END Show;

 

For usage see tasks Stacks.

 

=={{header|Crystal}}==

abstract def move

abstract def think

# Animal.new # => can't instantiate abstract class

he = Human.new("Andrew") # ok

Note that "class" can be replaced with "struct" in the above example, because Crystal also supports abstract structs and their inheritance.

 

=={{header|D}}==

 

class Foo {

}

 

 

=={{header|Delphi}}==

Abstract Class introduced in Delphi 2006. An abstract class cannot be instantiated and must be derived from in order to be used.

 

...

 

 

Abstract Methods can only be implemented in derived classes. A concrete class that contains abstract methods can be instantiated. A warning will be generated at compile time, and an EAbstractError exception will thrown if the method is called at run time.

 

TMyObject = class(TObject)

public

begin

AbstractFunction; // Calling the abstract function

 

=={{header|DWScript}}==

A simple abstract type without enforcement can be created using the interface expression:

 

to bar(a :int, b :int)

 

With enforcement, a separate ''stamp'' is created which must be applied to the instances. This is analogous to a Java interface.

 

to bar(a :int, b :int)

}

return a - b

}

 

=={{header|Eiffel}}==

 

deferred class

AN_ABSTRACT_CLASS

 

end

 

A more expressive view of an Abstract type in Eiffel:

note

title: "Prototype Person"

 

end

=={{header|Elena}}==

 

{

abstract run();

}

 

=={{header|F Sharp|F#}}==

A type with only abstract members and without constructors is an '''interface''' (when not marked with the <code>AbstractClass</code> attribute). Example:

abstract Perimeter: unit -> float

abstract Area: unit -> float

interface Shape with

member x.Perimeter() = 2.0 * width + 2.0 * height

 

A type that leaves some or all members unimplemented, is an '''abstract class'''. It has to be marked with the <code>AbstractClass</code> attribute. Example:

type Bird() =

// an abstract (=virtual) method with default impl.

inherit Bird()

override x.Move() = printfn "walking"

 

=={{header|Fantom}}==

abstract class X

{

}

}

 

=={{header|Forth}}==

{{trans|Fantom}}

There are numerous, mutually incompatible object oriented frameworks for Forth. This one works with the FOOS preprocessor extension of [[4tH]].

 

:: X()

;

 

 

Works with any ANS Forth

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

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

 

The FMS object extension uses duck typing and so has no need for abstract types.

 

=={{header|Fortran}}==

Simple abstract derived type (i.e. abstract class) in Fortran 2008

! abstract derived type

type, abstract :: TFigure

end function calculate_area

end interface

 

=={{header|FreeBASIC}}==

However, you can effectively create an abstract type by declaring all its methods to be abstract, so that they do not require a body in the declaring type itself. Such methods can then be overridden and implemented by its derived types. For example :-

 

Type Animal Extends Object

Print

Print "Press any key to quit program"

 

{{out}}

=={{header|Genyris}}==

In Genyris by default there are no constructors. In effect all classes are Abstract until they are used to tag (describe) an object. This in keeping with the language's roots in Description Logic. To prevent the class ever being associated with an instance it suffices to force the validator to fail.

def .valid?(object) nil

 

 

However this is not much use if we want to use an abstract class to define an '''interface'''. Here is a quasi-abstract class which can be used to tag objects if they conform to the class's membership expectations. In this case it wants two methods, ''.enstack'' and ''.destack'':

def .valid?(object)

object

is-instance? .enstack Closure

bound? .destack

 

So if ever we find an object which conforms to the validator it can be tagged. Here's a 'traditional' class definition using the Object class which ''does'' provide a constructor:

def .init()

var .items ()

var tmp (car .items)

setq .items (cdr .items)

Now we can tag an object that conforms to the Interface:

 

=={{header|Go}}==

In the following example, the Dog and Cat types both satisfy the Beast interface because they each have the specified methods. The ''bprint'' function can print details for any Beast.

 

 

import "fmt"

bprint(d)

bprint(c)

 

{{out}}

 

As in [[Java]], methods that are declared but not implemented are called "abstract" methods. An interface is a class-level typing construct that can only contain abstract method declarations (well, and constants, but pay no attention to those).

int method1(double value)

int method2(String name)

int add(int a, int b)

 

An abstract class may implement some of its methods and leave others unimplemented. The unimplemented methods and the class itself must be declared "abstract".

abstract public int methodA(Date value)

abstract protected int methodB(String name)

int add(int a, int b) { a + b }

 

An abstract class may also be used to partially implement an interface. Here class "Abstract2" implements the "add" method from the inherited "Interface", but leaves the other two methods, "method1" and "method2", unimplemented. Abstract methods that an abstract class inherits from an interface or another abstract class do not have to be redeclared.

int add(int a, int b) { a + b }

 

Interfaces and abstract classes cannot be instantiated directly. There must be a "concrete subclass" that contains a complete implementation in order to instantiate an object.

public int method1(double value) { value as int }

public int method2(String name) { (! name) ? 0 : name.toList().collect { it as char }.sum() }

public int method1(double value) { value as int }

public int method2(String name) { (! name) ? 0 : name.toList().collect { it as char }.sum() }

 

Notice that there are no extra descriptive keywords on the interface method declarations. Interface methods are assumed to be both abstract and public.

 

Obligatory test:

assert c1 instanceof Interface

println (new Concrete1().method2("Superman"))

assert c3 instanceof Interface

assert c3 instanceof Abstract2

 

Obligatory test output:

 

For example, the built-in type class Eq (the types that can be compared for equality) can be declared as follows:

(==) :: a -> a -> Bool

 

Default implementations of the functions can be provided:

(==) :: a -> a -> Bool

(/=) :: a -> a -> Bool

x /= y = not (x == y)

Here default implementations of each of the operators is circularly defined in terms of the other, for convenience of the programmer; so the programmer only needs to implement one of them for it to work.

 

Consider the following function which uses the operator == of the type class Eq from above. The arguments to == above were of the unknown type "a", which is of class Eq, so the type of the expression below now must include this restriction:

 

Suppose I make a new type

 

One could then provide an implementation ("instance") the type class Eq with this type

(Foo x1 str1) == (Foo x2 str2) =

And now I can, for example, use the function "func" on two arguments of type Foo.

 

An abstract class is a class with abstract methods. Icon is not object-oriented.

 

abstract method compare(l,r) # generates runerr(700, "method compare()")

 

=={{header|J}}==

 

=={{header|Java}}==

 

}

 

=={{header|Julia}}==

 

Usage:

 

Examples:

abstract type Real <: Number end

abstract type FloatingPoint <: Real end

abstract type Integer <: Real end

abstract type Signed <: Integer end

 

See more [http://docs.julialang.org/en/latest/manual/types/#abstract-types]

 

Here's a very simple (and silly) example of both:

 

interface Announcer {

announceName() // inherits Announcer's implementation

}

 

{{out}}

=={{header|Lasso}}==

Instead of abstract classes or interfaces, Lasso uses a [http://lassoguide.com/language/types.html trait system].

require get(index::integer)

#test->second + "\n"

#test->third + "\n"

 

{{out}}

 

In some movie script:

-- 'raw' instance of abstract class is made parent ("ancestor") of the

-- passed instance, i.e. the passed instance extends the abstract class

instance.setProp(#ancestor, abstractClass.rawNew())

 

Parent script "AbstractClass":

on new (me)

-- optional: show error message as alert

put me.ringtone

end repeat

 

Parent script "MyClass"

 

on new (me)

on foo (me)

put "FOO"

 

Usage:

obj.ring(3)

-- "Bell"

test = script("AbstractClass").new()

put test

 

=== Interfaces ===

 

In some movie script:

interfaceFuncs = interfaceClass.handlers()

funcs = instance.handlers()

end repeat

return TRUE

 

Parent script "InterfaceClass":

(Note: in Lingo closing function definitions with "end" is optional, so this a valid definition of 3 empty functions)

on bar

 

Parent script "MyClass":

-- if this class doesn't implement all functions of the

-- interface class, instantiation fails

on foobar (me)

put "FOOBAR"

 

Usage:

put obj -- would show <Void> if interface is not fully implemented

 

=={{header|Logtalk}}==

 

Logtalk supports the definition of interfaces (protocols), which can contain public, protected, and private declarations of methods (predicates). In addition, an object can qualify an implements relation with an interface (protocol) using the keywords "public", "protected", and "private".

:- protocol(datep).

 

 

:- end_protocol.

 

=={{header|Lua}}==

Lua does not include built-in object oriented paradigms. These features can be added using simple code such as the following:

 

function class ( baseClass )

 

BaseClass.class = class

The 'class' function produces a new class from an existing parent class (BaseClass is default). From this class other classes or instances can be created. If a class is created through the 'abstractClass' function, however, the resulting class will throw an error if one attempts to instantiate it. Example:

AA = A:class() -- New class AA inherits from existing class A

B = abstractClass() -- New abstract class B

AA:new() -- Okay: New class instance

B:new() -- Error: B is abstract

 

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

M2000 not use interfaces, but can combine groups (used as objects), and because we can alter definitions, we can make an Abstract group by implement modules and functions with a call to Error "not implement yet"

Private:

      x as double=1212, z1 as currency=1000, k$="ok"

      \\ we can use For Object {} and a dot before members to get access

      Print .z=1050.12, ExpType$(.z), Type$(.z) ' true, Currency, Group

 

 

Mathematica is a symbolic language and as such does not support traditional object oriented design patterns. However, it is quite easy to define pseudo-interfaces that depend on an object implementing a set of functions:

 

(* Define an interface, Foo, which requires that the functions Foo, Bar, and Baz be defined *)

InterfaceFooQ[obj_] := ValueQ[Foo[obj]] && ValueQ[Bar[obj]] && ValueQ[Baz[obj]];

(* And finally a non-specific string *)

PrintFoo["foobarbaz"]

{{out}}

<pre>

=={{header|MATLAB}}==

; Abstract Class

...

For classes that declare the Abstract class attribute:

* Concrete subclasses must redefine any properties or methods that are declared as abstract.

When you define any abstract methods or properties, MATLAB® automatically sets the class Abstract attribute to true.

; Abstract Methods

abstMethod(obj)

For methods that declare the Abstract method attribute:

* Do not use a function...end block to define an abstract method, use only the method signature.

* Concrete subclasses are not required to support the same number of input and output arguments and do not need to use the same argument names. However, subclasses generally use the same signature when implementing their version of the method.

; Abstract Properties

AbsProp

For properties that declare the Abstract property attribute:

* Concrete subclasses must redefine abstract properties without the Abstract attribute.

these features by default for all tpyes.

 

:- interface.

 

A == B :- (A^x = B^x, A^str = B^str),

A \= B :- not A == B

 

=={{header|Nemerle}}==

 

namespace RosettaCode

}

}

 

=={{header|NetRexx}}==

options replace format comments java crossref symbols binary

 

method callOverridden2() public returns String

return super.canOverride2

;Output

<pre>

</pre>

 

 

; url: http://rosettacode.org/wiki/Abstract_type

; author: oofoe 2012-01-28

(:draw (Rectangle "R" 32 4))

 

 

Sample output:

=={{header|Nim}}==

In Nim type classes can be seen as an abstract type. Type classes specify interfaces, which can be instantiated by concrete types.

Comparable = concept x, y

(x < y) is bool

for value in s:

 

=={{header|Nit}}==

Source: [https://github.com/nitlang/nit/blob/master/examples/rosettacode/abstract_type.nit the official Nit’s repository]

 

#

# Methods without implementation are annotated `abstract`.

fun method2: Int do return 1

var attr: Int

 

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

{{Works with|oo2c Version 2}}

TYPE

Animal = POINTER TO AnimalDesc;

Cat = POINTER TO CatDesc;

CatDesc = RECORD (AnimalDesc) END;

 

=={{header|Objeck}}==

class ClassA {

method : virtual : public : MethodA() ~ Int;

}

}

 

=={{header|OCaml}}==

The equivalent of what is called abstract type in the other OO examples of this page is just called '''virtual''' in Objective Caml to define '''virtual methods''' and '''virtual classes''':

 

object

method virtual bar : int

 

===Abstract Type===

 

In OCaml what we call an abstract type is not OO related, it is only a type defined without definition, for example:

it is used for example to hide an implementation from the interface of a module or for type algebra.

 

Example of abstracting a type in an interface:

type t

end = struct

type t = int * int

 

Pure abstract types in the implementation:

type v

type 'a t

type ut = u t

 

=={{header|Oforth}}==

Unlike interfaces, properties can include method implementations and attributes (see lang/Comparable.of for instance).

 

Spherical method: radius @r ;

Spherical method: setRadius := r ;

Object Class new: Planete(name)

Planete is: Spherical

 

Usage :

| b p |

Ballon new($red, 0.1) ->b

System.Out "Earth perimeter is : " << p perimeter << cr

System.Out "Earth surface is : " << p surface << cr

 

{{out}}

 

===Interface===

-- shape is the interface class that defines the methods a shape instance

-- is expected to implement as abstract methods. Instances of the shape

 

::method name

{{out}}

<pre>a RECTANGLE

 

===Abstract Type===

-- shape is the abstract class that defines the abstract method area

-- which is then implemented by its two subclasses, rectangle and circle

expose radius

numeric digits 20

{{out}}

<pre>a RECTANGLE

<pre>

 

 

 

 

end class

 

</pre>

There are no abstract types as part of the language, but we can do as in Python and raise exceptions:

 

class BaseQueue

attr

end

 

 

GP is not object-oriented and cannot sensibly use abstract types. PARI can use the same solution as [[#C|C]].

 

In ObjectPascal mode FreePascal has classes and abstract methods.

 

=={{header|Perl}}==

 

 

use strict;

 

 

Since Perl 5.12, the Yadda Yadda operator (...) dies with an Unimplemented error,

 

package AbstractFoo;

 

1;

Raku inspired roles are provided by the [http://search.cpan.org/perldoc?Moose Moose] library

 

 

use Moose::Role;

}

 

Roles are also provided in a more lightweight form with [http://search.cpan.org/perldoc?Role::Tiny Role::Tiny] library

 

 

use Role::Tiny;

}

 

 

=={{header|Phix}}==

 

You can also have explicitly abstract classes (and/or abstract methods). Needs 0.8.1+

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

<span style="color: #004080;">integer</span> <span style="color: #000000;">id</span>

<span style="color: #000000;">errand</span> <span style="color: #000000;">e</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">new</span><span style="color: #0000FF;">({</span><span style="color: #000000;">2</span><span style="color: #0000FF;">})</span>

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

{{out}}

<pre>

 

Methods that don't have an implementation are called abstract methods in PHP. A class that contains an abstract method or inherits one but did not override it must be an abstract class; but an abstract class does not need to contain any abstract methods. An abstract class cannot be instantiated. If a method is abstract, it must be public or protected

abstract public function method1($value);

abstract protected function method2($name);

return a + b;

}

Interfaces in PHP may not implement any methods and all methods are public and implicitly abstract.

public function method1($value);

public function method2($name);

public function add($a, $b);

 

=={{header|PicoLisp}}==

# There is just a naming convention where abstract classes start with a

# lower-case character after the '+' (the naming convention for classes).

(dm someMethod> ()

(foo)

 

=={{header|PowerShell}}==

#Requires -Version 5.0

 

}

}

Create a new player:

$player1 = [Player]::new("sam bradford", "philadelphia eagles", "qb", 7)

$player1

{{Out}}

<pre>

</pre>

Trade the player:

$player1.Trade("minnesota vikings", 8)

$player1

{{Out}}

<pre>

</pre>

Create a new player:

$player2 = [Player]::new("demarco murray", "philadelphia eagles", "rb", 29)

$player2

{{Out}}

<pre>

</pre>

Trade the player:

$player2.Trade("tennessee titans")

$player2

{{Out}}

<pre>

=={{header|Python}}==

 

"""Abstract/Virtual Class

"""

def Print_Contents(self):

for i in self.contents:

 

Python allows multiple inheritance and it's more common to implement "mix-in" classes rather than abstract interfaces. (Mix-in classes can implement functionality as well define interfaces).

 

Starting from Python 2.6, abstract classes can be created using the standard abc module:

 

class BaseQueue():

def Print_Contents(self):

for i in self.contents:

 

=={{header|Racket}}==

 

#lang racket

 

(define tom (new cat%))

(send tom say)

 

=={{header|Raku}}==

Raku supports roles, which are a bit like interfaces, but unlike interfaces in Java they can also contain some implementation.

 

use v6;

 

# made concrete in class

# 42

 

=={{header|REBOL}}==

Title: "Abstract Type"

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

 

print [crlf "A rectangle:"]

 

=={{header|Red}}==

Title: "Abstract Type"

Original-Author: oofoe

 

print [newline "A rectangle:"]

 

=={{header|REXX}}==

The Python and Tcl provisos apply to Ruby too. Nevertheless, a {{libheader|RubyGems}} package called [http://github.com/Peeja/abstraction/tree/master abstraction] exists where:

 

 

class AbstractQueue

puts "enqueue #{object.inspect}"

end

So:

<pre>irb(main):032:0> a = AbstractQueue.new

Rust doesn't have traditional object oriented concepts such as classes, instead it uses a concept called traits. Traits are similar to abstract classes in the sense that they define an interface a struct must conform to. A trait can be defined as such:

 

fn area(self) -> i32;

 

The trait can then be implemented on a struct.

 

side_length: i32

}

self.side_length * self.side_length

}

 

Note, traits can also have a default implementation:

 

fn area(self) -> i32;

 

true

}

 

=={{header|Scala}}==

different meaning that described in this page. Here are some examples:

 

type A

var B: A

trait Y {

val x: X

 

When integrating with Java, traits without implementation appear as interfaces.

A function is automaticall attached to the interface, when it has an parameter of the interface type.

 

const type: myInterf is sub object interface;

 

const func integer: method2 (in myInterf: interf, in string: name) is DYNAMIC;

const func integer: add (in myInterf: interf, in integer: a, in integer: b) is DYNAMIC;

 

=={{header|Sidef}}==

{{trans|Raku}}

# must be filled in by the class which will inherit it

method abstract() { die 'Unimplemented' };

var obj = SomeClass.new;

obj.abstract(); # made concrete in class

 

=={{header|Simula}}==

Abtract Datatypes are declared using the VIRTUAL keyword.

For example, we need the following two procedures hash and equalto for a hash map implementation.

! ABSTRACT HASH KEY TYPE ;

LISTVAL CLASS HASHKEY;

BEGIN

END HASHKEY;

A concrete implementation can be derived as follows:

! COMMON HASH KEY TYPE IS TEXT ;

HASHKEY CLASS TEXTHASHKEY(T); VALUE T; TEXT T;

EQUALTO := T = K QUA TEXTHASHKEY.T;

END TEXTHASHKEY;

=={{header|Smalltalk}}==

A class is declared abtract by responding to the query <tt>isAbstract</tt> with true, and defining the required protocol for subclasses to raise an error notification. Optionally, instance creation can be blocked (but seldom done, as you will hit a subclassResponsibility anyway soon). Typically, the IDE provides menu functions to generate these definitions automatically (eg. "Insert Abstract Class" in the refactoring submenu of the class browser):

^ true

 

someClass >> method1

^ self subclassResponsibility

 

=={{header|Standard ML}}==

 

The act of giving a signature to a module is called ascription. There are two type of ascription:

none of the types are abstract. If it is ascribed opaquely, all types are abstract by default, but can be specified

explicitly in the signature, in which case they are not abstract.

 

Here is an example signature for a queue data structure:

type 'a queue

val empty : 'a queue

val enqueue : 'a -> 'a queue -> 'a queue

val dequeue : 'a queue -> ('a * 'a queue) option

 

Because we did not specify an implementation for <tt>'a queue</tt>, the type

will be abstract if we use opaque ascription. Instead we could create a version of the signature which specifies the type,

in which case it will never be abstract:

type 'a queue = 'a list

val empty : 'a queue

val enqueue : 'a -> 'a queue -> 'a queue

val dequeue : 'a queue -> ('a * 'a queue) option

 

Then say we have a structure ListQueue which implements queues as lists. If we write <tt>ListQueue :> QUEUE</tt>

then the queue type will be abstract, but if we write <tt>ListQueue : QUEUE</tt> or <tt>ListQueue : LIST_QUEUE</tt> it won't.

 

=={{header|Tcl}}==

 

While in general Tcl does not use abstract classes at all (and has no need at all for interfaces due to supporting multiple inheritance and mixins), an equivalent effect can be had by concealing the construction methods on the class instance; instances are only created by subclassing the class first (or by mixing it in). In this example, the methods are also error-returning stubs...

method enqueue item {

error "not implemented"

}

self unexport create new

 

 

=={{header|Vala}}==

public void eat() {

print("Chomp! Chomp!\n");

scott.talk();

scott.eat();

 

{{out}}

* By convention all abstract classes have one or more Protected constructors.

 

 

Protected Sub New()

Public MustOverride Sub Method_Must_Be_Replaced()

 

 

=== Interfaces ===

Interfaces may contain Functions, Subroutines, Properties, and Events.

 

Sub Method_Must_Be_Implemented()

 

=={{header|Wren}}==

 

The Go example, when rewritten in Wren, looks like this.

 

class Beast{

var c = Cat.new("siamese", "Sammy")

d.print()

 

{{out}}

=={{header|zkl}}==

In zkl, nothing is ever abstract, objects are always runnable. However, it is easy to define "meta" objects, objects that define an interface/api for a "class" of objects. For example, it is desirable for "stream" objects (such as File, List, etc) to share semantics so that code doesn't need to know what the source object really is.

var [proxy protected]

isBroken = fcn { _broken.isSet() },

fcn writeln(x) { return(self.topdog); }

fcn walker { return((0).walker(*,wap((self.topdog.read.fpM(""))))); }

*The topdog property is the "youngest" child in the inheritance tree (root if you view the tree upside down), it allows a "parent" (or super) to access or pass control to, the actual instance.

*If you wish to "force" method implementation, you can have a meta method throw an NotImplementedError. This is run time thing, not compile time.

 

And now for a "real" object:

var [const] fileName = "DevNull"; // compatibility with File

fcn init { Stream.init() }

fcn write(x) { return(0); }

 

 

{{omit from|ALGOL 68}}

{{omit from|AWK}}

{{omit from|BASIC}}

{{omit from|Falcon|Does not support the concept of an abstract type.}}

{{omit from|gnuplot}}

{{omit from|Integer BASIC}}

{{omit from|JavaScript}}

{{omit from|LaTeX}}

{{omit from|Make}}

{{omit from|Maxima}}

{{omit from|Metafont}}

{{omit from|ML/I}}

{{omit from|Modula-2}}

{{omit from|Scratch}}

{{omit from|TI-89 BASIC|Does not have static or user-defined types.}}

{{omit from|UNIX Shell}}

{{omit from|ZX Spectrum Basic}}