Abstract type: Difference between revisions

=={{header|11l}}==

You can declare a virtual function to not have an implementation by using <code>F.virtual.abstract</code> keyword. A type containing at least one abstract virtual function cannot be instantiated.

F.virtual.abstract enqueue(Int item) -> N

T PrintQueue(AbstractQueue)

F.virtual.assign enqueue(Int item) -> N

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

=={{header|BASIC}}==

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

QB64, along with QBasic and QuickBasic (without extension), is not Object-Oriented; however, the following addresses issues raised in the description of the problem as well as the problem itself:

'said, the following is both legal and executable.

'an Integer or a String, being a use of type "c"'s element "d" or "e".

Print j.g.e

{{out}}

<pre>15

{{works with|QuickBasic|4.5}}

{{trans|QB64}}

TYPE c

PRINT i.g.e

PRINT g.e

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;

}

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

{

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.

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

Methods that don't have an implementation are called abstract methods in Java. 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 cannot be private.

public abstract int method1(double value);

protected abstract int method2(String name);

return a + b;

}

Before Java 8, interfaces could not implement any methods and all methods were implicitly public and abstract.

int method1(double value);

int method2(String name);

int add(int a, int b);

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

=={{header|Mathematica}}/{{header|Wolfram Language}}==

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>

=={{header|newLISP}}==

; 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

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

class BaseQueue

attr

end

=={{header|PARI/GP}}==

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