什么是泛型
泛型的概念
- Java泛型是JDK5中引入的一个新特性，泛型提供了编译时类型安全监测机制，该机制允许我在编译时检测到非法的数据类型。
- 泛型的本质是参数化类型，也就是操作的数据类型被指定为一个参数。
泛型的好处
- 类型安全
- 消除了强制类型的转换
泛型类、接口
泛型类
1.泛型类的定义语法
class 类名称<泛型标识，泛型标识，…>{
private 泛型标识 变量名；
…
}
2.常用的泛型标识:T、E、K、V
3.使用语法
类名<具体的数据类型> 对象名= new 类名<具体的数据类型>();
Java1.7以后,后面的<>中的具体的数据类型可以省略不写
类名<具体的数据类型> 对象名 =new 类名<>();
4.泛型注意事项
泛型类，如果没有指定具体的数据类型，此时，操作类型是Object
泛型的类型参数只能是类类型，不能是基本数据类型
泛型类型在逻辑上可以看成是多个不同的类型，但实际上都是相同的类型
实例1
package fanxing;
/**
* 泛型类的定义
* @param <T>泛型标识--类型形参
* T创建对象的时候指定具体的数据类型
*/
public class Generic<T> {
//T,是由外部使用类的时候来指定的
private T key;
public T getKey() {
return key;
}
public void setKey(T key) {
this.key = key;
}
public Generic(T key) {
this.key = key;
}
@Override
public String toString() {
return "Generic{" +
"key=" + key +
'}';
}
}
package fanxing;
import org.omg.CORBA.INTERNAL;
import java.util.ArrayList;
public class Demo1 {
public static void main(String[] args) {
//泛型类在创建对象的时候来操作具体的数据类型
Generic<String> strGeneric=new Generic<>("abc");
String key = strGeneric.getKey();
System.out.println(key);
Generic<Integer> integerGeneric=new Generic<>(100);
Integer key1 = integerGeneric.getKey();
System.out.println(key1);
//泛型类在创建对象的时候，没有指定类型的时候，将安州Object类型来操作
Generic generic=new Generic("abcd");
Object key2 = generic.getKey();
System.out.println(key2);
//泛型不支持基本数据类型，
//Generic<int> generic1=new Generic<int>(100);
//同一泛型类，根据不同的数据类型创建的对象实际是相同的
System.out.println(integerGeneric.getClass());
System.out.println(strGeneric.getClass());
System.out.println(integerGeneric.getClass()==strGeneric.getClass());//true
}
}
实例2
package fanxing;
import java.util.ArrayList;
import java.util.Random;
/**
* 抽奖器
* @param <T>
*/
public class ProductGetter<T> {
Random random = new Random();
//奖品
private T product;
//奖品池
ArrayList<T> list=new ArrayList<>();
//添加奖品
public void addProduct(T t) {
list.add(t);
}
//抽奖
public T getProduct(){
product= list.get(random.nextInt(list.size()));
return product;
}
}
package fanxing;
public class Demo2 {
public static void main(String[] args) {
//创建抽奖器对象，指定数据类型
ProductGetter<String> stringProductGetter=new ProductGetter<>();
String[] strProducts={"苹果手机","华为手机","扫地机器人","咖啡机"};
//给抽奖器中，填充奖品
for (int i=0;i<strProducts.length;i++){
stringProductGetter.addProduct(strProducts[i]);
}
String product = stringProductGetter.getProduct();
System.out.println("恭喜您,您抽中了:"+product);
System.out.println("------------------");
ProductGetter<Integer> integerProductGetter=new ProductGetter<>();
int[] intProducts={10000,5000,3000,2000};
for (int i = 0; i <intProducts.length ; i++) {
integerProductGetter.addProduct(intProducts[i]);
}
Integer product1 = integerProductGetter.getProduct();
System.out.println("恭喜您,您抽中了:"+product1);
}
}
从泛型类派生子类
子类也是泛型类，子类和父类的泛型类型要一致
* class ChildGeneric extends Generic 注意这两个T一定要一致，就不能一个是T,一个是E
子类不是泛型类，父类要明确泛型的数据类型
* class ChildGeneric extends Generic
实例
package fanxing;
public class Parent<E> {
private E value;
public E getValue(){
return value;
}
public void setValue(E value){
this.value=value;
}
}
package fanxing;
/**
* 泛型类派生子类，子类也是泛型类，那么子类的泛型标识要和父类一致
* 子类如果要扩展泛型必须要包含父类的泛型,如<T,E,K>,而<E,K>这中写法是错误的
* @param <T>
*/
public class ChildFirst<T> extends Parent<T> {
@Override
public T getValue() {
return super.getValue();
}
}
package fanxing;
/**
* 泛型类派生子类，如果子类不是泛型类，那么父类要明确数据类型
*/
public class ChildSecond extends Parent<String> {
@Override
public String getValue() {
return super.getValue();
}
@Override
public void setValue(String value) {
super.setValue(value);
}
}
package fanxing;
public class Test {
public static void main(String[] args) {
ChildFirst<String> childFirst=new ChildFirst<>();
childFirst.setValue("abc");
String value = childFirst.getValue();
System.out.println(value);
ChildSecond childSecond=new ChildSecond();
childSecond.setValue("bbb");
String value1 = childSecond.getValue();
System.out.println(value1);
}
泛型接口
- 泛型接口的定义语法
interface 接口名称 <泛型标识，泛型标识，…>{
泛型标识 方法名（）；
…
}
- 泛型接口的使用
- 实现类不是泛型类，接口要明确数据类型
- 实现类也是泛型类，实现类和接口的泛型类型要一致
使用方法可泛型类差不多，话不多说，看实例
实例
package demo1;
/**
* 泛型接口
* @param <T>
*/
public interface Generator<T>{
T getKey();
}
/**
* 实现泛型接口的类，不是泛型类，要明确泛型接口的数据类型，不写，默认Object
*/
public class Apple implements Generator<String> {
@Override
public String getKey() {
return "hello generic";
}
}
package demo1;
/**
* 泛型接口的实现类，是一个泛型类，那么要保证实现接口的泛型类型要包含接口的泛型类型
* @param <T>
* @param <E>
*/
public class Pair<T,E> implements Generator<T> {
private T key;
private E value;
@Override
public T getKey() {
return key;
}
public E getValue(){
return value;
}
public Pair(T key, E value) {
this.key = key;
this.value = value;
}
}
package demo1;
public class Test {
public static void main(String[] args) {
Apple apple=new Apple();
String key = apple.getKey();
System.out.println(key);
System.out.println("------------");
Pair<String,Integer> pair=new Pair<>("count",100);
String key1 = pair.getKey();
Integer value = pair.getValue();
System.out.println(key1+"="+value);
}
}
泛型方法
-
泛型类，是在实例化类的时候指明泛型的具体类型
-
泛型方法，是在调用方法的时候指明泛型的具体类型
-
语法
修饰符<T,E,...> 返回值类型 方法名（形参列表){ 方法体... }- public与返回值中间非常重要，可以理解为声明此方法为泛型方法。
- 只有声明了的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。
- 表明该方法将使用泛型类型T,此时才可以在方法中使用泛型类型T。
- 与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T,E,K,V等形式的参数常用于表示泛型。
-
泛型方法与可变参数
public <E> void print(E... e){
for(E el : e){
System.out.println(e);
}
}
实例
package fanxing;
import java.util.ArrayList;
import java.util.Random;
/**
* 抽奖器
* @param <T>
*/
public class ProductGetter<T> {
Random random = new Random();
//奖品
private T product;
//奖品池
ArrayList<T> list=new ArrayList<>();
//添加奖品
public void addProduct(T t) {
list.add(t);
}
//抽奖
public T getProduct(){
product= list.get(random.nextInt(list.size()));
return product;
}
/**
* 定义泛型方法
* @param list
* @param <E> 泛型标识，具体类型，由调用方法的时候来指定
* @return
*/
public <E> E getProduct(ArrayList<E> list){
return list.get(random.nextInt(list.size()));
}
/**
* 注意：表边上看这个T跟父类的T是一样的但是，实际上不是同一个，方法的泛型是在方法调用的时候定义使用的，它们互不相干。
* public <T> T getProduct(ArrayList<T> list){
* return list.get(random.nextInt(list.size()));
* }
*/
/**
* 静态的泛型方法，采用多个泛型类型
* 注意：成员的泛型方法定义为静态是错误的
* @param t
* @param e
* @param k
* @param <T>
* @param <E>
* @param <K>
*/
public static <T,E,K> void printType(T t,E e,E k){
System.out.println(t+"\t"+t.getClass().getSimpleName());
System.out.println(e+"\t"+e.getClass().getSimpleName());
System.out.println(k+"\t"+e.getClass().getSimpleName());
}
/**
* 泛型可变参数的定义
* @param e
* @param <E>
*/
public static <E> void print(E... e){
for (int i = 0; i < e.length; i++) {
System.out.println(e[i]);
}
}
}
package demo2;
import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;
import fanxing.ProductGetter;
import org.w3c.dom.ls.LSOutput;
import java.util.ArrayList;
public class Test {
public static void main(String[] args) {
ProductGetter<Integer> productGetter=new ProductGetter<>();
int[] products={100,200,300};
for (int i = 0; i < products.length ; i++) {
productGetter.addProduct(products[i]);
}
//泛型类的成员方法的调用
Integer product2 = productGetter.getProduct();
System.out.println(product2+"" +"\t"+product2.getClass().getSimpleName());
System.out.println("--------------");
ArrayList<String> strList=new ArrayList<>();
strList.add("笔记本");
strList.add("苹果手机");
strList.add("扫地机器人");
//泛型方法的调用，类型是通过调用方法的时候来指定。
String product = productGetter.getProduct(strList);
System.out.println(product+"\t"+product.getClass().getSimpleName());
System.out.println("------------");
ArrayList<Integer> intList =new ArrayList<>();
intList.add(1000);
intList.add(2000);
intList.add(3000);
Integer product1 = productGetter.getProduct(intList);
System.out.println(product1+"\t"+product1.getClass().getSimpleName());
System.out.println("----------------");
//调用多个泛型类型的静态泛型方法
ProductGetter.printType(100,"java",true);
ProductGetter.printType(false,false,true);
System.out.println("------------");
/**
* 泛型方法对可变参数的调用
*/
ProductGetter.print("a","b","c");
ProductGetter.print(1,2,2);
}
}
泛型方法总结
-
泛型方法能使方法独立于类而产生变化
-
如果static方法要使用泛型能力，就必须使其成为泛型方法
类型通配符
什么是类型通配符？
- 类型通配符一般使用“？”代替具体的类型实参。
- 所以，类型通配符是类型实参，而不是类型形参。
实例：
package domo3;
public class Box<E> {
private E first;
public E getFirst() {
return first;
}
public void setFirst(E first) {
this.first = first;
}
}
package domo3;
public class Test {
public static void main(String[] args) {
Box<Number> box1=new Box<>();
box1.setFirst(100);
showBox(box1);
Box<Integer> box2=new Box<>();
box2.setFirst(200);
showBox(box2);
}
//？代表任意实参，可以代表任意类型
public static void showBox(Box<?> box){
Object first = box.getFirst();
System.out.println(first);
}
// public static void showBox(Box<Integer> box){
// Number first = box.getFirst();
// System.out.println(first);
// }
}
类型通配符的上限
-
语法
类/接口<? extends 实参类型>
要求该泛型的类型，只能是实参类型，或实参类型的子类类型。
实例：
package domo3;
public class Test {
public static void main(String[] args) {
Box<Number> box1=new Box<>();
box1.setFirst(100);
showBox(box1);
Box<Integer> box2=new Box<>();
box2.setFirst(200);
showBox(box2);
}
//？代表任意实参，可以代表任意类型
public static void showBox(Box<? extends Number> box){
Number first = box.getFirst();
System.out.println(first);
}
// public static void showBox(Box<Integer> box){
// Number first = box.getFirst();
// System.out.println(first);
// }
}
public class Animal {
}
public class Cat extends Animal{
}
public class MiniCat extends Cat{
}
package domo3;
import java.util.ArrayList;
public class Test1 {
public static void main(String[] args) {
ArrayList<Animal> animals=new ArrayList<>();
ArrayList<Cat> cats=new ArrayList<>();
ArrayList<MiniCat> miniCats=new ArrayList<>();
// cats.addAll(animals);错误
cats.addAll(cats);
cats.addAll(miniCats);
// showAnimal(animals); 错误
showAnimal(cats);
showAnimal(miniCats);
}
/**
* 泛型上限通配符，上传的集合类型，只能是Cat或Cat的子类类型
* @param list
*/
public static void showAnimal(ArrayList<? extends Cat> list){
// list.add(new Animal()); 错误
// list.add(new Cat()); 错误
// list.add(new MiniCat()); 错误
for(int i=0;i<list.size();i++){
Cat cat=list.get(i);
System.out.println(cat);
}
}
}
类型通配符的下限
-
语法
类/接口<? super 实参类型>
要求该泛型的类型，只能是实参类型，或实参类型的父类类型
实例
package domo3;
import java.util.ArrayList;
import java.util.List;
public class TestDown {
public static void main(String[] args) {
ArrayList<Animal> animals=new ArrayList<>();
ArrayList<Cat> cats=new ArrayList<>();
ArrayList<MiniCat> miniCats=new ArrayList<>();
cats.addAll(cats);
cats.addAll(miniCats);
// cats.addAll(animals); 错误
showAnimal(animals);
showAnimal(cats);
// showAnimal(miniCats); 错误
}
/**
* 类型通配符下限，要求集合只能是Cat或Cat的父类类型
* @param list
*/
public static void showAnimal(List<? super Cat> list){
list.add(new Cat());
// list.add(new Animal());错误
list.add(new MiniCat());
for (Object o: list){
System.out.println(o);
}
}
}
案列2
package domo3;
public class Animal {
public String name;
public Animal(String name) {
this.name = name;
}
@Override
public String toString() {
return "Animal{" +
"name='" + name + '\'' +
'}';
}
}
package domo3;
public class Cat extends Animal{
public int age;
public Cat(String name, int age) {
super(name);
this.age = age;
}
@Override
public String toString() {
return "Cat{" +
"age=" + age +
", name='" + name + '\'' +
'}';
}
}
package domo3;
public class MiniCat extends Cat{
public int level;
public MiniCat(String name, int age, int level) {
super(name, age);
this.level = level;
}
@Override
public String toString() {
return "MiniCat{" +
"level=" + level +
", age=" + age +
", name='" + name + '\'' +
'}';
}
}
package domo3;
import java.util.Comparator;
import java.util.TreeSet;
public class Test2 {
public static void main(String[] args) {
// TreeSet<Cat> treeSet=new TreeSet<>(new Comprator2());
TreeSet<Cat> treeSet=new TreeSet<>(new Comprator1());
// TreeSet<Cat> treeSet=new TreeSet<>(new Comprator3()); 错误：因为 public TreeSet(Comparator<? super E> comparator) { this(new TreeMap<>(comparator)); }
treeSet.add(new Cat("jerry",20));
treeSet.add(new Cat("amy",22));
treeSet.add(new Cat("frank",35));
treeSet.add(new Cat("jim",15));
for (Cat cat:treeSet){
System.out.println(cat);
}
}
}
class Comprator1 implements Comparator<Animal>{
@Override
public int compare(Animal o1, Animal o2) {
return o1.name.compareTo(o2.name);
}
}
class Comprator2 implements Comparator<Cat>{
@Override
public int compare(Cat o1, Cat o2) {
return o1.age-o2.age;
}
}
class Comprator3 implements Comparator<MiniCat>{
@Override
public int compare(MiniCat o1, MiniCat o2) {
return o1.level-o2.level;
}
}
类型擦除
- 概念
泛型是Java 1.5版本才引进的概念，在这之前是没有泛型的，但是，泛型代码能够很好的和之前版本的代码兼容。那是因为泛型信息只存在与代码编译阶段，在进入JVM之前，与泛型相关的信息会被擦除掉，我们称之为–类型擦除。
- 无限制类型擦除
public class Erasure<T> {
private T key;
public T getKey() {
return key;
}
public void setKey(T key) {
this.key = key;
}
}
package demo4;
import java.lang.reflect.Field;
import java.util.ArrayList;
public class Test {
public static void main(String[] args) {
// ArrayList<Integer> integerArrayList=new ArrayList<>();
// ArrayList<String> stringArrayList=new ArrayList<>();
//
// System.out.println(integerArrayList.getClass().getSimpleName());
// System.out.println(stringArrayList.getClass().getSimpleName());
//
// System.out.println(integerArrayList.getClass()==stringArrayList.getClass());
Erasure<Integer> erasure=new Erasure<>();
Class<? extends Erasure> clz=erasure.getClass(); //利用反射，获取Erasure获取字节码文件的Class类对象
Field[] declaredFields = clz.getDeclaredFields();//获取所有的成员变量
for (Field declaredField:declaredFields){
System.out.println(declaredField.getName()+":"+declaredField.getType().getSimpleName()); //打印成员变量的名称和类型 key:Object
}
}
}
- 有限制类型擦除
- 擦除方法中类型定义的参数
package demo4;
import java.util.List;
public class Erasure<T extends Number> {
private T key;
public T getKey() {
return key;
}
public void setKey(T key) {
this.key = key;
}
/**
* 这是一个泛型方法
* @param t
* @param <T>
* @return
*/
public <T extends List> T show(T t){
return t;
}
}
package demo4;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class Test {
public static void main(String[] args) {
//获取所有的方法
Method[] declaredMethods = clz.getDeclaredMethods();
for (Method declardeMethod:declaredMethods) {
//打印方法名和方法的返回值类型
System.out.println(declardeMethod.getName()+":"+declardeMethod.getReturnType().getSimpleName());
}
}
}
- 桥接方法
package demo4;
public interface Info<T> {
T info(T t);
}
package demo4;
public class InfoImpl implements Info<Integer> {
@Override
public Integer info(Integer value) {
return value;
}
}
package demo4;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class Test {
public static void main(String[] args) {
Class<InfoImpl> infoClass = InfoImpl.class;
Method[] infoImplMethods = infoClass.getDeclaredMethods();
for (Method infoImplMethod : infoImplMethods) {
System.out.println(infoImplMethod.getName()+":"+infoImplMethod.getReturnType().getSimpleName());
}
}
}
泛型与数组
泛型数组的创建
* 可以声明带泛型的数组引用，但是不能直接创建带泛型的数组对象
* 可以通过java.lang.reflect.Array的newInstance(Class<T>,int)创建T[]数组
package demo5;
import java.lang.reflect.Array;
import java.util.ArrayList;
public class Fruit<T> {
// private T[] array=new T[3]; 错误
private T[] array;
public Fruit(Class<T> clz,int length) {
//通过Array.newInstance创建泛型数组
array = (T[]) Array.newInstance(clz, length);
}
/**
* 填充数组元素
* @param index
* @param item
*/
public void put(int index,T item){
array[index]=item;
}
/**
* 获取数组元素
* @param index
* @return
*/
public T get(int index){
return array[index];
}
public T[] getArray(){
return array;
}
}
package demo5;
import java.util.ArrayList;
import java.util.Arrays;
public class Test {
public static void main(String[] args) {
// ArrayList[] list=new ArrayList[5];
// ArrayList<String>[] listArr=list;
ArrayList<String>[] listArr=new ArrayList[5];
ArrayList<Integer> intList=new ArrayList<>();
intList.add(100);
ArrayList<String> strList=new ArrayList<>();
strList.add("abc");
strList.add("bbb");
// list[0]=intList;
// listArr[0]=intList;
listArr[0]=strList;
String s = listArr[0].get(1);
System.out.println(s);
System.out.println("----------------");
Fruit<String> fruit=new Fruit<>(String.class,3);
fruit.put(0,"苹果");
fruit.put(1,"西瓜");
fruit.put(2,"香蕉");
System.out.println(Arrays.toString(fruit.getArray()));
}
}
泛型和反射
反射常用的泛型类
* Class<T>
* Constructor<T>
package demo6;
public class Person {
private String name;
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
'}';
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
package demo6;
import java.lang.reflect.Constructor;
public class Test {
public static void main(String[] args) throws Exception {
//用反射的泛型创建创建对象更方便，不用再转换
// Class<Person> personClass = Person.class;
// Constructor<Person> constructor = personClass.getConstructor();
// Person person = constructor.newInstance();
Class personClass=Person.class;
Constructor constructor = personClass.getConstructor();
Object o = constructor.newInstance();
}
}
1222
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
