泛型

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

// 多个泛型可以使用逗号（,）进行分隔

/**
* 可以使用泛型约束
*  设置下限
* <？extends T> 设置上限
*  只能在使用泛型类时，限制泛型下限 不能再创建泛型类，创建泛型方法时使用，但是 <？extends T>可以使用
*
*
* 泛型类需要在声明类的时候 进行泛型限定 ps: Test test = new Test<>();
* 泛型方法可以直接使用 test.sout(data);
*
*/

public class Test {
 private T var;
 private X x;
 private Y y;

  public T getVar() {
      return var;
  }

  public void setVar(T var) {
      this.var = var;
  }

  public X getX() {
      return x;
  }

  public void setX(X x) {
      this.x = x;
  }

  public Y getY() {
      return y;
  }

  public void setY(Y y) {
      this.y = y;
  }

  public   void sout(T data){

      List integerList = new ArrayList<>();
      integerList.add(1);
      integerList.add(2);

      List numbers = new ArrayList();
      numbers = integerList;
      System.out.println(numbers);

      //  只能在使用泛型类时，限制泛型下限 不能再创建泛型类，创建泛型方法时使用，但是 <？extends T>可以使用
      List list=new ArrayList<>();
      list = integerList;
      System.out.println(list);

      Test objectNumberObjectTest = new Test<>();
      objectNumberObjectTest.setVar(1);
      objectNumberObjectTest.setX(1);
      objectNumberObjectTest.setY(1.0f);
      // objectNumberObjectTest.sout();

      TestSuper integerFloatTest = new TestSuper<>();


      System.out.println(data);
  }

  public static void main(String[] args) {
      Test test = new Test<>();
      test.setVar("我是泛型类");
      test.setX(1);
      test.setY(1.0f);
      System.out.println(test.getVar());
      System.out.println(test.getX());
      System.out.println(test.getY());

      // sout("我是泛型方法");
      Integer integer = 1;
      test.sout(integer);
  }
}

class TestSuper{


}