import java.util.*;
class HashSetTest
{
        public static void sop(Object obj)
        {
                System.out.println(obj);
        }
        public static void main(String[] args)
        {
                HashSet hs = new HashSet();
                hs.add(new Person("a1",11));
                hs.add(new Person("a2",12));
                hs.add(new Person("a3",13));
                hs.add(new Person("a4",14));
                sop(hs.remove(new Person("a3",13)));

                Iterator it = hs.iterator();
                while(it.hasNext())
                {
                        Person p = (Person)it.next();//这里是向下转型是吧，为什么要要这么做呢。是多态吧，父类引用指向子类对象？
                        sop(p.getName()+"::"+p.getAge());
                }

        }
}
class Person
{
        private String name;
        private int age;
        Person(String name, int age)
        {
                this.name = name;
                this.age = age;
        }
    public int hashCode()
        {
                System.out.println(this.name+".....hashCode()");
                return 60;//name.hashCode()+age;
        }

        public boolean equals(Object obj)
        {
                if(!(obj instanceof Person))
                        return false;
                Person p = (Person)obj;
                System.out.println(this.name+"..equals.."+p.age);
                return this.name.equals(p.name) && this.age == p.age;
        }
        public String getName()
        {
                return name;
        }
        public int getAge()
        {
                return age;
        }

}

是多态，由于你程序里没有使用泛型，往Set集合里存的是东西都被视为Object，那么使用迭代器取出来的时候也是Object类型，
getAge()方法是Person类特有的方法，想要使用此方法，需要先强转，即 Person p = (Person)it.next;
如果使用了泛型，将Set限定为Person，那么就是存入的是Person，取出的也是Person，就可以不需要强转了

1. import java.util.HashSet;
   
2. import java.util.Iterator;
   
3. 
   
4. 
   
5. public class HashSetTest
   
6. {
   
7.         public static void sop(Object obj)
   
8.         {
   
9.                 System.out.println(obj);
   
10.         }
    
11.         public static void main(String[] args)
    
12.         {
    
13.                 HashSet<Person> hs = new HashSet<Person>(); //使用泛型，表示集合中存的都是Person，如果存入的时候不是Person对象，编译时报错
    
14.                 hs.add(new Person("a1",11));
    
15.                 hs.add(new Person("a2",12));
    
16.                 hs.add(new Person("a3",13));
    
17.                 hs.add(new Person("a4",14));
    
18.                 sop(hs.remove(new Person("a3",13)));
    
19. 
    
20.                 Iterator<Person> it = hs.iterator();  //这里也要使用泛型，表示取出的都是Person
    
21.                 while(it.hasNext())
    
22.                 {
    
23.                         Person p = it.next();  //取出时不再需要强转
    
24.                         sop(p.getName()+"::"+p.getAge());
    
25.                 }
    
26. 
    
27.         }
    
28. }
    
29. class Person
    
30. {
    
31.         private String name;
    
32.         private int age;
    
33.         Person(String name, int age)
    
34.         {
    
35.                 this.name = name;
    
36.                 this.age = age;
    
37.         }
    
38.     public int hashCode()
    
39.         {
    
40.                 System.out.println(this.name+".....hashCode()");
    
41.                 return 60;//name.hashCode()+age;
    
42.         }
    
43. 
    
44.         public boolean equals(Object obj)
    
45.         {
    
46.                 if(!(obj instanceof Person))
    
47.                         return false;
    
48.                 Person p = (Person)obj;
    
49.                 System.out.println(this.name+"..equals.."+p.age);
    
50.                 return this.name.equals(p.name) && this.age == p.age;
    
51.         }
    
52.         public String getName()
    
53.         {
    
54.                 return name;
    
55.         }
    
56.         public int getAge()
    
57.         {
    
58.                 return age;
    
59.         }
    
60. 
    
61. }
    

复制代码

这样，我还没有看到泛型  你说的我能理解，