泛型学习笔记：

一. 泛型本质就是参数化类型，将原来的具体类型进行参数化，然后在使用的时候，传入具体的类型 eg: HashSet-->HashSet<String>
   可分为：泛型类，泛型方法，泛型接口
二.泛型类
  在构造类型的时候，给一个通用的值K，来代表一切合法的类，在类实例化的时候，在来明确具体的类型
      public class GenericClass <K> { // 这个类可有在实例化对象时，才明确数据类型
          private K k;
          public K getK() {
              return k;
          }
          public void setK(K k) {
              this.k = k;
          }
      }
      实例化
      public class GenericClassDemo {
          public static void main(String[] args) {
              GenericClass<String> g1 = new GenericClass<String>(); // 这里实例化字符
              g1.setK("哈哈");
              GenericClass<Integer> g2 = new GenericClass<Integer>();// 这里实例化整数对象
              g2.setK(18);
              System.out.println(g1.getK());
              System.out.println(g2.getK());
          }
      }
三.泛型方法：在构造方法时，不明确具体的方法类类型，在调用方法时才明确，实现了一个方法 ，要以同时传入多种对像
  重点：调用方法那一刻通过T来传递类型，实例化成什么对象，可以传多种对象，如下面：A1 A2 A3
  格式：public <T> void 方法名（T t）｛｝
  eg :
  public class GenericMeoth {  // 变通类
      public <T> void Show(T t){  //泛型方法
          System.out.println(t);
      }
  }
  ----------------------------------
  public class GenericClassDemo {
      public static void main(String[] args) {
          GenericMeoth gg = new GenericMeoth();  //实例化对像，这个时候没有明确类型
          gg.Show("哈哈");  //A1 :实例化成字符
          gg.Show(28);     //A2：实例化成整型对象
          gg.Show(new Student("嘿嘿",23).toString());  //A3：实例化成学生对象
      }
  }
 四.泛型接口：
 定义 ：
     public interface GenericIntefase<T> {  //定义一个泛型接口
         void println(T t);
         }
      // 一个类去实现这个接口
      public class GenericImp<T> implements GenericIntefase<T> {
          @Override
          public void println(T t) {
              System.out.println(t);
          }
      }
      //用实现接口的类，来实例对象
      public class GenericClassDemo {
          public static void main(String[] args) {
              System.out.println("-----泛型接口测试-----");
              GenericImp gA = new GenericImp();
              gA.println("哦哦");  字符
              gA.println(39);      整型


          }
      }
五 泛型通配符
   <?>  表示可以接收任何类型
   List<?> 是各种List泛型父类，比如：List<?> 是 List<String>父类，List<?>是不能实例对象的
   <? extends AA> :AA是这个类型的上限类，也就是只能实例化AA及以下的子类
   <? super AA> ：AA是这个类型的下限，也就是只能实例化AA及父类
   eg:
   public class GenericDemoA {
       public static void main(String[] args) {
           //<？>通配符
           List<?> list1 = new ArrayList<Object>();
           List<?> list2 = new ArrayList<Number>();
           List<?> list3 = new ArrayList<Integer>();
           /*
           Class Integer 的继承关系
           java.lang.Object
                java.lang.Number
                    java.lang.Integer
            */
          // <？extend Number> 上限通配符
          //  List<? extends Number> listA = new ArrayList<Object>();  上线是Number所以，不能实例Number以上的类
           List<? extends Number> listA = new ArrayList<Number>();
           List<? extends Number> listB = new ArrayList<Integer>();
           // <？super Number> 下限通配符  不能实例Integer
           List<? super Number> listA1 = new ArrayList<Object>();
           List<? super Number> listA2 = new ArrayList<Number>();
          // List<? super Number> listA3 = new ArrayList<Integer>();下线是Number所以，不能实例Number以下的子类
       }
   }
六. 可变参数 其实质就是把参数封装到数组中
   格式：public static int GetSum(int...a){}  只含有可变参数
        public static int GetSum(int b,int...a){}  含有其它参数时，可变参数要放在参数的最后
   eg:
   public class GenericDemoA {
       public static void main(String[] args) {
           System.out.println(GetSum(10,20,30));
           System.out.println(GetSum(10,20,30,40));
           System.out.println(GetSum(10,20,30,40,50));
       }
       /*
         作用：多个数据求和
         参数：一个数组
         返回值：int
          */
       public static int GetSum(int b,int...a){
           int sum =0;
           for(int s :a){
               sum = s+sum;
           }
           return sum;
       }
   }
七.可变参数的使用
  Arrays
   public Static <T> List<T> aslit(T...a)
   返回的集合不能增删操作，但是可以修改，因为，增删操作会让数据大小发变化
  List
   public Static <E> List<E> aslit(E...e)
   集合不能作增删改操作
  Set
  public Static <E> List<E> aslit(E...e)
  返回的集合不能作增删改操作，不能有重复元素