泛型的基本概念
1.什么时候使用泛型：泛型在Java中有着至关重要的作用，Java中所有的集合都需要使用到泛型。只要在使用类或者接口时，该类或者接口在api文档描述时都带着<>，就需要在使用时定义泛型。其实，泛型无非就是通过<>定义了一个形式参数，专门用于接收具体的引用类型。在使用时，一定要传递对应的实际参数类型。
2.泛型的檫除：泛型是JDK1.5之后出现的，所以为了避免修改JVM，就多了一个泛型的檫除，泛型是之出现在编译期的，运行是并没有泛型，也就是说，编译器会按照<>中的指定类型对元素进行检查，检查不匹配，就编译失败，匹配，就编译通过，通过后，产生的class文件中是没有泛型的，这就成为泛型的擦除
3.泛型的补偿：运行时，可以根据具体的元素对象获取其具体的类型，并用该类型对元素进行自动转换。
泛型的基本使用
* T--Type -> 通常在比较器上面见到
* E--Element -> 通常在集合上面见到，或者是自定义的集合
* K,v--Key,Value —> Map<K,V
泛型分为三种类型：
类的泛型比如在自定义一个集合的使用就需要使用到：class MySet<E>{ ... }，下面来个简单的例子
class Myset<E>{
List<E> list = new ArrayList<E>();
public boolean add(E e){
return list.add(e);
}
public boolean delete(E e){
return list.remove(e);
}
public boolean replace(E e1,E e2){
if(!list.contains(e1)){
return false;
}
for (int i = 0; i < list.size(); i++) {
if(list.get(i).equals(e1)){
list.remove(i);
list.add(i, e2);
break;
}
}
return true;
}
public Object[] toArray(){
return list.toArray();
}
public int size(){
return list.size();
}
public E get(int index){
return list.get(index);
}
}@Test
public void test2(){
Myset<String>set = new Myset<String>();
set.add("老干妈");
set.add("保济丸");
set.add("炸牛奶");
set.delete("aa");
set.delete("保济丸");
for (int i = 0; i < set.size(); i++) {
System.out.println(set.get(i));
}
System.out.println("--------");
set.replace("老干妈", "老干爹");
set.replace("炸牛奶", "炸地瓜");
for (int i = 0; i < set.size(); i++) {
System.out.println(set.get(i));
}
/*
老干妈
炸牛奶
--------
老干爹
炸地瓜
*/
}
方法上的泛型也细分为三种，与类捆绑的泛型（相当于前面的类的泛型）、独立于类的泛型、静态方法的泛型
class Show<E>{
//与类捆绑的泛型
public void print(E e){
System.out.println(e);
}
//独立与类的泛型
public <T> void qq(T t){
System.out.println("qq:"+t);
}
//静态方法泛型的使用，不能与类的泛型一致，因为静态是类模板，不能调用对象的实例
public static <T> void yy(T y){
System.out.println("yy:"+y);
}
}@Test
public void test1(){
Show<String> show = new Show<String>();
show.print("123");
}
@Test
public void test3(){
Show<Integer>show = new Show<Integer>();
show.qq("二手苹果");
}
@Test
public void test4(){
Show.yy("石头蚊帐二叉树");
}
接口中的泛型使用与前面的使用也差不多，就是在实现类的时候也需要给一个泛型
public class InteGT {
public static void main(String[] args) {
Bill<Integer> b = new billImp<Integer>();
b.showBill(100);
/*
以上操作相当于
List<Integer>list = new ArrayList<Integer>();
list.add(10);
*/
}
}
//接口
interface Bill<E>{
void showBill(E e);
}
//实现类
class billImp<E> implements Bill<E>{
@Override
public void showBill(E e) {
System.out.println("下一站：茶山刘"+e);
}
}泛型的高级应用
高级泛型使用通配符？来表示
当操作的不同容器中的类型都不确定的时候，而且使用的都是元素从Object类中继承的方法， 这时泛型就用通配符?来表示即可。（助理解的比方: 泛型中的多态应用)
@Test
public void test2(){
Set<Integer>set1 = new HashSet<Integer>();
set1.add(1);
set1.add(2);
set1.add(3);
set1.add(4);
Set<String>set2 = new HashSet<String>();
set2.add("闪电侠");
set2.add("蝙蝠侠");
set2.add("钢铁侠");
set2.add("蜘蛛侠");
printAllSet(set1);
printAllSet(set2);
}
/**
* 兼容所有，相当于多态中的Object
* @param set
*/
public void printAllSet(Set<?>set){
for (Object object : set) {
System.out.println(object);
}
}
泛型的上下兼容：泛型有上限和下限之分
对操作的类型限制在一个范围之内。比如：定义一个功能，只操作Person类型或者Person的子类型。这时可以用:
? extends E:接收E类型或者E的子类型。这就是上限。
? super E: 接收E类型或者E的父类型。 这就是下限。
这里就演示一下泛型的上限
@Test
public void test1(){
Set<Person>set = new HashSet<Person>();
set.add(new Student("Bally", 18, "计算机"));
set.add(new Student("Sammi", 19, "商务英语"));
set.add(new Student("Oliv", 20, "射箭"));
set.add(new Worker("老干爹", 53, "卖老干妈"));
set.add(new Worker("老干妈", 52, "卖老干爹"));
set.add(new Worker("老王", 54, "吃老干妈"));
print(set);
}
class Person{
public String name;
public int age;
public Person(String name,int age){
this.name = name;
this.age = age;
}
}
class Student extends Person{
String specialty;
public Student(String name, int age,String specialty) {
super(name, age);
this.specialty = specialty;
}
}
class Worker extends Person{
String job;
public Worker(String name, int age,String job) {
super(name, age);
this.job = job;
}
}
