泛型的初步了解

什么是泛型

所谓泛型，即通过参数化类型来实现在同一份代码上操作多种数据类型，泛型编程是一种编程范式，它利用“参数化类型”将类型抽象化，从而实现更为灵活的复用，泛型是jdk1.5推出的新特性，通过限定数据类型，达到安全和避免上下转型的目的。

泛型可以存在于类，方法 接口等；下面着重讲泛型类，泛型方法，通配符， 和限定。

1 泛型类

泛型类的作用在于在创建对象时可以创建不同数据类型的类。

格式  class 类名｛｝ 这里的T,W只是一个参数，而且参数可以多个或只有一个。

public class genericText {
  private T aa;
 private W bb;
 private int cc;
  public genericText(T aa,W bb,int cc){
      this.aa=aa;
      this.bb=bb;
      this.cc=cc;
  }
public T getAa() {
        return aa;
    }

    public void setAa(T aa) {
        this.aa = aa;
    }

    public W getBb() {
        return bb;
    }

    public void setBb(W bb) {
        this.bb = bb;
    }

    public int getCc() {
        return cc;
    }

    public void setCc(int cc) {
        this.cc = cc;
    }
}
class Text{
    public static void main(String[] args) {
        genericText ge=new genericText<>(12,13,14);
        System.out.println(ge.getAa()+ge.getBb()+ge.getCc());
    }
}

输出结果是39，这里 我们发现 在创建对象时，可以两个都是同样的数据类型，，这样的好处可以保证类的多样性，和安全性；

当然了 泛型类也是一种类，可以继承和实现接口。

2，泛型方法

泛型方法可以分为静态泛型方法和 一般泛型方法，且泛型方法可以定义在泛型类中，也可以定义在普通类中，泛型方法意义在于可以让方法处理不同的数据类型。

首先 我们先了解一般泛型方法，泛型方法格式是 修饰符  返回值类型 方法名（T t）｛｝  

当泛型方法在非泛型类时，表示的参数类型是Object类型，当调用方法时可以传输任意数据 。

public class Zi extends Fu {
  public Zi(String name,int age){
      super(name,age);
  }
  public  void fuc(T t){
      System.out.println(t);
  }
}
 class Text1{
     public static void main(String[] args) {
         Zi zi = new Zi("张三",12);
         zi.fuc("泛型方法");
         zi.fuc(12);
     }
 }

输出自然是泛型方法  12 了

当泛型方法定义在泛型类时   我们直

public class genericText {
  private T aa;
 private W bb;
 private int cc;
  public genericText(T aa,W bb,int cc){
      this.aa=aa;
      this.bb=bb;
      this.cc=cc;
  }
  public void fuc(T t){
      System.out.println(t);
  }
  public void fuc1(W w){
      System.out.println(w);
  }
  
  public  void fuc3(B b){
      System.out.println(b);
  }
 
    public T getAa() {
        return aa;
    }

    public void setAa(T aa) {
        this.aa = aa;
    }

    public W getBb() {
        return bb;
    }

    public void setBb(W bb) {
        this.bb = bb;
    }

    public int getCc() {
        return cc;
    }

    public void setCc(int cc) {
        this.cc = cc;
    }
}
class Text{
    public static void main(String[] args) {
        genericText ge=new genericText<>(12,13,14);
        ge.fuc("ya");
        ge.fuc(12);
        ge.fuc1(15) ;
        //ge.fuc1("");   显示只能输入Integer类型
        ge.fuc3(12);
        ge.fuc3("ya1");
    }
}

接看代码我们发现 fuc（）和fuc1（）只是在public差了一个，结果fuc（）可以输入不同类型，而fuc1（）只能输入Integer型的。现在我们来讨论为什么会出现这样的情况。这就要考虑到方法参数覆盖问题，当出现和此代码类似的泛型类，fuc（）时，他们参数名一样，但是方法的参数会覆盖类的参数，方法的参数范围时Object类型，而fuc1则是和泛型类同步的泛型方法。所以被限制只能输入Integer 类型。

静态泛型方法 单独拿出来的意义在于静态的体现，静态属于类本身，不会依赖对象。静态泛型方法格式 如下

修饰符 static  返回值类型 方法名(T t){}  特意强调的是静态泛型方法不可以访问类定义上的泛型。静态泛型方法和静态方法访问一样就用代码展示了。

3 通配符

通配符我们还是比较了解的 ，比如导入包时候的*。 在泛型中通配符的符号是？是一种表示【未知类型】的【类型约束】的方法 通配符只有在修饰一个变量时会用到，使用它可方便地引用包含了多种类型的泛型；一般通配符用于对象和方法  下面分别讨论下通配符的对象上的使用

当通配符在创建对象使用使用时，它是非常尴尬的 因为他的不确定性 所以他只可以接收，却不可以修改，我们举个例子来看

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

public class GenericText1{
    public static void main(String[] args) {
        List li=new ArrayList<>();
        li.add(12);
        List li1 = new ArrayList<>();
        li1.add("ya");
        List li2=new ArrayList<>();
        li2=li;
        li2=li1;
        System.out.println(li2.get(0));
        //li2.add();输入什么都不对 
    }
}

我们在代码中看出 泛型为？的对象可以接收任何元素，却不可以添加元素。这是他的弊端，事实上泛型更多的用在方法里 下面我们来看看 这里一起把 泛型限定给解决了

import java.util.ArrayList;
import java.util.List;
import java.util.Iterator;
public class GenericText1{
    public static void main(String[] args) {
        List li=new ArrayList<>();
        li.add(12);
        li.add(13);
        List li1 = new ArrayList<>();
        li1.add("ya");
        li1.add("a");
        fuc(li);
        fuc(li1);
        fuc1(li);
        fuc1(li1);
    }
    public static void fuc(List list){
        System.out.println(list);
    }
    public static void fuc1(List list1){
       //必须强制向下转型，否则报错
        Iterator> it= (Iterator>) list1.iterator();
   while (it.hasNext()){
       System.out.println(it.next());
   }
    }
}

输出结果

看代码 通配符我们可以很好理解 ，这里出现个 ？extends Object   这就是要讲的限定了 它是上线限定，  他限定的是Object的子类。

即Object的子类都是实际变量。 看到 ？extends 类 上限限定，我们很容易推断出下限限定是？super 类 他限定的是类的父类，和子类一样这里代码就省略了。

注意：Java中的泛型是伪泛型，在编译的时候就会擦拭掉泛型 这里就不做讨论了。