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

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());
    }
}