黑马程序员-学习日记（泛型）

[b] ------Java EE培训、Android培训、iOS培训、期待与您交流！ -------[/b]

import java.util.*;

class GD6
{
public static void main(String[] args)
{
ArrayList<Person> al = new ArrayList<Person>();
al.add(new Person("a"));
al.add(new Person("b"));
al.add(new Person("c"));

Iterator<Person> it = al.iterator();
while(it.hasNext())
{
Person p = it.next();
System.out.println(p);
}

ArrayList<Stu> al1 = new ArrayList<Stu>();
al1.add(new Stu("A"));
al1.add(new Stu("B"));
al1.add(new Stu("C"));
printCln(al1);
}

public static  void printCln(ArrayList<? extends Person> al)
{
Iterator<? extends Person> it = al.iterator();
while(it.hasNext())
{
System.out.println(it.next().getName());
}
}
}

class Person
{
String name;
String getName()
{
return this.name;
}
Person(String name){
this.name = name;
}
}
class Worker extends Person
{
Worker(String name)
{
super(name);
}
}
class Stu extends Person
{
String name;
Stu(String name)
{
super(name);
}
}

class tool
{
private Object obj;
public void setObj(Object obj)
{
this.obj = obj;
}
public Object getObj()
{
return obj;
}
}

tool t = new tool();
t.setObj(new Stu("Hynix"));
Worker w = (Worker)t.getObj();//通过编译、但运行时报错






Java早期无泛型，因此传入集合的就是Object对象，取出时就必须要对Object进行强转。

class Utils<F>
{
private F f;
public void setObject(F f)
{
this.f = f;
}
public F getObject()
{
return f;
}
}

Utils u = new Utils<Worker>();
u.setObject(new Stu("Jacky"));//在编译时就会报错
Worker w = u.getObject();



因此，什么时候定义泛型类？在类中要操作的引用数据类型不确定的时候。以前定义Object来完成扩展，现在就定义泛型来完成扩展。

class Demo<T>
{
public <T> void show(T t)
{
System.out.println("show:"+t);
}
public <Q> void print(Q q)
{
System.out.println("print:"+q);
}
}

class GenericDemo4
{
public static void main(String[] args)
{
Demo d = new Demo();
d.show("hello");
d.show(new Integer(4));
d.print("hi");
}
}

泛型限定

通配符<?>,也可以理解为占位符号
? extends E:可以接受E类型或者E的子类型 上限 <? extends E>
? super E:可以接受E或E的父类型 下限  <? super E>

上限什么时候用：往集合中添加元素时，既可以添加E类型对象，又可以添加E的子类型对象。为什么？因为取的时候，
E类型既可以接收E类对象，又可以接收E的子类型对象。?

下限什么时候用：当从集合中获取元素进行操作的时候，可以用当前元素的类型接收，也可以用当前元素的父类型接收。

import java.util.*;

class Gd12
{
public static void main(String[] args)
{
TreeSet<Worker> ts = new TreeSet<Worker>(new comp());
ts.add(new Worker("a"));
ts.add(new Worker("b"));
ts.add(new Worker("c"));

TreeSet<Student> ts1 = new TreeSet<Student>(new comp());
ts1.add(new Student("e"));
ts1.add(new Student("d"));
ts1.add(new Student("f"));

Iterator<Worker> it = ts.iterator();
while(it.hasNext())
{
System.out.println(it.next().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);
}
}
class comp implements Comparator<Person>
{
public int compare(Person p1,Person p2)
{
return p2.getName().compareTo(p1.getName());
}
}