黑马程序员—泛型总结归纳

　　------- android培训、java培训、期待与您交流！ ----------

泛型：JDK1.5版本以后出现的新特性。用于解决安全问题，是一个安全机制。

优点：

1.将运行时期出现的问题ClassCastException,转移到了编译时期，方便于程序员解决问题，让运行时期问题减少。安全。

2.避免了强制转换麻烦。


泛型格式：通过<>来定义要操作的引用数据类型。

在使用java提供的对象时，什么时候写泛型？

通常在集合框架中很常见。
只要见到<>就要定义泛型。

其实<>就是用来接收类型的。

class  GenericDemo
{

public static void main(String[] args) 
{
ArrayList<String> al = new ArrayList<String>(); //明确了集合中元素的数据类型，以防出错
// 与数组相似，从开始定义容器就定义了数据类型
//int []  = new int[3]
al.add("abc01123");
al.add("abc01991");
al.add("abc013");

al.add(4);装箱操作相当于-》//al.add(new Integer(4));  但是编译会出错，因为Integer不能转换为String。这是因为下面对

它进行了转换。

Iterator<String> it = al.iterator(); //注意在迭代器这里也要加上数据类型。因为它是把集合中的元素放到了自己当中
while (it.hasNext())

{

String s = it.next();//加了类型之后这里也不用强制转换了。而且没有了之前没加时的安全提醒。

//注意：GenericDemo.java 使用了未经检查或不安全的操作。

//注意：要了解详细信息，请使用 -Xlint:unchecked 重新编译。

System.out.println(s+":::"+s.length());

}

}

}

如果不加泛型的话需要强制转换对象，因为add方法默认传入的是Object对象，它会把我们传入的对象自动提升成Object对象

这样比较麻烦。

例如有一个Person类建立几个对象，存入集合中。并使用类中的方法：

public static void main(String[] args) 
{

ArrayList al = new ArrayList();

al.add(new Person("lisi01",30));//a1.add(object obj); //Object obj = new Person("lisi01",30);

al.add(new Person("lisi02",32));

al.add(new Person("lisi02",32));

Iterator it = al.iterator();//建立迭代器

while (it.hasNext())

{ //强制转换类型 obj = person; 因为add操作中默认传入的是obj类型，如同上方所示，他就把Person类型提升成了Obj类型。

//Object obj = it.next();//但是下方又要引用Person中才有的方法，所以要进行类型的强制转换。否则编译出错。

//Person p = (Person)obj;

//sop(it.next().getName()+"..."+it.next().getAge());

//简化代码：

Person p = (Person)it.next();

sop(p.getName()+"::"+p.getAge());

}

}

泛型类

格式 class Utils<自定义(泛型)>

当类中要操作的引用类型不确定的时候使用泛型类。

早期定义object来完成扩展，现在定义泛型完成扩展。好处是不需要强转。

例：

class Worker
{
}
//泛型前做法，获取对象的小工具。因为要获取任意的对象，所以这里定义的都是object类
class Tool
{

private Object obj;

public void setObject(Object obj)

{

this.obj = obj;

}

public Object getObject()

{

return obj;

}

}

class Tool
{

private Worker w;

public void setWorker(Worker w)

{

this.w = w;

}

public Worker getWorker()

{

return w;

}

}

class Utils<QQ>
{

private QQ q;

public void setObject(QQ q)

{

this.q = q;

}

public QQ getObject()

{

return q;

}

}
class GenericDemo3
{

public static void main(String[] args) 

{

Utils<Worker> u = new Utils<Worker>();

u.setObject(new Worker());

Worker w = u.getObject(); //使用泛型时可以不用强转

//泛型前做法

Tool t = new Tool(); //获取工具类

t.setObject(new Worker()); //使用工具类方法，并传入自己想要获取的对象

Worker w = (Worker)t.getObject();//获取对象，因为传入的是object类型所以获取时要强制转换

//转换为自己要获取的类型，这个需要自己判断。看自己传入什么类就转换什么类。

}

}

泛型方法

泛型类定义的泛型，在整个类中有效，如果被方法使用，
那么泛型类的对象明确要操作的具体类型后，所有方法要操作的类型就已经固定了
为了让不同方法可以操作不同类型，而且类型还不确定。
那么可以将泛型定义到方法上。

特殊之处：
静态方法不可以访问类上定义的泛型。
如果静态方法操作的引用数据类型不确定。 
可以将泛型定义在方法上。

注意书写格式泛型要写在修饰符后返回值类型前。

class Demo<T>
{
public void show(T t)//泛型方法，可以传入任意类型。 
{
System.out.println("show:"+t);
}

}
public<Q> void print(Q q) //如果类是泛型类，方法也可以是泛型方法。

{ //两者不冲突。都保留原有性能。

//比如如果建立了String对象。但是调用该泛型方法的话，还是可以操作任意类型的数据。

System.out.println("print:"+q);

}

public static <W>void method(W t) //注意在泛型类中的静态方法如果参数与类中的类型一样是会报错的

{ //因为静态方法先在内存中加载，而此时还没有在下方建立对象，就不能确定类型，

//静态中传入的参数类型不确定。所以会报错。因为泛型类中只有类建立才能确定类型。

//所以要给静态方法加泛型这样就解决了。(它就可以不管对方是任何对象就都可以处理了。不用等建立对象明确了。)

System.out.println("method:"+q);

}
}

泛型限定：

?:通配符，也可以理解为占位符。
？ extends E: 可以接受E类型或者E的子类。 上限
？ Super   E: 可以接受E类型或者E的父类。 下限

其实？super E 中的E就是你建立集合中的类型例如TreeSet<Worker>中的Worker.。用它来确定上限下限。自己的父类子类。

例使用了泛型的比较器:

class  GenericDemo
{

public static void main(String[] args) 

{

TreeSet<Student> ts = new TreeSet<Student>(new Comp());

ts.add(new Student("abc03"));

ts.add(new Student("abc02"));

ts.add(new Student("abc06"));

ts.add(new Student("abc01"));

Iterator<Student> it = ts.iterator();

while (it.hasNext())

{

System.out.println(it.next().getName());

}

TreeSet<Worker> ts1 = new TreeSet<Worker>(new Comp());

ts1.add(new Worker("abc03"));

ts1.add(new Worker("abc02"));

ts1.add(new Worker("abc06"));

ts1.add(new Worker("abc01"));

Iterator<Worker> it1 = ts1.iterator();

while (it1.hasNext())

{

System.out.println(it1.next().getName());

}

}

}


class Comp implements Comparator<Person> //<?super E> TreeSet中默认构造函数中定义了传入的比较器comparator中使用了泛型类
{ //这样传入的可以是自己与自己的父类。所以这里传入的类型是父类<Person>
//这样使用一个比较器，就可以给上面两个集合使用了，因为他们都是Person的子类

public int compare(Person p1, Person p2)

{

return p2.getName().compareTo(p1.getName());//这里要注意的是，这里只能使用父类中的方法。因为传入的是父类。

}

}

class StuComp implements Comparator<Student> //以前如果建立两个存储不同对象的集合需要建立两个不同的比较器。用于接收不用的类型。
{

public int compare(Student s1,Student s2)

{

return s1.getName().compareTo(s2.getName());

}

}

class WorkerComp implements Comparator<Worker>
{

public int compare(Worker s1,Worker s2)

{

return s1.getName().compareTo(s2.getName());

}

}

class Person
{

private String name;

Person(String name)

{

this.name = name;

}

public String getName()

{

return name;

}

}
class Student extends Person
{

Student(String name)

{

super(name); //直接调用父类构造函数。

}

}


class Worker extends Person
{

Worker(String name)

{

super(name);

}

}