Please enable JavaScript.

Coggle requires JavaScript to display documents.

6.Generics and Collections (Generics (Covariance and Contravariance (a.k.a…

- - - - List<? extends Shape> list
        
        can be a List of Circle
        
        can be a List of FilledCircle etc.
        
        therefore, safe to typecast them to upperbound Shape, or anything higher e.g. Object and get them.
      - ADVANTAGE: can retrieve elements from it as long as the element extends base class or is of same type as base class.
        // can retrieve it and store it in a Reference Variable that is equal to base class or higher than base class (toggling with upper bound)
        DISADVANTAGE: not able to add anything to it.(except null)
        
        Can't consume, but ok to produce.
    - - List<? super Circle> list
        
        can be a List of Circle
        
        can be a List of Shape
        
        can be a List of Object
        
        therefore, can add any element knowing that it inherits from whatever the List type is, and hence can be upcasted to it.
      - ADVANTAGE: Can add any element as long as its of the base class or of any type that extends base class. This is because no matter what type the element is, the worst case is its type baseclass, and hence I can add anything of baseclass and below to it.
        DISADVANTAGE: not able to determine the type of element. ONLY CAN RETRIEVE OBJECTS FROM IT.
        
        Can only produce object, but ok to consume.
  - - - To be able to use Generics in a class, we first need to define the class as follows:
        public class ExampleOne<T>
      - Using Generics to declare an instance variable:
        private T variableName;
      - Using Generics to define a return Type
        public T getVariableName() {
        return variableName;
        }
      - Using Generics to define a method parameter
        
        Using Generics to define a local variable
        public void setVariableName(T value) { //3.
        T temp = value; //4.
        this.value = temp;
        }
      - Using another Generics that is not the Generic used in Class, to define a method (now you can use this new Generic for static variables and static methods)
        
        How does Java know when you are introducing a new Generic? When you use < > inside the class.
        
        public static <Z> Z noOp(Z val) { Z localVar = val; return localVar; }
        
        <Z> tells Java you are using another Generic in this class and to not let it be confused with the class' definition Generic. In this case, since this new generic is independent of the Class Generic, it can be used in definition of static class attributes and class methods. Because if I create `ExampleOne<String> one = new ExampleOne<>(); and ExampleOne.staticVal = "hello"; then I create ExampleOne<Point> two = new ExampleTwo();, type of static variable is still String, but that does not prevent me from being able to define a new type for my class and can successfully build anothe ExampleOne<> object with different types. However, the restriction is that I need to use the same type for the Static Variable.
      - Why class Generic cannot be used in defining static variables and methods.
        
        If let's say I define Test<String> one = new Test<>(); and define Test.staticVar = "hello";, if I create another Test<Point> two object, now hello is still in the class file of Test as a static var, but now the static var type should be Point, this leads to an error. Hence, if I want to have static var or methods, create my own new Generic Type by using <Z> inside the class with generics <T>
- - - - Collection<E> Interface extends Iterable<E>
        
        This interface is a generic interface that is parameterized with a type parameter E.
        
        toArray(T[]) is a generic method; the caller is responsible for passing the right type.
        
        containsAll, removeAll, and retainAll has parameter type Collection<?>, so we can pass in a Collection of any reference type to check for equality.
        
        addAll has parameter declared as Collection <? extends E>; so we can only add elements that are upper-bounded by E.
        
        Any exceptions to the above results in an ArrayStoreException
      - List<E> Interface extends Collection<E>
        
        For implementing a collection of possibly duplicate objects and where order matters, use List
        
        Classes that implement List<E> include ArrayList and LinkedList
        
        List<E> Interface also specifies a sort method default void sort(Comparator<? super E> c)
        
        Interface with default method indicates that the classes implementing List<E> need not implement the same default method again, unless the class wants to override it.