我们在按照正常的写法，在集合中添加一些不是同类型的数据，在遍历的时候，报错了，这是为什么呢？
我们在存储数据的时候，存储了一些String和Integer类型的数据，但是在遍历的时候，默认集合中只存放String类型的数据，但是呢，又没有在存储数据的时候告诉我只能存String类型的数据。
java中集合就模仿着数组呢，也有这样的做法，在创建集合的时候，就明确了
元素的数据类型，创建后，再往集合中加入的元素，只能是定义好的数据类型相关的
数据了，然后再向下转型就没有问题了。
这样的技术，java中叫做：泛型

泛型

概念

   把明确的数据类型的工作，提前到了编译时期，在创建集合的时候明确数据类型。这样的做
   法有点像把数据类型当作参数一样进行传递，所以泛型还有一个名字：
   叫做：参数化类型。

定义

格式

<引用数据类型>
注意：尖括号中的数据类型只能是引用数据类型

作用

1. 把我们之前运行时候出现的问题，提前到编译时期
2. 不需要强制类型转换
3. 优化了代码，清楚不必要的黄色警告线

我们通过API发现，泛型可以出现在类、接口、方法上，看到一些类似yu，一般来说泛型出现在大多数的使用集合中

案例

public class GenericDemo1{
	public static void main(String[] args){
		//创建集合对象
		//jdk1.7后会自动的判进行类型断
		ArrayList<String> list = new ArrayList<String>();
		
		list.add("hello");
		//list.add(10)向上转型
		list.add("world");
		list.add("bigdata");


		//获取迭代器对象
		Iterator<String> it = list.iterator();
		while(it.hasNext()){
			String next = it.next();
			System.out.println(next + "--" + next.length());
		}
	}
}

泛型通配符

概念

字面意思，任意类型，如果没有明确，那么就是Object以及任意的Java类类。

定义

1. ? extends E - - -向下限定，E及其子类
2. ? super E - - -向上限定，E及其父类

public class Dog extends Animal {
}


public class Cat extends Animal {
}

public class Animal {
}

public class GeneriDemo2{
	public static void  mian(String[] args){
		//如果泛型里面的类型只用一个，并且明确数据类型的时候，前后必须要写一致
		ArrayList<Animal> list1 = new ArrayList<Animal>();
		ArrayList<Dog> list2 = new ArrayList<Dog>();
		ArrayList<Object> list3 = new ArrayList<Object>();

		//泛型通配符
		ArrayList<?> object1 = new ArrayList<Animal>();
		ArrayList<?> object2 = new ArrayList<Dog>();
		ArrayList<?> object3 = new ArrayList<Cat>();
		//注意这样写是错的
		// ArrayList<? extends Animal> list0 = new ArrayList<Object>();

		//? extends E向下限定，E及其子类
		ArrayList<? extends Animal> list4 = new ArrayList<Animal>();
		       ArrayList<? extends Animal> list5 = new ArrayList<Dog>();
        ArrayList<? extends Animal> list6 = new ArrayList<Cat>();
       // ArrayList<? extends Animal> list0 = new ArrayList<Object>();


        //? super E 向上限定，E及其父类
        ArrayList<? super Animal> list7 = new ArrayList<Animal>();
        ArrayList<? super Animal> list8 = new ArrayList<Object>();
//        ArrayList<? super Animal> list9 = new ArrayList<Dog>();
	}
}

下面我们继续看看泛型类，泛型方法和泛型接口

泛型类

顾名思义就是把泛型定义在类上

格式：public  class 类名<泛型类型1，...>

注意：这里泛型类型必须是引用类型

这里的<>里面的内容仅仅表示是一种参数数据类型，参数数据类型是一种变量，既然是
一种变量，就符合变量的命名规则，可以是任意符合标识符起名规则的名字

小小案例

public class GenericTool1<T> {
	private T obj;
	    public T getObj() {
        return obj;
    }

    public void setObj(T obj) {
        this.obj = obj;
    }
}
/*
        泛型类的测试
 */
public class GenericTest1{
	public static void main(String[] args){
	//不加泛型，默认是Object类型
		GenericTool1 gt1 = new GenericTool1();
		gt1.setObj("hello");
		gt1.setObj(20);
		gt1.setObj(new Student());

		GenericTool1<String> gt2 = new GenericTool1();
		gt2.setObj("hello");
		//这样就是错的
		//        gt2.setObj(20);
		String obj = gt2.getObj();
	}
}

泛型方法

顾名思义就是把泛型定义在方法上

格式：public <泛型类型> 返回类型 方法名(泛型类型 .)

public class GenericTool2 {
//    public void show(String s){
//        System.out.println(s);
//    }
//
//    public void show(int i){
//        System.out.println(i);
//    }
//
//    public void show(double d){
//        System.out.println(d);
//    }

    public <T> void show(T t){
        System.out.println(t);
    }

}
上面这样使用泛型方法就避免了我们要定义好多次不同类型的方法。

/*
        泛型方法的使用
 */

public class GenericTest2{
	public static void main(String[] args){
		//        GenericTool2 gt1 = new GenericTool2();
//        gt1.show(10);
//        gt1.show("hello");
//        gt1.show(12.34);
//        gt1.show(new Student());

//        GenericTool2<String> gt2 = new GenericTool2<>();
//        gt2.show("hello");
        gt2.show(20);
//        GenericTool2<Integer> gt3 = new GenericTool2<>();
//        gt3.show(20);
//
        //到目前为止，如果你能看懂，说明泛型类你是可以掌握的
        //但是有个问题，谁规定了方法的参数类型一定要和类的类型一致呢？
        //如果类上面没有泛型的话，方法还能不能随便传参呢？

//我们把类上的泛型去掉，写在方法上吗，来试试
		GenericTool2 gt1 = new GenericTool2();
		gt.show("hello");
		gt.show(20);
		gt.show(true);
		
	}
}

泛型接口

顾名思义就是定义在接口上的泛型

public interface GenericTool3{
	public abstract void show(T t);
}

public class GenericTool3Impl<T> implements GenericTool3<T>{
    @Override
    public void show(T t) {
        System.out.println(t);
    }
}

/*
        泛型接口的测试
 */

public class GenericTest3{
	public static void main(String[] args){
		GenericTool3Impl<String> sgt1 = new GenericTool3Impl<>();
		sgt1.show("hello");
	}
}

案例

/*
        获取10个1-20之间的随机数，要求不能重复
        数组可以实现码？长度不好确定，我们选择集合

        Random类：public int nextInt(int bound) :左闭右开


 */`

public class RandomTest{
	public static void main(String[] args){
		//1.创建随机数对象
		Random random = new Random();
		//2.创建集合来保存随机数对象
		ArrayList<String> list = new ArrayList();
		

		//定义一个变量统计集合中是否有10个随机数
		int count = 0;
		while(count < 10){
			//产生随机数
			int i = random.nextInt(20)+1 ;
			//判断集合中是否有该随机数
			if(list.comtains(i)){
				list.agg(i);
				count++;
			}
		}
		System.out.println(list);
	} 
}

最后

以上就是坚定乐曲为你收集整理的Java进阶之--------泛型泛型泛型通配符的全部内容，希望文章能够帮你解决Java进阶之--------泛型泛型泛型通配符所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。