黑马程序员——Java学习之泛型

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-

泛型，也许这个词造出来就不是用来让我顾名思义的。所以今天来挖挖泛型的背景和其使用方法。
第一个问题Java在设计时为什么需要泛型？
集合本身来讲是可以存储任何类型的对象；但这又造成一个麻烦，取的时候比较费事。一般情况下，我们都是需要集合只存储一种数据类型。Java为我们提供了一种方式，可以保证一个集合在定义时，就明确里面装什么类型的。这就叫：泛型。
那么问题来了，泛型咋用呢？
定义泛型的语法格式：
集合类类型<引用数据类型> 集合变量名 = new 集合类类型<引用的数据类型>();
格式1：(推荐使用) ArrayList strList = new ArrayList();
这个集合中只能存储String类型，如果想存储其它类型，在编译时就被阻止；
格式2： ArrayList strList = new ArrayList();

使用泛型集合存储自定义对象;

import java.util.List;
import java.util.Vector;
package com.mytest.demo21_使用泛型集合存储自定义对象;

public class Student {
private String name;
private int age;
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
    }
public Student() {
super();
    }
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;
    }
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
    }
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
        Student other = (Student) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
        } else if (!name.equals(other.name))
return false;
return true;
    }
}
public class Demo {
public static void main(String[] args) {
        List<Student> stuList = new Vector<Student>();

        Student stu1 = new Student("邓超",20);
        Student stu2 = new Student("李晨",22);
        Student stu3 = new Student("AngelaBaby",23);

        stuList.add(stu1);
        stuList.add(stu2);
        stuList.add(stu3);

//遍历取出
for(int i = 0;i < stuList.size() ; i++){
         Student stu = stuList.get(i);
         System.out.println(stu.getName() + "," + stu.getAge());
        }       
    }
}

例如：集合类，都支持泛型
泛型类：类本身支持泛型的语法
让我们的MyArrayList支持泛型
1.在类名后加：<变量名>
变量名：可以是大写，可以小写，可以多个，用逗号隔开
这个变量名就类似于一个说明：它说明一个类型；在使用是的编译器确定。

public class MyArrayList<T> {
private Object[] objArray = new Object[10];
private int count = 0;
    boolean add(T obj){
        objArray[count] = obj;
        count++;
return true;
    }   
}

public class Demo {
public static void main(String[] args) {
        MyArrayList<String> list = new MyArrayList<String>();
        list.add("10");
// list.add(20);

    }
}

泛型的通配符：
1.泛型通配符

class A{}
class B extends A{}
class C extends B{}
class D extends B{}
public class Demo {
public static void main(String[] args) {
List<?> list1 = new ArrayList();
List<?> list2 = new ArrayList<Object>();
List<?> list3 = new ArrayList<Student>();
List<?> list4 = new ArrayList<String>();
List<?> list5 = new ArrayList<Integer>();
/* 因为List<?>的声明，不确定是什么类型，所以什么类型都不可以添加；
 但是这个引用可以指向任何类型的集合；
 一般不用来存东西；
 一般用于方法的返回值，用于从里面取东西；*/
        list5.add("aaa");
        list5.add(20);
        list5.add(new Student("张三",20));

//2.? extends E:
List<? extends B> list6 = new ArrayList<>();
//一：引用可以指向什么类型的对象：B的子类泛型的集合；
        list6 = new ArrayList<B>();
        list6 = new ArrayList<C>();
// list6 = new ArrayList<A>();//NO

//二：可以添加什么类型的元素？
//使用? extends E 不能向集合中添加任何类型的元素，因为不确定是哪个B的子类类型；
/*list6.add(new B());//No
 list6.add(new C());//No
 list6.add(new A());//No
 list6.add("aaa");//No
 list6.add(20);//No
 list6.add(new Object());//No
 */

//三：取出来的是什么类型的？必须使用B或者B的父类型接收
        A a = list6.get(0);//OK的，多态
        B b = list6.get(0);//OK的，多态
// C c = list6.get(0);//No

//? super E
//一：引用可以指向什么类型的对象：任何B及B的父类类型的集合
List<? super B> list7 = new ArrayList<>();
        list7 = new ArrayList<A>();
        list7 = new ArrayList<B>();
// list7 = new ArrayList<C>();//No
// list7 = new ArrayList<D>();//No

//二：可以添加什么类型的元素？任何的B及B的子类对象都可以；
// list7.add(new A());//No
        list7.add(new B());//OK的，多态
        list7.add(new C());//OK的，多态

//三：取出来的是什么类型的？任何类型都不可以
/*A a1 = list7.get(0);//No
 B b1 = list7.get(0);//No
 C c1 = list7.get(0);//No
 D d1 = list7.get(0);//No
 */
    }
}

下面我们来扒扒这个泛型在使用过程中可能会出现的一些错误，其中有哪些是理解易出错还是压根就难以理解，就简单举个栗子吧！
兼容性（也就是哪些写法是可以通过编译的）：

Collection c = new Vector();//考虑到对以前代码的兼容性，编译器是可以通过的。
参数化类型可以引用一个原始类型的对象，编译时会报告警告。

Collection c = new Vector();//原来的方法接收一个集合参数，新的类型也要能传进去。原始类型可以引用一个参数化类型的对象，编译时会报告警告。

Vector v = new Vector( ); //错误！
如果以后从v中取出的对象当作String用，而v实际指向的对象中可以加入任意的类型对象。

Vector v = new Vector( ); //错误！
如果以后可以向v中加入任意的类型对象，而v实际指向的集合中只能装String类型的对象
编译器不允许创建泛型变量的数组。

Vector vectorList[ ] = new Vector[10]; //错误！
在创建数组实例时，数组的元素不能使用参数化的类型。

经过这些例子的练手，我可以更好地理解出泛型的设计目的了。
总体而言，泛型是对Java语言的类型系统的一种扩展，以支持创建可以按类型进行参数化的类。当没有使用泛型时，只要是对象，不管是什么类型的对象，都可以存储进同一个集合中。使用泛型集合，可以将一个集合中的元素限定为一个特定类型，集合中只能存储同一个类型的对象，这样更安全；并且当从集合获取一个对象时，编译器也可以知道这个对象的类型，不需要对对象进行强制类型转换，更加方便。

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-