View source for Abstract type

{{Short description|Feature of a programming language}}
{{more citations needed|date=January 2022}}
{{distinguish|Abstract data type}}
{{Type systems}}

In [[programming languages]], an '''abstract type''' (also known as '''existential types''')<ref>Mitchell, John C.; Plotkin, Gordon D.; [http://theory.stanford.edu/~jcm/papers/mitch-plotkin-88.pdf ''Abstract Types Have Existential Type''], ACM Transactions on Programming Languages and Systems, Vol. 10, No. 3, July 1988, pp. 470–502</ref> is a [[Type (computer science)|type]] in a [[nominative type system]] that cannot be [[Instance (computer science)|instantiated]] directly; by contrast, a '''concrete type''' {{em|can}} be instantiated directly. Instantiation of an abstract type can occur only indirectly, via a concrete [[Subtyping|''subtype'']]. 

An abstract type may provide no implementation, or an incomplete implementation. In some languages, abstract types with no implementation (rather than an incomplete implementation) are known as ''[[Protocol (object-oriented programming)|protocols]]'', ''interfaces'', ''signatures'', or ''class types''. In [[Class-based programming|class-based]] [[object-oriented programming]], abstract types are implemented as ''[[abstract class|abstract classes]]'' (also known as ''[[abstract base class]]es''), and concrete types as ''[[concrete class]]es''. In [[generic programming]], the analogous notion is a [[Concept (generic programming)|''concept'']], which similarly specifies syntax and semantics, but does not require a subtype relationship: two unrelated types may satisfy the same concept.

Often, abstract types will have one or more implementations provided separately, for example, in the form of concrete subtypes that {{em|can}} be instantiated. In object-oriented programming, an abstract class may include ''[[abstract method]]s'' or ''abstract [[Property (programming)|properties]]''<ref name="Oracle">{{cite web | title=Abstract Methods and Classes (The Java Tutorials > Learning the Java Language > Interfaces and Inheritance) | website=Oracle.com| url=https://docs.oracle.com/javase/tutorial/java/IandI/abstract.html | access-date=2019-08-14}}</ref> that are shared by its subclasses. Other names for language features that are (or may be) used to implement abstract types include ''[[Trait (computer science)|traits]]'', ''[[mixin]]s'', ''flavors'', ''roles'', or ''type classes''.{{Citation needed|date=September 2014}}

Abstract types may also include any number of non-abstract methods and properties, such as when implementing the [[Template_method_pattern|Template Method Pattern]] which uses a mixture of invariant methods with fixed implementations and [[hooking|hook methods]] which can be overridden in concrete subclasses to provide custonised logic.

== Creation ==

Abstract classes can be created, signified, or simulated in several ways:
* By use of the explicit [[keyword (computer programming)|keyword]] {{code|abstract}} in the class definition, as in [[Java (programming language)|Java]], [[D (programming language)|D]] or [[C Sharp (programming language)|C#]].
* By including, in the class definition, one or more [[abstract method]]s (called ''pure [[virtual functions]]'' in [[C++]]), which the class is declared to accept as part of its protocol, but for which no implementation is provided.
* By [[inheritance (object-oriented programming)|inheriting]] from an abstract type, and not overriding all missing features necessary to complete the class definition.  In other words, a child type that does not implement all abstract methods from its parent becomes abstract itself.<ref name="Oracle" /><ref>{{Cite web|url=https://www.geeksforgeeks.org/pure-virtual-functions-and-abstract-classes/|title=Pure Virtual Functions and Abstract Classes in C++|website=GeeksforGeeks.org|date=15 July 2014 }}</ref>
* In many dynamically typed languages such as [[Smalltalk]], any class that sends a particular method to [[this (computer science)|this]], but does not implement that method, can be considered abstract.  (However, in many such languages, like [[Objective-C]], the error is not detected until the class is used, and the message returns results in an exception error message such as "Does not recognize selector: xxx" as <code>- [NSObject doesNotRecognizeSelector:(SEL)selector]</code> is invoked upon detection of an unimplemented method).

==Examples==

===Java===
By default, all methods in all classes are concrete, unless the abstract keyword is used. An abstract class may include abstract methods, which have no implementation.
By default, all methods in all interfaces are abstract, unless the default keyword is used.
The default keyword can be used to specify a concrete method in an interface.

<syntaxhighlight lang="java">

//By default, all methods in all classes are concrete, unless the abstract keyword is used.
public abstract class Demo {
    // An abstract class may include abstract methods, which have no implementation.
    public abstract int sum(int x, int y);

    // An abstract class may also include concrete methods.
    public int product(int x, int y) { 
        return x*y; 
    }
}

//By default, all methods in all interfaces are abstract, unless the default keyword is used.
interface DemoInterface {
    int getLength(); //The abstract keyword can be used here, though is completely useless
    
    //The default keyword can be used in this context to specify a concrete method in an interface
    default int product(int x, int y) {
        return x * y;
    }
}
</syntaxhighlight>

[[File:UML class pet.svg]]

== Usage ==

Abstract types are an important feature in [[static typing|statically typed]] OOP languages. Many [[dynamic typing|dynamically typed]] languages have no equivalent feature (although the use of [[duck typing]] makes abstract types unnecessary); however ''[[Trait (computer programming)|traits]]'' are found in some modern dynamically-typed languages.{{Citation needed|date=April 2020}}

Some authors argue that classes should be [[Leaf class (programming language)|leaf class]]es (have no subtypes), or else be abstract.<ref name="riel1996">{{cite book|last=Riel|first=Arthur|title=Object-Oriented Design Heuristics|publisher=Addison-Wesley Professional|year=1996|isbn=0-201-63385-X|page=89}}</ref><ref name="meyers1996">{{cite book|last=Meyers|first=Scott|title=More Effective C++|publisher=Addison-Wesley Professional|year=1996|isbn=0-201-63371-X|page=[https://archive.org/details/moreeffectivec3500meye/page/258 258]|quote=Make non-leaf classes abstract|url=https://archive.org/details/moreeffectivec3500meye/page/258}}</ref>

Abstract types are useful in that they can be used to define and enforce a ''[[Protocol (object-oriented programming)|protocol]]''; a set of operations that all objects implementing the protocol must support.{{Citation needed|date=April 2020}}

Abstract types are also an essential part of the [[Template_method_pattern|Template Method Pattern]].

== See also ==
* [[Class (computer programming)|Class]]
* [[Concept (generic programming)|Concept]]
* [[Type class]]

== References ==
{{Reflist}}

==Further reading==
* {{cite book|title=Head First Java|year=2003|publisher=O'Reilly Media|isbn=0-596-00920-8|pages=[https://archive.org/details/headfirstjava00sier_0/page/688 688]|url=https://archive.org/details/headfirstjava00sier_0/page/688}}
*Core Java: An Integrated Approach by  R. Nageswara Rao

== External links ==
* "Abstract or Skeletal Interfaces Explained" [http://10kloc.wordpress.com/2012/12/03/abstract-interfaces-the-mystery-revealed/]
* ''Types and Programming Languages'' by Benjamin Pierce (MIT Press 2002) [http://www.cis.upenn.edu/~bcpierce/tapl/main.html]
* ''[http://rosettacode.org/wiki/Abstract_type Abstract type]'' at [[Rosetta Code]]

<!--Categories-->
[[Category:Type theory]]
[[Category:Articles with example Java code]]

[[sv:Klass (programmering)#Abstrakt klass]]