import java.util.*;


class Person
{
        private String name;
        private int age;
        Person(String name,int age)
        {
                this.name = name;
                this.age = age;
        }
       
        public boolean equals(Object obj)
        {

                if(!(obj instanceof Person))   
                  return false;                        
                Person p = (Person)obj;
                System.out.println(this.getName());

                return this.name.equals(p.name) && this.age == p.age;
        }
        /**/
        public String getName()
        {
                return name;
        }
        public int getAge()
        {
                return age;
        }
}
class ArrayListTest3
{
        public static void sop(Object obj)
        {
                System.out.println(obj);
        }
        public static void main(String[] args)
        {
                ArrayList al = new ArrayList();

                //al.add(new Demo());

                al.add(new Person("lisi01",30));//al.add(Object obj);//Object obj = new Person("lisi01",30);
                //al.add(new Person("lisi02",32));
                al.add(new Person("lisi02",32));
                al.add(new Person("lisi04",35));
                al.add(new Person("lisi03",33));
                //al.add(new Person("lisi04",35));

               
                al = singleElement(al);

                sop("remove 03 :"+al.remove(new Person("lisi03",33)));//remove方法底层也是依赖于元素的equals方法。


                Iterator it = al.iterator();


                while(it.hasNext())
                {
                        Person p = (Person)it.next();
                        sop(p.getName()+"::"+p.getAge());
                }
        }


        public static ArrayList singleElement(ArrayList al)
        {
                //定义一个临时容器。
                ArrayList newAl = new ArrayList();

                Iterator it = al.iterator();

                while(it.hasNext())
                {
                        Object obj = it.next();

                        if(!newAl.contains(obj))
                                newAl.add(obj);

                }

                return newAl;
        }
}


请看程序的红色部分 ：  我的问题是我知道contians（Object o）是这样调用：o.equals(e) 方法的   this代表的是O， 而o是Object类型   object中并没有定义name变量   那么为什么this.name 在编译的时候，不会报错呢？  第二个问题  这个e 代表的是什么？ 是容器中存放的对象吗？

Object传入子类Person向下转型，可以调用person的方法， this指的是调用equals（Object   o）的Person实例对象。 第二个equals是调用容器中字符串的比较方法比较的是内容

红色部分我是这样理解的：

       public boolean equals(Object obj){//这个equals()方法是实现本类里面的方法
             if(!(obj instanceof Person))       //判断，如果obj不是Person的类型就返回false，否则继续执行
                    return false;                        
             Person p = (Person)obj;  //把传入的Object强制转换成Persin类型的对象
             System.out.println(this.getName());

                            return this.name.equals(p.name) && this.age == p.age; //this指针是指向本来的，调用this来指向本类的成员在用本类的成员去调用String类里面的equals()方法
        }

楼主，你想的有点过于复杂了；
第一个问题：public boolean equals(Object obj)  这个是类的一个方法，Object obj 是形参类型 和 形参名，类中的方法使用  this.name  表示类的数据成员name，这是为了防止调用出现错误，类的方法当然可以调用自己的数据成员了。
第二个问题：o.equals(e)   中的e ,这个是实参名，当你调用有参数的函数方法时，你要将实参传递给形参，形参名可以随便取，实参名则是你程序中定义的。

红色的部分，既然已经判断过如果是PerSon对象就往下执行，那为什么还要强制转换呢

关于你的第一个问题，为什么return this.name不会报错的问题，我是这样理解的，因为你这个方法是定义在类里面的，在一个类的内部，不管是私有的还是共有的变量，方法内部都是直接可以访问的  你可以随便写个小例子测试一下

Person p = (Person)obj;//这里用了强制转换，下面的this就代表Person了，编译自然没问题
System.out.println(this.getName());
equals（e）//这个e表示你需要传入的实际参数

郑传庆 发表于 2012-6-18 23:16
红色部分我是这样理解的：

       public boolean equals(Object obj){//这个equals()方法是实现本类里面 ...

  过程我知道   我就想问的是 this代表的是那个对象   p代表的又是那个对象

李海 发表于 2012-6-19 10:18
过程我知道   我就想问的是 this代表的是那个对象   p代表的又是那个对象

如果你要说this代表哪个对象，我的理解是代表Person，每一个类都有一个指针，该指针是指向本类的，可以指向该类的全局变量或者对象。


    private String name;
     private int age;
     Person person=null;
     int num=0;
     Person(String name,int age)
     {
             this.name = name;
             this.age = age;
     }
     
     public boolean equals(Object obj)
     {
             int aa;
            if(!(obj instanceof Person))   
               return false;                        
             Person p = (Person)obj;
             System.out.println(this.getName());
             this.person = p;//--------------------------1
             this.num = age;/-------------------2
            return this.name.equals(p.name) && this.age == p.age;
     }

equals(Object obj)是由底层调用的方法。当你在集合中存入对象时，al.add(new Person("lisi01",30));集合中只有一个对象，不比较，当存入al.add(new Person("lisi02",32))，lisi02这个对象调用equals方法
将lisi 01当作参数进行比较，在有对象进入时，也是同样道理。因为lisi02对象调用的方法，所以this 指向lisi02，可以调用成员。你所说的那个e也是容器中的对象。equals（）的参数，调用equals（）的对象与参数进行比较。

王璐 发表于 2012-6-19 10:41
equals(Object obj)是由底层调用的方法。当你在集合中存入对象时，al.add(new Person("lisi01",30));集合中 ...

   不是吧   真是这样吗？  我一直以为   是contains（）这个方法调用的底层的equals（）方法    你去API查一下contians（）方法   你会发现有这个：o==null？ e=null； o.equals(e)

郑传庆 发表于 2012-6-19 10:33
如果你要说this代表哪个对象，我的理解是代表Person，每一个类都有一个指针，该指针是指向本类的，可以指 ...

  我们不是一直认为   谁调用函数   this就指向谁吗？   那你认为在这个程序中   是那个函数在调用底层的equals方法  我认为是contains()

public boolean equals(Object obj)//对于这里传Objec应该没有疑问吧，既然传入的是person，当然也是Object。（因为父类是Object，所以重写应该这样）
        {

                if(!(obj instanceof Person))   
                  return false;                        
                Person p = (Person)obj;（由于传入的是Object类型，而你也知道值就是一个Person，所以Object传入子类Person向下转型，这样就这可以使用子类的成员）
                System.out.println(this.getName());

                return this.name.equals(p.name) && this.age == p.age;（其实这里equals使用的String中的，用于比较String中的两个字符中的内容是否相等）
        }

   有些问题 答案  更本不是我想要的  为什么要给加分呢？