74_Generics

//generics= enable types(classes and interfaces) to be parameters when defining:
//          classes, interfaces and method
//          a benefit is to eliminate the need to create multiple versions
//          of methods or classes for various data types.
//          Use 1 version for all reference data types

---Draft idea---
<Main.java>
import javax.swing.*;

public class Main {
    public static void main(String[] args){

        Integer[] intArray = {1,2,3,4,5};
        Double[] doubleArray = {5.5, 4.4, 3.3, 2.2, 1.1};
        Character[] charArray = {'H', 'E', 'L', 'L', 'O'};
        String[] stringArray = {"B","Y","E"};
        displayArray(intArray);
        displayArray(doubleArray);
        displayArray(charArray);
        displayArray(stringArray);
    }

    public static void displayArray(Integer[] array){
        for(Integer x: array){
            System.out.print(x+" ");
        }
        System.out.println();
    }
    public static void displayArray(Double[] array){
        for(Double x: array){
            System.out.print(x+" ");
        }
        System.out.println();
    }
    public static void displayArray(Character[] array){
        for(Character x: array){
            System.out.print(x+" ");
        }
        System.out.println();
    }
    public static void displayArray(String[] array){
        for(String x: array){
            System.out.print(x+" ");
        }
        System.out.println();
    }
}

---Apply Generics---
public class Main {
    public static void main(String[] args){

        Integer[] intArray = {1,2,3,4,5};
        Double[] doubleArray = {5.5, 4.4, 3.3, 2.2, 1.1};
        Character[] charArray = {'H', 'E', 'L', 'L', 'O'};
        String[] stringArray = {"B","Y","E"};
        
    }

    public static <Thing> void displayArray(Thing[] array){ //Apply generic
        for(Thing x: array){
            System.out.print(x+" ");
        }
        System.out.println();
      }
    }

---To print the first element of each array---
public class Main {
    public static void main(String[] args){

        Integer[] intArray = {1,2,3,4,5};
        Double[] doubleArray = {5.5, 4.4, 3.3, 2.2, 1.1};
        Character[] charArray = {'H', 'E', 'L', 'L', 'O'};
        String[] stringArray = {"B","Y","E"};

        System.out.println(getFirst(intArray));
        System.out.println(getFirst(doubleArray));
        System.out.println(getFirst(charArray));
        System.out.println(getFirst(stringArray));
    }

    public static <Thing> void displayArray(Thing[] array){ //Apply generic
        for(Thing x: array){
            System.out.print(x+" ");
        }
        System.out.println();
    }
    public static <Thing> Thing getFirst(Thing[] array){//no void because returning smtg
        return array[0];}
}

---To create a method that accepts all data type (DRAW)---
public class Main {
    public static void main(String[] args) {
        Player player = new Player();
        Enemy enemy = new Enemy();
        Item item = new Item();
        Tree tree = new Tree();

        draw(player);
        draw(enemy);
        draw(item);
        draw(tree);
    }

    public static <Thing> void draw (Thing x){
        x.draw();
    }
}

===Generic CLasses===
--ori--
public class Main {
    public static void main(String[] args) {
        MyIntegerClass myInt = new MyIntegerClass(1);
        MyDoubleClass myDouble = new MyDoubleClass(3.14);
        MyCharacterClass myChar = new MyCharacterClass('@');
        MyStringClass myString = new MyStringClass("Hello");

        System.out.println(myInt.getValue());
        System.out.println(myDouble.getValue());
        System.out.println(myChar.getValue());
        System.out.println(myString.getValue());
    }
}

<MyIntegerClass.java>
public class MyIntegerClass {
    Integer x;
    MyIntegerClass(Integer x){
        this.x = x;
    }
    public Integer getValue(){
        return x;
    }
}

<MyDoubleClass.java>
public class MyDoubleClass {
    
        Double x;
        MyDoubleClass(Double x){
            this.x = x;
        }
        public Double getValue(){
            return x;
        }
        
}

<MyCharacterClass.java>
public class MyCharacterClass {
        Character x;
        MyCharacterClass(Character x){
            this.x = x;
        }
        public Character getValue(){
            return x;
        }

}

<MyStringClass.java>
public class MyStringClass {
        String x;
        MyStringClass(String x){
            this.x = x;
        }
        public String getValue(){
            return x;
        }
}

--apply Generic Classs--
<Main.java>
import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        MyGenericClass<Integer> myInt = new MyGenericClass(1);
        MyGenericClass<Double> myDouble = new MyGenericClass(3.14);
        MyGenericClass<Character> myChar = new MyGenericClass('@');
        MyGenericClass<String> myString = new MyGenericClass("Hello");

        ArrayList<String> myFriends = new ArrayList<>();
        
        System.out.println(myInt.getValue());
        System.out.println(myDouble.getValue());
        System.out.println(myChar.getValue());
        System.out.println(myString.getValue());
    }
}

<MyGenericClass.java>
public class MyGenericClass <Thing>{
    <Thing> x;
    MyGenericClass(Thing x){
        this.x = x;
    }
    public Thing getValue(){
        return x;
    }
}


--To return the 2nd item--look like hashmap
<Main.java>
import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        MyGenericClass<Integer,Integer> myInt = new MyGenericClass(1,9);
        MyGenericClass<Double,Double> myDouble = new MyGenericClass(3.14,1.01);
        MyGenericClass<Character,Character> myChar = new MyGenericClass('@','$');
        MyGenericClass<String,String> myString = new MyGenericClass("Hello",'!');

        ArrayList<String> myFriends = new ArrayList<>();

        System.out.println(myInt.getValue());
        System.out.println(myDouble.getValue());
        System.out.println(myChar.getValue());
        System.out.println(myString.getValue());
    }
}

<MyGenericClass.java>
public class MyGenericClass <Thing, Thing2>{
    Thing x;
    Thing2 y;
    MyGenericClass(Thing x, Thing2 y){
        this.x = x;
        this.y = y;
    }
    public Thing2 getValue(){
        return y;
    }
}

---bounded types---
//bounded types = you can create the objects of a generic class to have data
//                of specific derived types ex.Number

<Main.java>
import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        MyGenericClass<Integer,Integer> myInt = new MyGenericClass(1,9);
        MyGenericClass<Double,Double> myDouble = new MyGenericClass(3.14,1.01);

        System.out.println(myInt.getValue());
        System.out.println(myDouble.getValue());
        }
}

<MyGenericClass.java>

public class MyGenericClass <Thing extends Number, Thing2 extends Number>{
    //Only Number Class can be passed in
    Thing x;
    Thing2 y;
    MyGenericClass(Thing x, Thing2 y){
        this.x = x;
        this.y = y;
    }
    public Thing2 getValue(){
        return y;
    }
}