Pieter van den Hombergh Richard van den Ham. March 1, 2018

Transcription

1 ,, Pieter van den Hombergh Richard van den Ham Fontys Hogeschool voor Techniek en Logistiek Type : Upper March 1, 2018 /FHTenL, March 1, /29

2 Topics, Type : Upper Type : Lower Bounds, accepting things Type : Upper /FHTenL, March 1, /29

3 , boon or bust?, Type : Upper This can be quite frustrating, if you do not grasp the concept. /FHTenL, March 1, /29

4 Java is type safe,... and the consequences are: The compiler will forbid incompatible assignments. You might need to convince the compiler with a cast that the operation is okay. Then the compiler says to runtime: Please check that cast. Runtime: Okay, If the programmer lied, I will kick ass with a ClassCastException. It helps the programmer to avoid errors or to at least find them early. ClassCastExceptions are a typical case of wrong design/implementation or wrong usage. Type : Upper /FHTenL, March 1, /29

5 Java history and evolution The Java solution may seem strange. E.g. Arrays do check against incompatible assignments. The reference type (of what you want to stick in) is type checked against the array declaration. (Safety!). Arrays of objects will accept any ref type, so Containers (ArrayList etc.) of object did not/could not check against incompatible assignments in the pre- Java5 era. e.g. ArrayList uses, you guessed it, and array of Object inside. Since Java5 1 the compiler can (statically) check against incompatible assignments. but..., Type : Upper 1 introducing generics /FHTenL, March 1, /29

6 The ideal type system, Type : Upper Only real... allowed here /FHTenL, March 1, /29

7 But it would prohibit this use..., Type : Upper /FHTenL... that hastype evolved safety, with the Java culture. March 1, /29

8 summary protects the programmer against many errors, like putting round pegs in square holes. Even with type safety the type system and usage is quite flexible. Only having reference object types and no value object types also makes the implementation efficient. You need only one binary (class file) for of List, Set etc., whereas e.g. C++ needs a new separate binary for every member type and need to recompile 2 with that member type., Type : Upper 2 see C++ templates /FHTenL, March 1, /29

9 Example - String Container Container of String p u b l i c c l a s s StringContainer { p r i v a t e String value ; p u b l i c String getvalue ( ) { r e t u r n value ; p u b l i c v o i d setvalue ( String value ) { t h i s. value = value ;, Type : Upper p u b l i c StringContainer ( String value ) { t h i s. value = value ; p u b l i c String tostring ( ) { r e t u r n value ; /FHTenL, March 1, /29

10 Example - Integer Container Container of Integer p u b l i c c l a s s IntegerContainer { p r i v a t e Integer value ; p u b l i c Integer getvalue ( ) { r e t u r n value ; p u b l i c v o i d setvalue ( Integer value ) { t h i s. value = value ;, Type : Upper p u b l i c IntegerContainer ( Integer value ) { t h i s. value = value ; p u b l i c String tostring ( ) { r e t u r n value. tostring ( ) ; /FHTenL, March 1, /29

11 Analysis of an example What is remarkable New class for every data type Basic structure is same Copy and waste Consequences: Bad extensibility Reduced maintainability Bigger chance for errors, Type : Upper /FHTenL, March 1, /29

12 Generic Container p u b l i c c l a s s GenericContainer <C> { p r i v a t e C value ; p u b l i c GenericContainer ( C value ) { t h i s. value = value ; p u b l i c C getvalue ( ) { r e t u r n value ;, Type : Upper p u b l i c v o i d setvalue ( C value ) { t h i s. value = value ; Quiz: How to implement public String tostring()? /FHTenL, March 1, /29

13 Container In stead of a concrete type we have a formal Type parameter (C in the example) The instantiation takes place based on the parameterized type All generic operations can now have a type., Type : Upper /FHTenL, March 1, /29

14 Applying GenericContainer Integer and Double containers package maingencontainer ; p u b l i c c l a s s MainGenContainer { p u b l i c s t a t i c v o i d main ( String [ ] args ) { GenericContainer<Integer> intcontainer = new GenericContainer <>(3) ; GenericContainer<Double> doublecontainer = new GenericContainer < >(3.0) ; System. out. println ( intcontainer. getvalue ( ) ) ; System. out. println ( doublecontainer. getvalue ( ) ) ;, Type : Upper /FHTenL, March 1, /29

15 in Methods A class can also have generic (static) methods. The Type parameter is applied on the current method definition only., Typed (static), method p u b l i c s t a t i c <T> T randomflip ( T head, T tail ) { r e t u r n Math. random ( ) > 0. 5? head : tail ; Type : Upper /FHTenL, March 1, /29

16 Implementation of Generic classes, type erasure Instead of the generic type, Object is used. Everywhere a type access is used, a typecast is applied for you., Type : Upper /FHTenL, March 1, /29

17 Implementation of - 2 The compiler erases the generic type information, so it is not available in the class file or at runtime. Reason: The old, pre-generics code would not know what to do. Think of the donkey in the car on sheet 7. This implies that the following code produces a compiler error. At runtime only the raw GenericContainer is available., Consequence of type erasure GenericContainer <String> genericstringcontainer = new GenericContainer <String> ( " A String " ) ; Type : Upper i f ( genericstringcontainer i n s t a n c e o f GenericContainer<String >){ //... /FHTenL, March 1, /29

18 , Implementation of - 2 This is cheating List<Integer> list = new ArrayList<Integer >() ; ( ( List ) list ). add ( " a String " ) ; System. out. println ( list. get ( 0 ) ) ; What s this? Of course if you want to cheat, you can. To prevent this kind of folly, wrap your collectiona, say Set, in a checkedset like Type : Upper Set<String> s = Collections.checkedSet( new TreeSet<>(), String -.class ); The class object, passed as second parameter, stands guard to make sure no other type gets in. You should not do this as a habit, but only if you found a problem (in your tests of course), where this usage will help you find the problem. a List, Map, Set /FHTenL, March 1, /29

19 Putting bound to types You can constrain or put on the type The extends keyword can be followed by both a class or an interface Using & you can use a combination of types public class Container <C extends Person & Serializable>... 3, Type : Upper 3 extends here applies to both classes and interfaces; read it as inherits from. /FHTenL, March 1, /29

20 Wildcard usage In generic code, <?>, called the wildcard, represents an unknown type, which is of course implicitly of type Object. You can use the wildcard with upper (of which should the type be a child) or lower (what type should at least be accepted) bound. This is the preferred usage, instead of using a raw type, that is, omitting the type parameter altogether., Type : Upper /FHTenL, March 1, /29

21 Wildcard with upper bound Upper wildcard are easy to understand: you specify what class hierarchy you accept to have a compatible assignment. You use it when a some value is produced, such as in a collection that is used as input parameter, which produces the objects. Here the list is assumed to produce Foo objects or children of Foo. So the method knows what operations are available on the objects. (These are the methods defined in type Foo)., Type : Upper /FHTenL, March 1, /29

22 Producer example Producer Example List<Shape> shapes = new ArrayList <>() ; /** * Print shape areas from list. * shapestoprint is the " producer " of the shapes * to print. * shapestoprint are printed */ v o i d printshapeareas ( Collection<? e x t e n d s Shape> shapestoprint ) { f o r ( Shape s : shapestoprint ) { i f ( s. area ( ) > 0) { System. out. println ( s. area ( ) ) ;, Type : Upper You know that what the collection will produce will be a Shape, the upper bound. /FHTenL, March 1, /29

23 Wildcard with lower bound If you want to pass a container that should receive objects that are selected in a method, than that receiving container or consumer should accept the objects to be consumed. The way to specify that is to say that the objects are the least 4 things that should be acceptable. It also implies acceptance of the super types of the acceptable type. You specify that lower bound with <? super T>. In the example on page 18, the list consumes Integers, and must accept at least these, but a super of Integer (like Number or Object) will do, but a String won t. Note that you only use this construction when defining the formal container parameter in the method taking a consumer as parameter., Type : Upper 4 Lowest in type hierarchy /FHTenL, March 1, /29

24 Consumer Example, method with consumer argument /** * Filter circles from shapes. * Collect the circles in this into a collection. * The specification ( Generic Type and all ) * should accept circles. * The collection is a " consumer " of Circle. * collection accepting circles */ v o i d collectcircles ( List<? s u p e r Circle> collection ) { f o r ( Shape c : shapes ) { i f ( c i n s t a n c e o f Circle ) { collection. add ( ( Circle ) c ) ;, Type : Upper Collection may be any Collection that accepts Circles. So a collection of Object would do, and so would a collection of any interface type that Circle implements, for instance Collection<Serializable> collection. Object Shape Circle Disk Serializable Triangle TwoDimensional getarea():double; /FHTenL, March 1, /29

25 Consumer Example, caller site List<Shape> foundshapes = new ArrayList <>() ; List<Object> foundobjects = new ArrayList <>() ; List<Circle> foundcircles = new ArrayList <>() ; toy. collectcircles ( foundobjects ) ; toy. collectcircles ( foundshapes ) ; toy. collectcircles ( foundcircles ) ; Without the wildcard with lower (super) bound, the method calls in lines 58 and 59 would be rejected by the compiler a message looking like this: BrokenToy. java :58: error : method collectcircles in class BrokenToy cannot be applied to given types ; toy. collectcircles ( foundobjects ); ˆ required : List < Circle > found : List < Object > reason : argument mismatch ; List < Object > cannot be converted to List < Circle >, Type : Upper /FHTenL, March 1, /29

26 Consumer Example wrong call Suppose Disc extends Circle. List<Disc> founddiscs = new ArrayList <>() ; toy. collectcircles ( founddiscs ) ; Than the compiler rejects with the message: GenShapeToy. java :63: error : method collectcircles in class GenShapeToy cannot be applied to given types ; toy. collectcircles ( founddiscs ); ˆ required : List <? super Circle > found : List < Disc > reason : argument mismatch ; List < Disc > cannot be converted to List <? super Circle > because it insists on a super type of circle, and disk is not, it is a sub type. It cannot guarantee that all object put into the collection will be disks, because it s implementation will stick circles is, which are not always also disk. Note that this a Java 9 error message invoked with javac -Xdiags:verbose *.java., Type : Upper /FHTenL, March 1, /29

27 P.E.C.S., P roducer E xtends C onsumer S uper PE colloquial for Pectoralis major muscle. Type : Upper Remember, or I will be back. /FHTenL, March 1, /29

28 extends and super Summary It is important to notice that the wild card types specify either the element or the container, not both. Producer specification uses extends to guarantee the type of elements that come out of that producer. A Producer of Foo is therefor specified as producing Foos or children of Foo. Consumer specification uses super to guarantee what the container will accept. Super is applicable because an instance of a type in Java is also of its super type, implying that a container of a super type will also accept the lower bound. A consumer of Bar must accept Bars, but any container that accepts Baf, the super of Bar will also fit the bill because a super declared variable will always accept a reference to a sub type object., Type : Upper /FHTenL, March 1, /29

29 Questions Questions? Questions or remarks?, Type : Upper /FHTenL, March 1, /29