非常经典的问题！！！， 拜托了！！

Question

请问， 这个世界上先有的鸡蛋还是 鸡？ 请用 oop思想去解释！！！！！谢谢！！！！

Answer 1

YD跟JH卿天，YD抱怨道：还说是兄弟，难道你没看见，独眼龙这一阵子经常进来捣乱，磨磨蹭蹭赖着不走，每次走的时候还随地吐痰．你也不过来帮我？JH觉得有些惭愧，小声解释道：几次我都想过来，可我害怕呀，你知不知道，独眼龙他太狠了，每次来的时候都会先在我门上挂两个手雷．

Answer 2

OOP啊各位！
前面两个O长得不像蛋吗？后面那个P有尾巴所以是鸡。正解应该是：
先有两个蛋，才有一个鸡

Answer 3

是母鸡吧~~~~~~~~~~~~~~~面向对象思想是这么解释的：
鸡里有蛋
蛋里有鸡
public class NoName {
public static void main(String[] args) {
// 一只母鸡
Hen h = new Hen();
// 下蛋
Egg e_h = new Egg();
h.setEgg(e_h); // 一个蛋
Egg e = new Egg();
// 孵公鸡
Chicken c_e = new Cock();
e.setChicken(c_e); // 一个蛋
Egg e1 = new Egg();
// 孵母鸡
Chicken c_e1 = new Hen();
e1.setChicken(c_e1);
}
}/**
 * 鸡
 * 
 * @author gg
 * 
 */
class Chicken {}/**
 * 母鸡
 * 
 * @author gg
 * 
 */
class Hen extends Chicken {
private Egg egg; public Egg getEgg() {
return egg;
} public void setEgg(Egg egg) {
this.egg = egg;
}
}/**
 * 公鸡
 * 
 * @author gg
 * 
 */
class Cock extends Chicken {}/**
 * 鸡蛋
 * 
 * @author gg
 * 
 */
class Egg {
private Chicken chicken; public Chicken getChicken() {
return chicken;
} public void setChicken(Chicken chicken) {
this.chicken = chicken;
}
}

Answer 4

蛋是鸡的抽象，鸡是蛋的实现。。
《java设计与模式》中提到，我看了一下，现在记不清了。

Answer 5

哈哈！这问题问的。java--Object是父类。明显蛋的属性少，可以作为父类。鸡可以成为蛋的一个子类或是特例。蛋有壳，颜色，蛋黄等。-对应鸡就是羽毛，毛色，内脏等，同时又有爪子，眼睛等装饰属性。所以先有蛋。

Answer 6

有这样的两个类  Egg   Chicken这里说的蛋和鸡 分别是这两个类的实例对象进而 我们可以将问题转化为 是先有 Egg 类 ,还是先有 Chicken类public class Egg {}pulblic class Chicken {}

Answer 7

[Quote=引用 15 楼 tkinjava 的回复:]
引用 12 楼 closewbq 的回复:
正反解释的都行。
1.对象：鸡
  属性：鸡头，鸡胸，鸡屁股，鸡腿
  动作：下鸡蛋
2.对象：蛋
  属性：颜色，大小
  动作：孵小鸡

Answer 8

先有蛋，因为蛋是抽象的，鸡是具体的，抽象决定具体，上层决定下层，这是Java与模式上说的！！！

Answer 9

细究起来用oop是解释不通的，因为鸡生蛋，蛋生鸡

Answer 10

to ls: 问的是先有  鸡蛋  还是先有  鸡  ，好像不是问的先有 蛋 还是 鸡 吧.....

Answer 11

/**鸡,鸡蛋,没看到无论鸡还是鸡蛋,鸡不都在蛋的前面吗?
*/
public class Main {    public static void main(String[] args) {
        Chicken c = Chicken.getChickenFirst();
        System.out.println("" + c.toString());
        egg e = null;
        try {
            while (c != null) {
                e = c.getEgg();
                System.out.println("" + e.toString());
                e.grow();
                c = (Chicken) e;
                System.out.println("" + e.toString());
            }        } catch (EOFException ex) {
            System.out.println("" + ex.getLocalizedMessage());
        }    }
}interface GrowAble {    /**
     * 长大
     */
    void grow();
}interface GetEggAble {    /**
     * 生蛋
     * @return
     * @throws java.io.EOFException
     */
    egg getEgg() throws java.io.EOFException;
}/**
 * 蛋,不一定是鸡蛋
 * @author Administrator
 */
abstract class egg implements GrowAble {
}class Chicken extends egg implements GetEggAble {    /**
     * 是否是公鸡
     */
    private boolean sex = false;
    /**
     * 是否是鸡蛋
     */
    private boolean is_egg = true;
    private final static Integer FIRST_MADER = 0;
    private static long nid = 1;
    /**
     * id
     */
    private long id;
    /**
     * 这鸡蛋或鸡的他妈的id
     */
    private long maid = 0;    private Chicken() {
        synchronized (FIRST_MADER) {
            id = nid++;
        }
    }    /**
     * 是否是鸡蛋
     * @param e
     * @return
     */
    public static boolean isChickenEgg(egg e) {
        if (e == null || !(e instanceof Chicken)) {
            return false;
        }
        return ((Chicken) e).is_egg;
    }    public static boolean isChicken(Chicken c) {
        if (c == null || c.is_egg) {
            return false;
        }
        return c instanceof Chicken;
    }    /**
     * 得到母鸡
     * @return
     */
    public static Chicken getChickenFirst() {
        Chicken c = new Chicken();
        c.is_egg = false;
        c.maid = FIRST_MADER;
        return c;
    }    @Override
    public synchronized void grow() {
        if (is_egg) {
            is_egg = false;
            sex = System.currentTimeMillis() % 2 == 0;
        }
    }    public egg getEgg() throws java.io.EOFException {
        if (is_egg) {
            throw new java.io.EOFException("蛋不能生蛋");
        }
        if (sex) {
            throw new java.io.EOFException("公鸡不能生蛋");
        }
        try {
            Thread.sleep(System.currentTimeMillis() % 10);
        } catch (InterruptedException ex) {
        }
        Chicken c = new Chicken();
        c.maid = id;
        return c;
    }    @Override
    protected Object clone() throws CloneNotSupportedException {
        throw new CloneNotSupportedException("");
    }    @Override
    public boolean equals(Object obj) {
        if (obj == this) {
            return true;
        }
        if (!(obj instanceof Chicken)) {
            return false;
        }
        Chicken c = (Chicken) obj;
        return c.id == id;
    }    @Override
    public int hashCode() {
        int hash = 7;
        hash = 23 * hash + (this.sex ? 1 : 0);
        hash = 23 * hash + (this.is_egg ? 1 : 0);
        hash = 23 * hash + (int) (this.id ^ (this.id >>> 32));
        hash = 23 * hash + (int) (this.maid ^ (this.maid >>> 32));
        return hash;
    }    @Override
    public String toString() {
        return "本" + (is_egg ? "蛋" : sex ? "公鸡" : "母鸡") + "id:" + id + ",本" + (is_egg ? "蛋" : sex ? "公鸡" : "母鸡") + "他妈的id:" + maid;
    }
}

Answer 12

这个要从对象进化论来讨论，鸡这个对象派生了子对象，可是这个子对象呢，在当时的软件环境下，生存的并不好，总出bug,于是呢，鸡这个对象给他的子对象进化加了个封装，就是蛋壳，于是就有鸡蛋这个对象了。
天才和疯子的距离有时是很近的。