added first time

Author: Bhuwan Gautam

file.txt

@@ -0,0 +1,15 @@
+/**
+ * 
+ */
+package com.lftechnology.covariant;
+
+/**
+ * @author bhuwan
+ */
+public class AfricaZoo extends Zoo {
+
+    @Override
+    Lion getWildAnimal() {
+        return new Lion();
+    }
+}

src/com/lftechnology/covariant/AfricaZoo.java

@@ -0,0 +1,15 @@
+/**
+ * 
+ */
+package com.lftechnology.covariant;
+
+/**
+ * @author bhuwan
+ */
+public class AsianZoo extends Zoo {
+
+    @Override
+    Tiger getWildAnimal() {
+        return new Tiger();
+    }
+}

src/com/lftechnology/covariant/AsianZoo.java

@@ -0,0 +1,17 @@
+/**
+ * 
+ */
+package com.lftechnology.covariant;
+
+/**
+ * @author bhuwan
+ */
+public class Covariant {
+
+    public static void main(String[] args) {
+        AsianZoo asianZoo = new AsianZoo();
+        System.out.println("Asian Zoo:" + asianZoo.getWildAnimal().whoAreYou());
+        AfricaZoo africaZoo = new AfricaZoo();
+        System.out.println("Africa Zoo:" + africaZoo.getWildAnimal().whoAreYou());
+    }
+}

src/com/lftechnology/covariant/Covariant.java

@@ -0,0 +1,15 @@
+/**
+ * 
+ */
+package com.lftechnology.covariant;
+
+/**
+ * @author bhuwan
+ *
+ */
+public class Lion extends WildAnimal{
+
+    public String whoAreYou(){
+        return "Lion";
+    }
+}

src/com/lftechnology/covariant/Lion.java

@@ -0,0 +1,15 @@
+/**
+ * 
+ */
+package com.lftechnology.covariant;
+
+/**
+ * @author bhuwan
+ *
+ */
+public class Tiger extends WildAnimal{
+
+    public String whoAreYou(){
+        return "Tiger";
+    }
+}

src/com/lftechnology/covariant/Tiger.java

@@ -0,0 +1,15 @@
+/**
+ * 
+ */
+package com.lftechnology.covariant;
+
+/**
+ * @author bhuwan
+ *
+ */
+public class WildAnimal {
+
+    public String willYouBite(){
+        return "Yes";
+    }
+}

src/com/lftechnology/covariant/WildAnimal.java

@@ -0,0 +1,15 @@
+/**
+ * 
+ */
+package com.lftechnology.covariant;
+
+/**
+ * @author bhuwan
+ *
+ */
+public class Zoo {
+
+    WildAnimal getWildAnimal(){
+        return new WildAnimal();
+    }
+}

src/com/lftechnology/covariant/Zoo.java

@@ -0,0 +1,31 @@
+/**
+ * 
+ */
+package com.lftechnology.generics;
+
+/**
+ * @author bhuwan
+ */
+public class BoundedType {
+
+    /**
+     * Bounded type example
+     * 
+     * @author bhuwan
+     * @param t1
+     * @param t2
+     * @return 0, 1, or -1
+     */
+    public static <T extends Comparable<T>> int compare(T t1, T t2) {
+        return t1.compareTo(t2);
+    }
+    
+    @SuppressWarnings("unused")
+    public static void main(String[] args) {
+        String name = "Bhuwan";
+        String anotherName = "Gautam";
+        Double amount = 0.0;
+        BoundedType.compare(name, anotherName);
+    }
+
+}

src/com/lftechnology/generics/BoundedType.java

@@ -0,0 +1,21 @@
+/**
+ * 
+ */
+package com.lftechnology.generics;
+
+/**
+ * @author bhuwan
+ */
+public class GenericsAndInheritance {
+    public static void main(String[] args) {
+        String name = "Bhuwan";
+        Object nameObject = new Object();
+        nameObject = name;
+        
+        GenericsType<String> nameString = new GenericsType<String>();
+        GenericsType<Object> object = new GenericsType<Object>();
+        // this is not same with generic
+        //object = nameString;
+        
+    }
+}

src/com/lftechnology/generics/GenericsAndInheritance.java

@@ -0,0 +1,29 @@
+/**
+ * 
+ */
+package com.lftechnology.generics;
+
+/**
+ * @author bhuwan
+ */
+public class GenericsInheritance {
+
+    @SuppressWarnings("unused")
+    public static void main(String[] args) {
+        String str = "GenericsInheritance";
+        Object obj = new Object();
+        // works because String is-a Object, inheritance in java
+        obj = str;
+
+        MyClass<String> myClass1 = new MyClass<String>();
+        MyClass<Object> myClass2 = new MyClass<Object>();
+        // compilation error since MyClass<String> is not
+        //myClass2 = myClass1;
+        // MyClass<T> parent is Object
+        obj = myClass1;
+    }
+
+    public static class MyClass<T> {
+    }
+
+}

src/com/lftechnology/generics/GenericsInheritance.java

@@ -0,0 +1,30 @@
+/**
+ * 
+ */
+package com.lftechnology.generics;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @author bhuwan
+ */
+public class GenericsLowerBounded {
+
+    public static void main(String[] args) {
+        List<Number> ints = new ArrayList<>();
+        ints.add(3);
+        ints.add(5);
+        ints.add(10);
+        double sum = sumWithWildCard(ints);
+        System.out.println("Sum of ints=" + sum);
+    }
+
+    public static double sumWithWildCard(List<? super Number> list) {
+        double sum = 0;
+        for (Object n : list) {
+            sum += (Integer)n;
+        }
+        return sum;
+    }
+}

src/com/lftechnology/generics/GenericsLowerBounded.java

@@ -0,0 +1,37 @@
+/**
+ * 
+ */
+package com.lftechnology.generics;
+
+import java.util.logging.Logger;
+
+/**
+ * @author bhuwan
+ */
+public class GenericsMethods {
+
+    private static final Logger log = Logger.getLogger(WithouUsingGenerics.class.getName());
+
+    // Generics in method
+    public static <T> boolean isEqual(GenericsType<T> g1, GenericsType<T> g2) {
+        return g1.get().equals(g2.get());
+    }
+
+    public static void main(String args[]) {
+        GenericsType<String> g1 = new GenericsType<>();
+        g1.set("Bhuwan");
+
+        GenericsType<String> g2 = new GenericsType<>();
+        g2.set("Bhuwan");
+
+        boolean isEqual = GenericsMethods.<String> isEqual(g1, g2);
+        // above statement can be written simply as
+        log.info("isEqualFirst:: " + isEqual);
+        isEqual = GenericsMethods.isEqual(g1, g2);
+        // This feature, known as type inference, allows you to invoke a generic
+        // method as an ordinary method, without specifying a type between angle
+        // brackets. Compiler will infer the type that is needed
+        log.info("isEqualSecond:: " + isEqual);
+    }
+
+}

src/com/lftechnology/generics/GenericsMethods.java

@@ -0,0 +1,36 @@
+/**
+ * 
+ */
+package com.lftechnology.generics;
+
+/**
+ * @author bhuwan
+ */
+public class GenericsType<T> {
+
+    private T t;
+
+    public T get() {
+        return this.t;
+    }
+
+    public void set(T t1) {
+        this.t = t1;
+    }
+
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    public static void main(String args[]) {
+        // java 7 style declaration
+        // Generic type instantiation
+        GenericsType<String> type = new GenericsType<>();
+        type.set("Bhuwan Gautam");
+        // this will be a compile time error
+        // type.set(11);
+
+        // raw type instantiation
+        GenericsType type1 = new GenericsType();
+        type1.set("Prakash");
+        type1.set(10);
+    }
+
+}

src/com/lftechnology/generics/GenericsType.java

@@ -0,0 +1,29 @@
+/**
+ * 
+ */
+package com.lftechnology.generics;
+
+/**
+ * @author bhuwan
+ */
+public class GenericsTypeOld {
+
+    private Object t;
+
+    public Object get() {
+        return t;
+    }
+
+    public void set(Object t) {
+        this.t = t;
+    }
+
+    @SuppressWarnings("unused")
+    public static void main(String args[]) {
+        GenericsTypeOld type = new GenericsTypeOld();
+        type.set("Bhuwan Gautam");
+        // type casting, error prone and can cause ClassCastException
+        String name = (String)type.get();
+    }
+
+}

src/com/lftechnology/generics/GenericsTypeOld.java

@@ -0,0 +1,39 @@
+/**
+ * 
+ */
+package com.lftechnology.generics;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @author bhuwan
+ */
+public class GenericsUpperBounded {
+
+    public static double sumWithoutWildCard(List<Number> list) {
+        double sum = 0;
+        for (Number n : list) {
+            sum += n.doubleValue();
+        }
+        return sum;
+    }
+
+    public static void main(String[] args) {
+        List<Number> ints = new ArrayList<>();
+        ints.add(3);
+        ints.add(5);
+        ints.add(10);
+        double sum = sumWithWildCard(ints);
+        System.out.println("Sum of ints=" + sum);
+    }
+
+    public static double sumWithWildCard(List<? extends Number> list) {
+        double sum = 0;
+        for (Number n : list) {
+            sum += n.doubleValue();
+        }
+        return sum;
+    }
+
+}

src/com/lftechnology/generics/GenericsUpperBounded.java

@@ -0,0 +1,17 @@
+/**
+ * 
+ */
+package com.lftechnology.generics;
+
+import java.util.List;
+
+/**
+ * @author bhuwan
+ */
+public interface ISort {
+
+    // By using raw type
+    @SuppressWarnings("rawtypes")
+    public List sort(final List aList);
+
+}