-1

我该怎么做：例如当我在主类中创建一个对象时

public class Blabla {
    public static void main(String[] args) {
        Whatever w = new Whatever(100, 200, 400);
        Whatever w2 = new Whatever(500, 600, 700);
    }
}

它将自动添加到另一个类的数组中，例如

public class Pilipili {
    private Whatever[] tabW = new Whatever[20];
}

我希望我的问题足够清楚！

4

5 回答 5

2

根据我对您的问题的理解，您想要实现的是，每当您在方法中创建WhatEver类的实例时main，您都希望将新实例自动添加到类中的数组中Pilipili；您不想显式调用一个方法main来添加这个新实例。

为此，我将向您提供该方法的整体结构以及可以用代码替换的注释。你需要在课堂上有一个addWhateverObject方法。Pilipili

public void addWhateverObject(WhatEver w){   
  // Add the object w to the array tabW 
}

然后在WhatEver类中，在构造函数中，您需要调用该addWhateverObject方法并将this引用传递给它。

public WhatEver(int arg0, int arg1, int arg2){
  // Initialize the instance
  // Create an instance of Pilipili class
  // Call "addWhateverObject" method with "this" as the argument
}
于 2013-03-12T04:18:18.893 回答
1

您可以将 X 值传递给其他类的构造函数或在其他类中创建方法，例如：

class AnotherClass {

    X[] xArray = new X[20]

    void setXArrayItem(X x, int index) {
       xArray[index] = x;
    } 

}
于 2013-03-12T03:48:46.183 回答
1

我认为你不能以这种方式绑定一个类，只要它的对象创建它就会自动传递给一个数组或你正在使用的任何数据结构。您必须编写一个可以显式调用创建对象的方法。

于 2013-03-12T03:51:52.870 回答
1

你想要这样的东西吗...

public class Blabla {
    public static void main(String[] args) {
        Whatever w = new Whatever(100, 200, 400);
        Whatever w2 = new Whatever(500, 600, 700);
    }
}

public class Whatever{
    public Whatever(){int i, int j, int k){
        // some code
        Pilipili.addTabW(this);
    }
}

public class Pilipili {
    private static List<Whatever> tabW = new ArrayList<Whatever>();
    public static void addTabW(Whatever w){
        tabW.add(w);
    }
}
于 2013-03-12T04:11:18.390 回答
0

唯一的方法是，Whatever 有一个引用 Pilipili 的类变量，并在构造函数的末尾调用它来注册新对象。

public class Blabla {
    public static void main(String[] args) {
        Whatever.registry = new Pilipili();

        Whatever w1 = new Whatever(100, 200, 400);
        Whatever w2 = new Whatever(500, 600, 700);
    }
}

public class Whatever {
    public static Pilipili registry;

    private final int alpha, bravo, charlie;

    public Whatever(int a, int b, int c) {
        this.alpha = a;
        this.bravo = b;
        this.charlie = c;

        if (registry != null) {
            registry.register(this);
        }
    }
}

public class Pilipili {
    private int next = 0;
    private Whatever[] tabW = new Whatever[20];

    public void register(Whatever w) {
        tabW[next++] = w;
    }
}

但是，这被认为是不安全的。在构造完成之前，Whatever 构造函数不应允许对对象的引用转义。在像这样的简单情况下，这无关紧要，但如果字段是 final 并且对象是从多个线程中使用的，则无法保证所有线程都会看到设置为 final 字段的值。只有在构造函数完成后才能保证。由于其他类能够在构造完成之前看到该对象，因此它可能会看到它处于不一致的状态。

解决这个问题的最好方法是重组你的代码，这样就没有必要了，但下一个最好的方法是使构造函数私有并使用工厂方法创建对象。这样，工厂方法就可以调用构造函数，然后，构造函数完成后，可以将对象注册到监听器或你有什么，然后它可以将构造和注册的对象返回给调用者。

public class Blabla {
    public static void main(String[] args) {
        Whatever.registry = new Pilipili();

        Whatever w1 = Whatever.newInstance(100, 200, 400);
        Whatever w2 = Whatever.newInstance(500, 600, 700);
    }
}

public class Whatever {
    public static Pilipili registry;

    private final int alpha, bravo, charlie;

    private Whatever(int a, int b, int c) {
        this.alpha = a;
        this.bravo = b;
        this.charlie = c;
    }

    public static Whatever newInstance(int a, int b, int c) {
        Whatever whatever = new Whatever(a, b, c);

        if (registry != null) {
            registry.register(whatever);
        }

        return whatever;
    }
}

同样，这是安全的，因为当静态工厂方法向 Pilipili 注册实例时，构造函数已经返回。然后，对新建对象的引用可以安全地逃逸到外部世界。

于 2013-03-12T04:28:45.807 回答