Java基础，写一个flat函数

有这样一个需求，在一个A类中，有个一对象C数组arr,,对象里面有一个字段叫做x；在一个B类中，有一个对象D数组arr，对象里面有一个字段叫做y；有点晕，我们来看看对应的JavaBean
A.java

public class A{
    public List<C> arr = new ArrayList<>();

    static class C{
        public int x = 1;
    }
}

B.java

public class B {
    public List<D> arr = new ArrayList<>();

    static class D{
        public int y = 2;
    }
}

现在的需求是，写一个函数来构造一个数组，具体是这样的，就是这个函数能遍历A类的C，把C中的x变成一个数组，也能够遍历B类的D，把D中的y变成一个数组。
借用flat函数的思想，我们可以这样想，问题的关键在与当我们用foreach遍历到对象的时候不可以去获取成员变量，就是我不知道是.x还是.y又要求用一个方法完成，所以接口大法来救你了，看代码吧。

MyClass.java

public class MyClass {
    public static void main(String args[]) {
        MyClass myClass = new MyClass();
        A a = new A();
        A.C c = new A.C();
        a.arr.add(c);
        a.arr.add(c);
        a.arr.add(c);

        B b = new B();
        B.D d = new B.D();
        b.arr.add(d);
        b.arr.add(d);
        b.arr.add(d);

        List list = myClass.traverseArray(a.arr, new UtilFlat<A.C>() {
            @Override
            public Object flat(A.C o) {
                return o.x;
            }
        });

        for (Object i:
             list) {
            System.out.println(i);
        }

        list = myClass.traverseArray(b.arr, new UtilFlat<B.D>() {
            @Override
            public Object flat(B.D o) {
                return o.y;
            }
        });

        for (Object i:
                list) {
            System.out.println(i);
        }
    }

    private List traverseArray(List objectList, UtilFlat iFlat) {
        ArrayList<Object> list = new ArrayList<>();
        for (Object o :
                objectList) {
            list.add(iFlat.flat(o));
        }
        return list;
    }

    public interface UtilFlat<T>{
        Object flat(T o);
    }
}

总结：接口一定是延迟操作，把当前不能决策的操作延迟到实现的地方。

PS:感谢老大的教育之恩