泛型方法 类 接口

　　特点:只有在方法的时候才把<T>写在前面,如果是类或者接口那么就是把<T>写在后面

1.自定义泛型:   其实是一个数据类型的占位符,泛型中不能使用基本数据类型,必须要利用包装基本数据类型对应的类

　　修饰符　　<声明自定义的泛型>返回值类型(未知可以用T表示)　　函数名(使用自定义泛型...){

}

public static <T>T getFactor(T t){}  注意T是所在的地方

public <T>void reverse(T[] arr){}     没有返回值类型的情况

T Type  类型      E  Element    元素

　　基本数据类型对应的包装类:

基本数据类型	对应的包装类
byte	Byte
short	Short
int	Integer
long	Long
double	Double
float	Float
boolean	Boolean
char	Character

2.泛型类, 类上有这个自定义泛型,下面的方法就不需要写自定义泛型了

class　　类名<声明自定义泛型>{

}

　　注意:

　　　　1.在类上自定义泛型的具体数据类型是使用该类创建对象的时候确定的.所以无法添加其他的数据类型,需要重新创建新的对象

　　　　2.在创建这个自定义泛型类时没有制定泛型的数据类型,默认为Object类型!

　　　　3.在类上自定义泛型,不能作用于静态的方法,如果静态的方法需要使用自定义泛型,那么需要在方法上声明使用.

class MyTest<T> {

    public void reverse(T[] arr) {

        for (int startIndex = 0, endIndex = arr.length - 1; startIndex < endIndex; startIndex++, endIndex--) {
            T temp = arr[startIndex];
            arr[startIndex] = arr[endIndex];
            arr[endIndex] = temp;
        }
    }

    public String toString(T[] arr) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < arr.length; i++) {
            if (i == 0) {
                sb.append("{" + arr[i]+",");
            } else if (i == (arr.length - 1)) {
                sb.append(arr[i] + "}");
            } else {
                sb.append(arr[i]+",");
            }
        }
        return sb.toString();
    }
    
    //在类上自定义泛型,不能作用于静态的方法,如果静态的方法需要使用自定义泛型,那么需要在方法上声明使用.
    public static <T>String print(T [] arr){
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < arr.length; i++) {
            if (i == 0) {
                sb.append("{" + arr[i]+",");
            } else if (i == (arr.length - 1)) {
                sb.append(arr[i] + "}");
            } else {
                sb.append(arr[i]+",");
            }
        }
        return sb.toString();
    }
}

public class Demo8 {

    public static void main(String[] args) {
        Integer[] arrInt = { 1, 2, 3, 4, 5 };
        MyTest<Integer> myTest = new MyTest<Integer>();//创建对象的时候,确定泛型类型
        myTest.reverse(arrInt);
        System.out.println(myTest.toString(arrInt));
        System.out.println(MyTest.print(arrInt));
    }
}

3.泛型接口

//接口自定义泛型
//第一种接口自定义泛型方法,在实现这个接口的时候,放入数据类型
interface Dao1<T>{
    
    public void add(T t);
    
}

class Dao1Imp implements Dao1<String>{

    @Override
    public void add(String t) {
        // TODO Auto-generated method stub
        
    }
}

//第二种是在实现这个实现类对象的时候,传入数据类型.
interface Dao2<T>{
    
    public void add(T t);
}

class Dao2Imp<T> implements Dao2<T>{

    @Override
    public void add(T t) {
        // TODO Auto-generated method stub
        
    }
    
}

public class Demo9{

    public static void main(String[] args) {
        Dao2Imp<String> dao2Imp = new Dao2Imp<String>();
        
    }
}

4.泛型的通配符  ? 

/*
     泛型的上限和下限:
                     上限:就是利用extends
                     下限:就是利用super
     泛型的通配符 :  ? 

    //需求: 定义一个函数可以接收任意类型的集合对象(Collection是集合容器的父类),
        要求集合对象只能存储Integer 或者是 Integer 父类的数据类型
*/
public class Demo10 {
    
    public static void main(String[] args) {
        
        LinkedList<Integer> list1  = new LinkedList<Integer>();
        HashSet<Number> list2 = new HashSet<Number>();
        TreeSet<String>    list3 = new TreeSet<String>();//String
        print(list1);
        print(list2); //Number是Integer的父类
        //print(list3);//报错
    }
    
    //上限
        public static void print2(Collection<? extends Number> c){
            
    }
    
    //下限
    public static void print(Collection<? super Integer> c){
        
    }
}