![]() Thus, one can define a circle with immutable center and mutable radius as a subtype of an immutable point without violating the history constraint. Fields added to the subtype may however be safely modified because they are not observable through the supertype methods. This is a violation of the history constraint, because in the history of the immutable point, the state is always the same after creation, so it cannot include the history of a mutable point in general. A violation of this constraint can be exemplified by defining a mutable point as a subtype of an immutable point. It was the novel element introduced by Liskov and Wing. Because subtypes may introduce methods that are not present in the supertype, the introduction of these methods may allow state changes in the subtype that are not permissible in the supertype. Objects are regarded as being modifiable only through their methods ( encapsulation). History constraint (the "history rule").Invariants must be preserved in the subtype. ![]() Postconditions cannot be weakened in the subtype.Preconditions cannot be strengthened in the subtype.These are detailed in a terminology resembling that of design by contract methodology, leading to some restrictions on how contracts can interact with inheritance: In addition to the signature requirements, the subtype must meet a number of behavioural conditions. New exceptions cannot be thrown by the methods in the subtype, except if they are subtypes of exceptions thrown by the methods of the supertype.Covariance of method return types in the subtype.Contravariance of method parameter types in the subtype.structural subtyping for the distinction): Liskov substitution principle imposes some standard requirements on signatures that have been adopted in newer object-oriented programming languages (usually at the level of classes rather than types see nominal vs. Nonetheless, the principle is useful in reasoning about the design of class hierarchies. a compiler) to verify that it holds true for some subtype S of T, even if q does hold for T. Behavioural subtyping is undecidable in general: if q is the property "method for x always terminates", then it is impossible for a program (e.g. correctness).īehavioural subtyping is a stronger notion than typical subtyping of functions defined in type theory, which relies only on the contravariance of parameter types and covariance of the return type. Liskov's notion of a behavioural subtype defines a notion of substitutability for objects that is, if S is a subtype of T, then objects of type T in a program may be replaced with objects of type S without altering any of the desirable properties of that program (e.g. In the same paper, Liskov and Wing detailed their notion of behavioral subtyping in an extension of Hoare logic, which bears a certain resemblance to Bertrand Meyer's design by contract in that it considers the interaction of subtyping with preconditions, postconditions and invariants. That is, if S subtypes T, what holds for T-objects holds for S-objects. Barbara Liskov and Jeannette Wing described the principle succinctly in a 1994 paper as follows: It is a semantic rather than merely syntactic relation, because it intends to guarantee semantic interoperability of types in a hierarchy, object types in particular. It is based on the concept of "substitutability" – a principle in object-oriented programming stating that an object (such as a class) may be replaced by a sub-object (such as a class that extends the first class) without breaking the program. The Liskov substitution principle ( LSP) is a particular definition of a subtyping relation, called strong behavioral subtyping, that was initially introduced by Barbara Liskov in a 1987 conference keynote address titled Data abstraction and hierarchy. Liskov substitution was introduced by Barbara Liskov, photo taken in 2010
0 Comments
Leave a Reply. |