Question

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

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];
}

我希望我的问题足够明确！

Answer 1

根据我对您的问题的理解，您希望实现的是每当您在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
}

Answer 2

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

class AnotherClass {

    X[] xArray = new X[20]

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

}

Answer 3

我认为你不能以这种方式绑定一个类，无论何时它的对象创建它自动传递给你正在使用的数组或任何数据结构。你必须编写一个方法，你可以明确地创建对象。

Answer 4

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

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);
    }
}

Answer 5

唯一的方法是，如果有一个类变量引用了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构造函数不应允许在构造完成之前对对象的引用进行转义。在这样的简单情况下，这没关系，但是如果字段是最终的并且对象是从多个线程使用的，那么所有线程都会看到设置为最终字段的值的保证将无法保证。只有在构造函数完成后才能保证。由于其他类在构造完成之前能够看到对象，因此可能会看到它处于不一致状态。

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

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注册实例时，构造函数已经返回。然后，对新构造的对象的引用可以安全地逃逸到外部世界。

另一个类中的数组中的对象

5 个答案: