Java泛型

1.何为泛型

2.使用泛型的简单演示

3.泛型类

4.泛型方法

5.泛型接口

6.泛型的类型通配符

6.1设定通配符的上限

1.何为泛型

泛型就是指定一个容器里的元素是固定的一个类型。

如 ： List<String> list  表示 list 中的元素全都要为String类型。

使用泛型后，编译器在编译时，就可以对集合中存储的对象的类型进行检查，一旦发现类型不匹配，就编译失败。这个技术就是泛型。

好处：

1.将程序运行时期的问题转移到了编译时期，可以更好的 让程序员发现问题并解决问题。

2.避免了向下转型的麻烦

总结：

泛型就是应用在编译时期的一项安全机制。

泛型的擦除：

编译器通过泛型对元素类型的检查后，只要检查通过，就会生成class文件，但在class文件中，就将泛型的标识去掉了。

泛型的表现：

泛型的应用在集合框架中用得很多。什么时候要写泛型呢？1.只要看到类或者接口在描述时右边有尖括号< >，就需要泛型。

其实是集合容器在不明确操作元素的类型的情况下，向外提供了一个参数< >，使用容器时，只要将具体类型传递给该参数即可。

说白了泛型就是传递类型参数。跟函数传参是一样的， 只不过函数是往小括号传参，泛型是往尖括号。

#注意：泛型只能装对象。

2.使用泛型的简单演示

示例一：

public class Main {

	public static void main(String args[])
	{
		List<Integer> list = new ArrayList<Integer>(); //用泛型指定 list 操作的元素类型为整型，由于泛型只能装对象，所以用Integer。Integer 是 int 的对象表示
		list.add(1);
		list.add(2);
		list.add(3);
		
		for(Iterator<Integer> it = list.iterator();it.hasNext();)
		{
			System.out.println(it.next());
		}
	}
}

示例二：自定义类的泛型使用

/*Person类文件*/
public class Person implements Comparable<Person> {

	private String name;
	private int age;
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	
	
	public Person() {
		super();
		// TODO Auto-generated constructor stub
	}
	
	@Override
	public int compareTo(Person o) {
		int temp = this.age - o.age;
		return temp==0?this.name.compareTo(o.name):temp; //先通过年龄比较，若年龄相同，再通过名字比较。
	}
	
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	
}

/*Main主文件*/
import java.util.*;

public class Main {

	public static void main(String args[])
	{
		Set<Person> set = new TreeSet<Person>();
		set.add(new Person("xiaoming",28));
		set.add(new Person("xiaohong",22));
		set.add(new Person("zhangsan",31));
		
		for(Person person:set)
		{
			System.out.println(person);
		}
	}
}

3.泛型类

使用泛型类可以对类传入任意类型的参数，而并非只能传入局限的一种类型。

class Apple<E>
{
	E info;
	public Apple(E info)
	{
		this.info = info;
	}
	
	public E getInfo()
	{
		return info;
	}
}

public class Main {
	public static void main(String[] args)
	{
		Apple<String> app1 = new Apple<>("ABCD");
		System.out.println(app1.getInfo());
		
		Apple<Double> app2 = new Apple<>(3.14);
		System.out.println(app2.getInfo());
	}
}

打印结果：

ABCD
3.14

4.泛型方法

泛型方法：该方法中可以传入任意类型的变量。

class Demo<E>
{
	E info;
	
	public void print1(E e)
	{
		System.out.println(e);
	}
	
	public <Q>void print2(Q q)	//泛型方法
	{
		System.out.println(q);
	}
}

public class Main {
	public static void main(String[] args)
	{
		Demo<String> d1 = new Demo<>();		//创建Demo实例时，已经把泛型确定为String
		d1.print1("abc");
		d1.print1(123);			//错误，因为创建Demo实例时，已经把泛型确定为String，所以print1（）只能处理String
		
		d1.print2("abc");		
		d1.print2(123);			//正确，因为print2中又使用了泛型，print2是泛型方法
	}
}

5.泛型接口

interface Inter<T>		//泛型接口
{
	public void fun(T t);
}

class Cla1 implements Inter<String>		//一般类实现泛型接口
{
	public void fun(String t)
	{
		;
	}
}

class Cla2<W> implements Inter<W>		//泛型类实现泛型接口，W的类型由泛型类Cla2决定。
{
	public void fun(W w)
	{
		;
	}
}

6.泛型的类型通配符

先看一段用于遍历 List 容器的代码：

	public void test(List c)
	{
		for(int i=0;i<c.size();i++)
		{
			System.out.println(c.get(i));
		}
	}

这段代码是典型的遍历 List 元素的代码，运行起来是没问题。问题是 List 是一个有泛型声明的接口，而上述代码使用List接口时没有传入类型参数，这将引起一个警告Warnning。如何解决这个警告？就是当传入 List c 作为参数时，给出 List 的类型，但又不知道List 会是什么类型，那可以用<？>代替，如：

public void test(List<?> c)
	{
		for(int i=0;i<c.size();i++)
		{
			System.out.println(c.get(i));
		}
	}

其中，？就是通配符

6.1设定通配符的上限
当通配符为 List<？ extends xx>  表示？表示的类型 一定是 xx类或者是xx类的子类。

import java.util.*;

//顾客类
class Customer
{
	public void BuyFruits(List<? extends Fruit> fruits)  //表示通配符的类型参数一定要是 Fruits类的子类 或是 Fruits类本身
	{
		System.out.println("BUY"+fruits);
	}
}

//抽象水果类
abstract class Fruit
{
	abstract public void Buy(Customer c);
}

//苹果类
class Apple extends Fruit
{
	public String name;
	
	public Apple(String name) {
		super();
		this.name = name;
	}

	public void Buy(Customer c)
	{
		System.out.println("Buy Apple");
	}

	@Override
	public String toString() {
		return "Apple"+this.name;
	}
	
}

//蕉类
class Banana extends Fruit
{
	public String name;
	
	public Banana(String name) {
		super();
		this.name = name;
	}
	public void Buy(Customer c)
	{
		System.out.println("Buy Banana");
	}
	
	@Override
	public String toString() {
		return "Banana"+this.name;
	}
}

public class Main
{
	public static void main(String[] args)
	{
		Customer c = new Customer();
		List<Apple> AppleList = new ArrayList<>();
		List<Banana> BananaList = new ArrayList<>();
		
		Apple a1 = new Apple("红富士");
		Apple a2 = new Apple("青苹果");
		Banana b1 = new Banana("香蕉");
		Banana b2 = new Banana("大蕉");
		
		AppleList.add(a1);
		AppleList.add(a2);
		BananaList.add(b1);
		BananaList.add(b2);
		
		//主要体现是Customer类的BuyFruits方法可以传入不同的类型参数
		c.BuyFruits(AppleList);
		c.BuyFruits(BananaList);
		
	}
}

打印结果：

BUY[Apple红富士, Apple青苹果]
BUY[Banana香蕉, Banana大蕉]