泛型的一些问题

泛型的概念：把类型明确工作推迟到创建对象或者调用方法时才明确的一种机制；

泛型的语法 ： <引用类型,引用类型…>

1. 使用泛型好处是避免了向下转型，例如集合中的元素：

//如果不使用泛型，取出元素后，需要向下转型成为本类才可以获得；
		ArrayList arrayList = new ArrayList();
		arrayList.add("abc");
		arrayList.add("abc");
		arrayList.add("abc");
		arrayList.add("abc");
		Object obj = arrayList.get(0);
		String string= (String) obj;
//使用泛型后，就可以直接取出元素；
 		ArrayList<String> list2 = new ArrayList<String>();
        list2.add("abc");
        list2.add("abc");
        list2.add("abc");
        list2.add("abc");
        String s = list2.get(0);
        System.out.println(s);

2. 泛型也可以应用到类，方法和接口上：
   2.1.类：

//定义的泛型Demo类，指的是成员变量类型为泛型；
public class Demo <T>{
    private  T  object;

    public T getObject() {
        return object;
    }

    public void setObject(T object) {
        this.object = object;
    }
}
//测试类：
public class MyTest {
    public static void main(String[] args) {
        Demo<String> stringDemo = new Demo<>();//创建泛型类对象，明确对象类型；
        stringDemo.setObject("string");//赋值元素只能是String类；
        System.out.println(stringDemo.getObject());

    }
}

2.2. 接口：

//创建泛型到接口上，接口中方法的返回值和形参都是泛型，等到实现接口时，才明确具体的类型；
public interface MyInterface<T,U> {
    U show(T t);
}

//1. 创建匿名内部类时明确接口上的类型：
public class MyTest {
    public static void main(String[] args) {
        new MyInterface<String,String>(){
            @Override
            public String show(String s) {
               return null;
            }
        };
}

//2. 或者实现泛型接口时明确：
public class Son implements MyInterface<String,Integer> {
    @Override
    public Integer show(String s) {
        return null;
    }
}

//3. 泛型类也可以实现泛型接口，最后可以在测试类main函数里创建该类对象，明确该接口类型：
public class Son2<T,U> implements MyInterface<T,U>{
    @Override
    public U show(T t) {

        return null;
    }
}

public class MyTest {
    public static void main(String[] args) {
        
        Son2<Integer, Integer> integerIntegerSon2 = new Son2<>();
      
    }
}

3.3. 方法：

public class MyTest {
    public static void main(String[] args) {
        MyUtils myUtils = new MyUtils();
        myUtils.set(100);
        myUtils.set("abc");
        myUtils.set(new Object());
    }
}
class MyUtils{
   //泛型方法：返回值和形参类型都是泛型；
     public<T> void set(T t){
         System.out.println(t);
     }
}

注意：<?>为泛型通配符

public class MyTest2 {
    public static void main(String[] args) {
        //向上限定：集合传入的元素只能是元素本类对象或者父类；
        ArrayList<? super Person> list = new ArrayList<Person>();
        ArrayList<? super Person> list1 = new ArrayList<Object>();
        //向下限定：集合传入的元素只能是元素本类对象或者子类；
        ArrayList<? extends Person> people = new ArrayList<Person>();
        ArrayList<? extends Person> people1 = new ArrayList<Student>();

    }
}
class Person{

}
class Student extends Person{

}
class Doctor extends Person{

}
class  Nurse extends  Person{

}