Learning to use generic types

<Regular array>

Creat an arry of object type

class Test{
    Object[] arry=new Object[20];

    public Object getArry(int site) {
        return arry[site];
    }

    public void setArry(int site,int value) {
        this.arry[site] = value;
    }

    public static void main(String[] args) {
        Test test=new Test();
        test.setArry(5,0);
        int val=(int)test.getArry(0);//1.you must conversion its type to int 
        System.out.println(val);
    }
}

But ,more often ,we want it to be able to hold only one data type.

Genericty's main purpose:

 

<genericity>

public class Genericity<T> {//表示当前的类是泛型类
    //T[]arr=new T[20];

    T[]arr=(T[])new Object[20];//1.
    public T getArr(int site) {
        return arr[site];
    }

    public void setArr(int site,T value) {
        this.arr[site] = value;
    }

    public static void main(String[] args) {
        Genericity<Integer> genericity=new Genericity<>();
     //2.When do parameters  need to be passed?
        genericity.setArr(0,20);
        int val=genericity.getArr(0);
        System.out.println(val);


    }


}

 Please think about:

< erasure machanism>

<The upper bound of a generic>

 

complex

 

Example :Please use a generic classes to find the biggest element in the arry

public class GenericityTwo<T extends Comparable<T>> {
    public  T Compare(T[]arry){
        T max=arry[0];
        for (int i = 0; i <arry.length; i++) {
            if (arry[i].compareTo(max)>0){
                max=arry[i];
            }
        }
        return max;

    }

    public static void main(String[] args) {
        GenericityTwo<Integer> genericity=new GenericityTwo<>();
        Integer[]arry={20,21,22,23};
        int ret=genericity.Compare(arry);
        System.out.println(ret);
    }
}

use a static method in the generic class

 class Univversal<T extends Comparable<T>>{
    public static <T extends Comparable<T>> T compare(T[]arry){
        T max=arry[0];
        for (int i = 0; i <arry.length; i++) {
            if (arry[i].compareTo(max)>0){
                max=arry[i];
            }
        }
        return max;
    }

    public static void main(String[] args) {
       Integer[]arry={20,21,22,23};
        int ret=Univversal.<Integer>compare(arry);
        System.out.println(ret);
    }

}

<wildcard character>

public class Message<T> {
    public T message;

    public T getMessage() {
        return message;
    }

    public void setMessage(T message) {
        this.message = message;
    }

    public static void main(String[] args) {
        Message<String> message=new Message<>();
        message.setMessage("通配符");
        fun(message);
    }
    public static void fun(Message<String> message)///{
        String word=message.getMessage();
    }

}

 public static void fun(Message<?> message)
Accept all types

 

<The upper bound of the wildcard >

 

class Food{

}
class Fruit extends Food{

}
class Apple extends Fruit{

}
class Banana extends Fruit{

}
public class MessageTwo<T> {

    public T message;

    public T getMessage() {
        return message;
    }

    public void setMessage(T message) {
        this.message = message;
    }

    public static void main(String[] args) {
        Message<Apple> message=new Message<>();
        message.setMessage(new Apple());
        fun(message);
        Message<Banana> message2 = new Message<>() ;
        message2.setMessage(new Banana());
        fun(message2);
    }
    public static void fun(Message<? extends Fruit> message){
        System.out.println(message.getMessage());

    }



}

 

 Please thiking about:  

 

<The lower bound of the wildcard>

 

  Please thiking about: 

 <Packaging class>