关于泛型

Question

package test;
import java.util.*;
class Animal{
 private String name;
 Animal(String name){
 
 this.name=name;
 
 }
 public String getName(){
    
  return name;
 
 }
}
class Pig extends Animal{ 
  Pig(String name){
   super(name);
 }
}
class Bird extends Animal{
  Bird(String name){
    
super(name);
  
  }
}
class Demo{
public static void main(String[] args){
      
  TreeSet<Pig>ts1 = new TreeSet<Pig>(new Com());
   ts1.add(new Pig("P1"));
   ts1.add(new Pig("P2"));
 
  TreeSet<Bird>ts2 = new TreeSet<Bird>(new Com());
   ts2.add(new Bird("B1"));
   ts2.add(new Bird("B2"));
   method(ts1);
   method(ts2);}
    /*
        构造函数:
        TreeSet(Comparator<? super E> comparator)
        例如:E为Pig
             TreeSet(Comparator<? super Pig> comparator)
    对于以上其可传入类型为:Comparator<Pig>或Comparator<Animal>或   Comparator<Object>
当 传入Comparator<? super Pig>=new Com()时,new Com()为原始类型的对象,为什么不会发出警告?
*/
 public static <T extends Animal> void method(TreeSet<T> ts ){ 
  
    for(Iterator<T>it=ts.iterator();it.hasNext();){
   
    System.out.println(it.next().getName());
   }
 }
}
class Com implements Comparator<Animal>{
 public int compare(Animal a1,Animal a2){
 
  return a1.getName().compareTo(a2.getName());
 
 }
 
}

Answer 1

给一点个人的理解：class Com implements Comparator<Animal> 比较的是Animal对象，而class Pig extends Animal 所以Pig当然也属于Animal,自然属于可以被比较的对象。如有错误 恳请大虾指正。

Answer 2

额,但你想过没,假如有这样的语句 ArrayList<String> as = new ArrayList()
编译器会发出不安全警告,因为没有指明ArrayList要存入的引用类型->可能发生转换异常.

Answer 3

不知道楼主说的到底什么意思，Com类只是你自写了一个实现Comparator接口的比较器而已，为何要警告呢？

Answer 4

Com 类 已经实现了Comparator<Animal>，有什么问题吗?

Answer 5

package cn.fuxi;
import java.util.*;public class fanxing { /**
 * @param args
 */
public static void main(String[] args) {
// TODO Auto-generated method stub ArrayList<Dog> al=new ArrayList<Dog>();


// Game <String>gm=new <String>("SSS"); 不要忘记在new 后面加上Game这一块内存


//Game<String> gm=new Game<String>("hello,world");

Game <Dog> gg=new Game<Dog>(new Dog());

Dog dog1=new Dog();
Cat cat1=new Cat();
// al.add(cat1);/   //出错，但是项正确的话也是可以，继承Dog
al.add(cat1);
cat1=(Cat)al.get(0);
System.out.println(cat1.Hk());


}}class Dog 
{
   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;
}
private String name;
   private int age;
   
}
class Cat  extends Dog
{
private String Time="18:18"; public String Hk()
{
//System.out.println("现在Time是:"+Time);
return Time;
}
}
class Game<G> extends Dog
{
    //  <Dog>是在生成对象前，被指定的对象
public Game(Dog g) //G是一个字符串数据类型
{
g.setAge(10);
System.out.println(g.getAge());
}
}

Answer 6

TreeSet(Comparator<? super E> comparator)class Com implements Comparator<Animal>{
 public int compare(Animal a1,Animal a2){
  
  return a1.getName().compareTo(a2.getName());
  
 }Comparator接口有一个泛型参数，需要指定比较的类型。
而你的实现Com已经指定了类型Animal，所以Com这个类并没有泛型参数，可以直接使用的。
TreeSet<Pig>ts1 = new TreeSet<Pig>(new Com()); //Animal是Pig的父类，可以使用这个比较器。
TreeSet<Bird>ts2 = new TreeSet<Bird>(new Com());/Animal是Bird的父类，可以使用这个比较器。
用了<? Super E>的好处是可以使用父类的比较器，不然你就要对每个类都写一个比较器了。

Answer 7

我的意思就是在有了泛型后:
如果不指定类型会发出警告
例如:
List<String> l =new ArrayList();//会发出安全性警告我上面 传入的是new Com()
TreeSet构造函数接收的是
Comparator<? super Pig>=new Com()->没有发出安全性警告.写个小程序测试下:(单独摘出这一块)
class Father<T>{
  T str;}
class Son extends Father<Integer>{//传递一个实参Integer
                                  //为了测试 public void method(Father<String> t){
 System.out.println(str);
 }
 
 public static void main(String[] args){ new Son().method(new Father<String>());//可以Father<String> t=new Father<String>();
  new Son().method(new Son());//编译失败,无法Son 转换成 Father<String>(无法通过方法调用转换将实    际参数Son转换为Father<String>)
                                //(Father)new Son() ->强制类型提升->仅仅发出警告,为什么? }
}
修改下:
class Father<T>{
  T str;}
class Son extends Father<String>{//改为<String>
                                  //为了测试 public void method(Father<String> t){
 System.out.println(str);
 }
 
 public static void main(String[] args){ new Son().method(new Father<String>());//可以Father<String> t=new Father<String>();
  new Son().method(new Son());//正常,没有警告, Father<String> t =new Son( ),为什么不会发出警告呢?和Comparator例子很类似.
                                                  //如果在这里也强制类型提升(Father)new Son()->编译会发出警告
 }
}