我当天聊聊中的 泛型， 它是一个宽泛经常使用但探讨较少的主题。咱们经常会经常使用它，但大少数开发人员并没有真正了解它。

Java开发中你们必需都用过List或许ArrayList。那你们应该记得如何定义他们吧？

List<Integer>list=newArrayList<>();//这里的Integer就是经常使用了泛型

这就是咱们申明的形式。所以，咱们经常使用了泛型。这里，是咱们传递的指定类型。那是一个类型。在咱们创立这样的列表后，您只能 将整数参与 到列表中。

那假设咱们不指定类型呢？

ListnumList=newArrayList<>();//不指定类型

假设咱们像上方这样定义列表，咱们就可以将从Object超类裁减的任何类型的数据参与到列表中。

所以参与泛型后，咱们可以成功此列表的 类型安保 。

泛型 象征着 参数化类型。 Java让咱们创立一个类、接口和方法，可以在泛型域中与不同类型的数据（对象）一同经常使用。

泛型的优势是：

让咱们举个例子来解释为什么咱们须要泛型。

构想一下，您必需经常使用打印机类打印数字和文本。打印机有一种在创立数据时接受数据的方法。

在传统形式中，咱们必需创立2个类，由于咱们有2种数据类型：数字（整数）和文本（字符串）

publicclassTextPrinter{privatefinalString>经常使用：
publicclassGenericsMn{publicstaticvoidmain(String[]args){NumberPrinternumberPrinter=newNumberPrinter(5);numberPrinter.print();//输入print:::5TextPrintertextPrinter=newTextPrinter("Hello");textPrinter.print();//输入print:::Hello}}
有没有感觉代码重复了？惟一的区别就是数据类型不同！
上方咱们应用泛型来变革一下，使它成为一个通用的类型
publicclassPrinter<T>{privatefinalT>经常使用：
Printer<Integer>integerPrinter=newPrinter<>(5);integerPrinter.print();//输入print:::5Printer<String>stringPrinter=newPrinter<>("Hello");stringPrinter.print();//输入print:::HelloPrinter<Double>doublePrinter=newPrinter<>(45.34);doublePrinter.print();//输入print:::45.34Printer<Long>longPrinter=newPrinter<>(5L);longPrinter.print();z//输入print:::5
如今咱们就只写了一个类，T用来示意作为通用规范的类型。咱们甚至可认为其余数据类型（例如Double/Long）创立打印对象。代码可重用性是经过格调成功的。
咱们还可以创立多个类型的通用类。如下：
publicclassMultiPrinter<T,V>{privatefinalT>Java类型命名商定
有界泛型
这是泛型的初级版本。咱们可以经过有界泛型来限度更多并成功更多类型安保。
假定咱们有一个AnimalPrinter类，它只能打印生物具体信息。不准许与其余物体一同经常使用。如何成功这一指标？
publicclassAnimal{privatefinalStringname;privatefinalStringcolor;privatefinalIntegerage;publicAnimal(Stringname,Stringcolor,Integerage){this.name=name;this.color=color;this.age=age;}publicStringgetName(){returnname;}publicStringgetColor(){returncolor;}publicIntegergetAge(){returnage;}@Overridepublicbooleanequals(Objecto){if(this==o)returntrue;if(o==null||getClass()!=o.getClass())returnfalse;Animalanimal=(Animal)o;returnObjects.equals(name,animal.name)&&Objects.equals(color,animal.color)&&Objects.equals(age,animal.age);}@OverridepublicinthashCode(){returnObjects.hash(name,color,age);}}publicclassCatextendsAnimal{publicCat(Stringname,Stringcolor,Integerage){super(name,color,age);}}publicclassDogextendsAnimal{publicDog(Stringname,Stringcolor,Integerage){super(name,color,age);}}
publicclassAnimalPrinter<TextendsAnimal>{privatefinalTanimalData;publicAnimalPrinter(TanimalData){this.animalData=animalData;}publicvoidprint(){System.out.println("Name:::"+animalData.getName());System.out.println("Color:::"+animalData.getColor());System.out.println("Age:::"+animalData.getAge());}}
在这个类中，T裁减Animal局部成功了上班！咱们限度了狗和猫的通用性！
AnimalPrinter<Cat>animalPrinter1=newAnimalPrinter<>(newCat("Jim","brown",2));animalPrinter1.print();AnimalPrinter<Dog>animalPrinter2=newAnimalPrinter<>(newDog("Rocky","black",5));animalPrinter2.print();
多重界限
假定咱们想向打印机通用性能参与更多性能。咱们可以这样成功。
publicclassAnimalPrinter<TextendsAnimal&Serializable>{..................}
我经常使用Serialized接口提供了Serialized性能。这里有一些关键的事件须要记住。
泛型通配符
通配符由问号?示意在Java中，咱们用它们来指代未知类型。这可以用作泛型的参数类型。而后它将接受任何类型。在上方的代码中，我经常使用通配符将任何对象的列表用作方法参数。
publicstaticvoidprintList(List<?>list){System.out.println(list);}printList(Arrays.asList(newCat("Jim","brown",2),newDog("Rocky","black",5)));printList(Arrays.asList(50,60));printList(Arrays.asList(50.45,60.78));//output://[generics.Cat@b1fa3959,generics.Dog@62294cd9]//[50,60]//[50.45,60.78]
列表如今可以是任何类型！
1️⃣下限通配符
思考这个例子：
publicstaticvoidprintAnimals(List<Animal>animals){animals.forEach(Animal::eat);}
假设咱们构想Animal的子类型，例如Dog，咱们就不能将此方法与Dog列表一同经常使用，即使Dog是Animal的子类型。咱们可以经常使用通配符来做到这一点。
publicstaticvoidprintAnimals(List<?extendsAnimal>animals){...}
如今，此方法适用于类型及其一切子类型。
printAnimals(Arrays.asList(newCat("Jim","brown",2),newDog("Rocky","black",5)));
这称为下限通配符，其中类型是下限。
2️⃣下界通配符
咱们还可以指定具备下限的通配符，其中未知类型必需是指定类型的超类型。可以经常使用super关键字后跟特定类型来指定下限。
例子：
publicstaticvoidaddIntegers(List<?superInteger>list){list.add(newInteger(70));}
通用方法
构想一下，咱们须要一种驳回不同数据类型并口头某些操作的方法。咱们可认为此创立一个通用方法偏重用它。
publicstatic<T>voidcall(T>假设咱们想前往数据而不是VOID，咱们也可以这样做。
publicstatic<T>TgetData(T>咱们也可以在通用方法中接受多种数据类型。
publicstatic<T,V>voidgetMultiData(T>好了,当天的分享就到这里，假设各位感觉老七的文章还不错的话，费事大家动动小手，

java 泛型方法持有多个泛型

这段代码我觉得你要是理解了instance这个关键字就不是很难理解。instance的意思就是比较一个对象是不是属于这个类型，当然这种比较返回的是boolean值。比如上例上说的在遍历list时设置了一个参数t，如果t属于student类型则执行result+=((student)t)();如果t属于teacher类型，则执行result+=((teacher)t)();但这是不推荐的做法，应该很好的应用多态。

还有你说如何迭代，我用上面的例子打印出list的对象啊！

list<t> list=new arraylist<t>(); //创建泛型对象iterator<t> i=();//遍历list中的对象if(()){//判断i中是否有元素，有则返回truet t=(t) ();//获取i中的元素，将其强制转换为t类型并赋给(t);//打印输出}

还有什么不明白的吗？呵呵，希望能帮你解决问题！

Java泛型方法题目

;;;publicclassCollectionSort{publicstaticvoidmain(String[]args){}staticclassPersonimplementsComparable{ private String name; private int age; private String id; public String getName() { return name; } public void setName(String name) { = name; } public int getAge() { return age; } public void setAge(int age) { = age; } public String getId() { return id; } public void setId(String id) { = id; } /** * 默认在这里进行排序 */ public int compareTo(Person p) { // 默认按照name进行排序 int result = (()); if ((())) { // 如果name一样，那么按照年年龄进行排序 result = - (); if ( == ()) { // 如果年龄也一样，那么按照id进行排序 result = (()); } } return result; } } // 定义一个静态方法 public static > void sort(T[] dates) { List l = (dates); (l); } // 对实现comparable接口的对象进行排序从小到大 // 自定义类，Person有属性name,age,id // 定义它的数组,进行排序 } 当然不使用person实现compare接口，使用匿名内部类做排序也可以。