java泛型

只有指定类型才可以添加待集合中：类型安全

java的泛型只在编译阶段有效，也就是说泛型信息不会进入到运行阶段

普通泛型

public  class Test1 {
    public static void main(String[] args) {
        Test<String> a = new Test<>();
        a.print("jjj");
    }
}

使用

• 泛型类

• /package itheima.myclass;
  
  /**
   * @author 
  //这里的T可以任意的取名，A,B.V都行
  //    一般使用T，意为Type
  public class MyClass<T> {
     private T key;
     public void setKey(T key){
         this.key = key;
     }
     public T getKey(){
         return this.key;
     }
  }
  
  class Test1{
      public static void main(String[] args) {
  //        在mew A对象时指定泛型的类型为String
          MyClass<String> objectMyClass = new MyClass<String>();
  //        对象使用setKey（T Key）方法中的key的形参就是String
          objectMyClass.setKey("77");//返回值有new的对象决定
          
  //        如果不指定类型，那么默认为超类
  //        同样的类，new对象时，不同的泛型不能相互赋值
      }
  }
  

• 泛型方法

  泛型方法在调用之前没有具体数据类型，在调用时，传入的数据是声明类型就会把泛型改成什么类型，也就是说泛型方法会在调用时确定具体数据类型

  class H<E>{
      private E e;
  
      public static<T> void test3(T t) {//静态方法的泛型
          System.out.println(t);
      }
      public<T> void test(T s){//无返回值
          System.out.println(this.e);//在类定义的泛型，可以在普通的方法中使用，在静态方法中不可以使用
          T t =  s;
      }
      public<T> T test1(T s){//有返回值
          return s;
      }
      public<T> void test2(T...s){//可变参数
          for (T s2 : s){
              System.out.println(s2);
          }
      }
      
  }
  

• 泛型接口//类名后面都要指定泛型

  package itheima.myinter;
  //类名后面都要指定泛型,在声明类时，需要将泛型声明也一起加载到类中
  public class Test<O> implements MyInter<O> {
      @Override
      public void print(O o) {//重写方法，指定泛型
          System.out.println(o);
  
      }
  
      @Override
      public O o(O o) {
          return o;
      }
  }
  class B implements MyInter<String>{
  //如果实现接口时指定了接口的泛型的具体数据类型
  //    这个类实现接口所有方法的位置都有泛型替换成具体数据类型
      @Override
      public void print(String o) {
  
      }
  
      @Override
      public String o(String o) {
          return null;
      }
  
  }
  
  class C{
      public static void main(String[] args) {
  //        接口有具体数据类型的，new对象时不用再添加泛型，添加反而是错的
      }
  }
  

通配符

public class Test {
    public static void main(String[] args) {
        ArrayList<String> a = new ArrayList<>();
        a.add("jjk");
        a.add("jj");
        a.add("jjkk");

        ArrayList<Integer> b = new ArrayList<>();
        b.add(4);
        b.add(6);
        b.add(8);

        print(a);
        print(b);
    }
//    泛型通配符：？，加了这个就可以把俩数据类型不一样的泛型用同一个方法或同一个对象输出
    public static void print(ArrayList<?> list){//迭代器
        Iterator it = list.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }

    }
}

有限制的通配符

1. <? extends Number> (无穷小 , Number]

只允许泛型为Number及Number子类的引用调用

1. <? super Number> [Number , 无穷大)

只允许泛型为Number及Number父类的引用调用

1. <? extends Comparable>

只允许泛型为实现Comparable接口的实现类的引用调用

package itheima;

import java.util.ArrayList;
import java.util.List;

public class Tong {
    public void test(List<? extends C> s){}//list集合的参数的数据类型是C及其子类

    public void test2(ArrayList<? extends P> s){}
    public void test1(ArrayList<? super C> s){}//list集合的参数的数据类型是C及其父类
}
class B {}
class C extends B{}
class N extends C{}
class G{
    public static void main(String[] args) {
        Tong t = new Tong();
        List<C> a = new ArrayList<C>();
        t.test(a);

        ArrayList<B> a1 = new ArrayList<>();
        t.test(a1);

        ArrayList<N> a2 = new ArrayList<>();
        t.test(a2);
    }
}
interface P{}