class Person
{
        private String name;
        private int age;
        Person(String name,int age)
        {
                this.name=name;
                this.age=age;
        }
        public String getName()
        {
                return name;
        }
        public int getAge()
        {
                return age;
        }
}
class ArrayListTest
{
        public static void sop(Object obj)
        {
                System.out.println(obj);
        }
        public static void main(String[] args)
        {
                ArrayList al=new ArrayList();
                al.add(new Person("ll01",22));
                al.add(new Person("ll02",23));
                al.add(new Person("ll03",24));
                al.add(new Person("ll04",26));

                Iterator it=al.iterator();
                while(it.hasNext())
                {
                        Object obj=it.next();
                        Person p=(Person)obj;//这是咋么个情况?是如何定义的？谁能帮我详细走一遍？(Person)obj是什么意思？
                        sop(p.getName()+"::"+p.getAge());
                }
        }
}

Object obj=it.next();
Person p=(Person)obj;//这个是强制类型转换，obj本来是Object类型的，要把它转换成Person类型的

当你使用集合又没有使用泛型的时候，存入集合里边的所有东西都会变成object了  所以当你取出来的时候需要转换类型  
    Person p=(Person)obj;//你这句话意思就是把obj转换为Person类型...

Object obj=it.next();
Person p=(Person)obj;
这句话是由于iterator是泛型的类；不知道你要遍历的是什么类型；如果不用泛型Iterator<person> it=al.iterator();
就必须要告知是什么类型的变量；这样迭代器才会识别。这里用的是java1.2的方法。还没有泛型之前；
就是用Object来代替泛型的；由于你的it。next（）是返回objec类型的变量；所以要强转为person类的才可以操作；
如果不强转，只有object的方法，谁都会奔溃的；所以（person）后就有person的方法啦

class Person
{
        private String name;
        private int age;
        Person(String name,int age)
        {
                this.name=name;
                this.age=age;
        }
        public String getName()
        {
                return name;
        }
        public int getAge()
        {
                return age;
        }
}
class ArrayListTest
{
        public static void sop(Object obj)
        {
                System.out.println(obj);
        }
        public static void main(String[] args)
        {
                ArrayList al=new ArrayList();//创建一个ArrayList数组al。
                al.add(new Person("ll01",22));
                al.add(new Person("ll02",23));
                al.add(new Person("ll03",24));
                al.add(new Person("ll04",26));//往al数组中添加了四个匿名的Person对象。

                Iterator it=al.iterator();//创建了一个al数组的迭代器it。它能够使用迭代器中的hasNext()方法判断他的下一个元素是否存在。它是一个泛型类，
                                                  //如果你这样写  Iterator<Person> it=al.iterator() ;就用到了泛型，下面就不用再进行强制转换了。可以直接写成Person p = it.next();
                while(it.hasNext())//当it.hasNext()为true时，也就是说他有下一个元素。
                {
                        Object obj=it.next();//这个时候迭代器it就可以调用它的next() 方法来取出下一个元素，把取出来的Person类的元素向上转型，转为Object类并赋值给obj。
                                                          //因为Object类是所有类的父类。所以这里是多态的一种体现。
                        Person p=(Person)obj;//这句话的意识就是把从obj的类型向下转型。把obj强制转换为原来的Person类。并赋值给对象p。
                        sop(p.getName()+"::"+p.getAge());//调用本类中的静态方法打印。
                }
        }
}

集合中存储的是person类的对象，你没有使用泛型，所以it.next()返回来的是Object的对象，你需要进行向下转型
使用泛型后的代码如下：
import java.util.*;
class Person
{
         private String name;
         private int age;
         Person(String name,int age)
         {
                 this.name=name;
                 this.age=age;
         }
         public String getName()
         {
                 return name;
         }
         public int getAge()
         {
                 return age;
         }
}
class ArrayListTest
{
         public static void sop(Object obj)
        {
                 System.out.println(obj);
         }
         public static void main(String[] args)
        {
                 ArrayList<Person>al=new ArrayList<Person>();
                 al.add(new Person("ll01",22));
                 al.add(new Person("ll02",23));
                 al.add(new Person("ll03",24));
                 al.add(new Person("ll04",26));

                Iterator<Person> it=al.iterator();
                 while(it.hasNext())
                 {
                         //Object obj=it.next();
                        // Person p=(Person)obj;//这是咋么个情况?是如何定义的？谁能帮我详细走一遍？(Person)obj是什么意思？
                         Person p=it.next();
                                                 sop(p.getName()+"::"+p.getAge());
                 }
         }
}

这是多态里面的知识。
  我们老师讲解的是向下类型转换。即转成子类型。
  这样做可以调用子类里特有的方法。
什么时候使用向上转型，和向下转型呢？
当需要对程序进行扩展，或者限定对对象的方法操作时，使用向上转型。
操作其父类型。
当要使用子类的特有的内容时，就需要向下转型。
转型前一定要判断，否则容易出现问题。
注意：
在这个转型过程中，自始自终都是一个子类对象在做着类型的变化而已。
Object obj=it.next();
   是子类对象的类型提升。向上转型。   
好处：提高了扩展性，局限：只能使用父类中的方法。
这种提升可以限制对子类对象的操作。              
   Person p=(Person)obj
向下转型。 转成子类型。
可以使用子类的特有方法。
弊端，如果类型转换错误，会出现运行异常。
希望对楼主有所帮助。

首先LZ要明白，在java中Object类是根类，是所有类的根。也就是说当你定义一个类时，没有给它指定父类，那么它就是它的父类就是Object类。
在这里，LZ定义Person类时，并没有给它指明父类，那么它就默认为Object类的子类。
obj是Object类的对象，那么它就可以向下转换成子类的对象，就如下面这样的操作就可以：
Person p=(Person)obj; //这是咋么个情况?是如何定义的？谁能帮我详细走一遍？(Person)obj是什么意思？
(Person)obj的意思是把obj对象强制向下转型为Person对象。

               Iterator it=al.iterator();
                while(it.hasNext())
                {
                        Object obj=it.next();
                        Person p=(Person)obj;//这是咋么个情况?是如何定义的？谁能帮我详细走一遍？(Person)obj是什么意思？
                        sop(p.getName()+"::"+p.getAge());
                }

1、哥们，你辛辛苦苦的创建一大堆Person，并给他们贴上Person的标签，把它们放到了一个ArrayList容器里面。
      这时候你想把它们取出来，其实可以使用高级for循环的
        for(Person p:al)
       {
           对取出来的每一个Person做你喜欢的操作。
        }

2、可惜你要用迭代器，迭代器是另外一种容器，它里面可以装Object,
     ①iIterator it=al.iterator():  你把所有的Person从ArrayList里面取出来，往it里面放，这时你发现it里面只能放Object；
     ② 不过Person也是Object啊，就像奥迪也是汽车一样，系统帮你在Person上面贴了一个Object标签，就可以往里面放了，就像奥迪是汽车一样，不用你管，系统就知道他是Object

3、现在，好了，it里面装了很多Object了，你通过它的it.next()把它们都取出来了
      Person p=(Person)obj ，这时你发现你取出来都是Object,坑爹了，我放进去Person，取出来却是Object了，
       为了知道这些Object，你撕掉了他们的Object标签，在看它们的标签就是Person了
      
(Person)obj ：就是撕掉Obj的标签，看看他到底是什么，发现它们是个Person，（Person)就相当于，你又给它们贴了Person标签了。

4、来个例子：奥迪、、宝马、桑特拉、.....,现在有一个仓库，只能存放车，为了把这些放进去，不管3721，给他贴上汽车标签，放了 进去  。现在，我又要把汽车取出来，要根据他们的实际情况，卖掉它们。我随机取出来一辆，撕开它的标签，发现，郁闷了，是俩桑特拉，5000甩卖了。哥们，你也来取了一辆，当你撕开标签是，我们都崩溃了，是俩自行车，留着自己用算了。

al.add(new Person("ll01",22));
al.add(new Person("ll02",23));
al.add(new Person("ll03",24));
al.add(new Person("ll04",26));


这里添加的都是Person对象,obj就是那add()的对象