Question

我有一个类，里面有一个数组。这是当前类的代码：

public class SomeClass{
     int array[] = new int[3];
     array[0] = 1;
     array[1] = 1;
     array[2] = 1;
}

我想创建一个包含方法的类。该方法将数组中的所有数字设置为SomeClass，等于0。

如果它是SomeClass内的方法，那将非常容易。我只想将以下方法添加到现有类中：

public void manipulateArray(){
     for(int i=0;i<3;i++){
          array[i]=0;
     }
}

但是，我希望这个方法位于不同的类中，并操纵类SomeClass中的数组。

在应用程序中执行此操作的最标准方法是什么？感谢

Answer 1

您必须将此array字段设置为公共静态，才能从类外部访问它并修改它：

public class SomeClass {
    public static int array[] = new int[3];
}

然后：

public void manipulateArray(){
     for(int i=0;i<3;i++){
          SomeClass.array[i]=0;
     }
}

编辑：

然而，这只是快速解决方案。更好的是为这个字段创建setter / getter并使用这个类的对象..但是......一切都取决于你的设计。

Answer 2

将您的数组公开并通过SomeClass sc = new SomeClass(); sc.array[0] = 4;访问它如果你不需要，不要这样做！
让你的数组静态SomeClass.array[0] = 4; 如果你不需要，不要这样做！

3.将其保密，并使公共制定者得到吸气剂喜欢

public void setArray(int[] array) {
this.array = array;
}

SomeClass sc = new SomeClass();
sc.setArray(myNewArray);

其实这样做！

Answer 3

为什么不简单地为数组实现 getter ？

在另一个类中，您可以拥有类型为SomeClass的对象，并从那里获取数组：

SomeClass someClass = new SomeClass();
int myArr = someClass.getArray();
someClass.modifyArray();

Answer 4

这样做。

将数组传递给OtherClass.manipulateArray（array）并修改它。

class OtherClass{

    public void manipulateArray(int[] array){
       for(int i=0;i<3;i++){
            array[i]=0;
       }
    }
}

Answer 5

您可以像这样声明它并将数组作为参数传递。

public void manipulateArray(int[] array){
     for(int i=0;i<3;i++){
          array[i]=0;
     }
}

Answer 6

我可能会弄错，因为缺少这个答案，但标准方法是封装字段并通过接口管理对象的状态。因此，在您的情况下，您可以提供对SomeClass的引用，并通过引用重置数组：

public class SomeClass{
     final int array[] = new int[3];

     { Arrays.fill(array, 1); }

     public void manipulateArray(){
         Arrays.fill(array, 0);  
     }     
}

public class OtherClass{
     SomeClass someClass;

     public OtherClass(SomeClass someClass){ this.someClass = someClass;}

     public void reset(){
         someClass.manipulateArray();
     }
}

Answer 7

以上答案是真实有用的。可能依赖于代码的其他部分，将数组声明为“静态”也很有用。

Answer 8

您可以使用Java反射从其他类访问SomeClass数组。

以下是展示它的小代码：

public class POC {
    public static void main(String args[]) {
        new POC().run();
    }

    private void run() {
        SomeClass sc = new SomeClass();
        say("BEFORE: ");
        sc.showArray();

        DifferentClass dc = new DifferentClass();
        dc.manipulateArray(sc);

        say("---");
        say("AFTER: ");
        sc.showArray();
    }

    private class SomeClass {
        private int array[];

        public SomeClass() {
            array = new int[3];

            array[0] = 1;
            array[1] = 1;
            array[2] = 1;
        }

        public void showArray() {
            for (int i = 0; i < array.length; i++) {
                say(i + ">" + array[i]);
            }
        }
    }

    private class DifferentClass {
        public void manipulateArray(SomeClass sc) {
            try {
                Field arrayField = sc.getClass().getDeclaredField("array");
                arrayField.setAccessible(true);

                Object array = arrayField.get(sc);
                for (int i = 0; i < Array.getLength(array); i++) {// equivalent to for(int i=0;i<3;i++){
                    Array.set(array, i, 0); // equivalent to array[i]=0;
                }

                arrayField.setAccessible(false);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    private static void say(String msg) {
        System.out.println(msg);
    }
}

<强>输出

BEFORE: 
0>1
1>1
2>1
---
AFTER: 
0>0
1>0
2>0

如何在一个类中操作数组，来自不同的类？

8 个答案: