Question

我尝试创建一个封装对象，一个字符串（用于命名和区分对象实例）的包装类，以及一个用于存储数据的数组。我现在遇到的问题是使用确定对象“名称”的方法访问此类，并读取包含一些随机变量的数组。

注意：这是从原版编辑的，但无论如何，下面的代码都更好。

import java.util.Arrays;
import java.util.Random;
public class WrapperClass
{
    String varName;
    Object varData;
    int[] array = new int[10];
    static WrapperClass globalobject;
    public WrapperClass(String name, Object data, int[] ARRAY)
    {
        varName = name;
        varData = data;
        array = ARRAY;
    }
    public static void getvalues()
    {

    }
    public static void main(String[] args)
    {

       Random random = new Random(3134234);
       String x;
       Object y;
       int[] n = new int[10];
       WrapperClass object;
       for(int i = 0; i < 10; i++)
       {

         int[] array = new int[10];

        for (int c = 0; c < 10; c++)
        {
            array[c] = random.nextInt();//randomly creates data
        }
        globalobject = new WrapperClass("c" + i, new Object(),array);

       } 
       globalobject.getvalues();
    }
}

Answer 1

好的，我继续看看你在评论中链接的帖子，现在我想我明白你为什么要这样做。这似乎是一个沟通问题，在很大程度上 - 我认为你已经知道你在概念上要做什么，但从我收集到的你是OOP的新手并且难以用技术术语表达它

基本上，你想要做的是获取某种任意数据，使用名称填充它，然后在将来使用该名称将其取回，对吗？

Java有一个名为 map 的结构，它可以让你做到这一点，而不必担心包装器或其他结构。这是一个如何使用地图的重要评论示例，希望有助于消除您的一些困惑：

import java.util.HashMap;
import java.util.Iterator;
import java.util.Random;

class MyClass
{
    public String name;
    public int[] myIntArray;

    public MyClass()
    {
        myIntArray = new int[10];
    }
}

public class Program
{
    static final int MAX_RANDOM = 20;

    public static void main(String[] args)
    {
        // Create a new map which will use keys of type String and
        // hold values of type MyClass.
        HashMap<String, MyClass> map = new HashMap<String, MyClass>();

        // Initialize a new random object. Not supplying a seed number
        // means that it seeds from the system clock, a good source of
        // randomness.
        Random rand = new Random();

        // Loop ten times...
        for (int i = 0; i < 10; ++i)
        {
            // ...and each time, create a new MyClass and call it "m"...
            MyClass m = new MyClass();

            // ...and set m.name as "c" followed by the iteration number.
            m.name = "c" + i;

            // Loop as many times as there are elements in m.myIntArray...
            for (int j = 0; j < m.myIntArray.length; ++j)
            {
                // ...and each time, set the next element to a new random int
                // with a value between 0 and MAX_RANDOM.
                m.myIntArray[j] = rand.nextInt(MAX_RANDOM);
            }

            // Once we've filled all the variables, push the object into
            // the map using its name as the lookup key.
            map.put(m.name, m);

            // The "m" variable now goes out of scope and the name can be
            // re-used on the next iteration of the loop. "map" and "rand"
            // stay in scope because they were declared outside the loop body.
        }

        // Now that we've created ten objects, time to read them back out.

        // Get an iterator object which will let us traverse the set of
        // keys (names) in the map.
        Iterator<String> i = map.keySet().iterator();
        // While i still has more keys in the set...
        while (i.hasNext())
        {
            // Grab the next name from the iterator and assign it to
            // a local variable called "name".
            String name = i.next();

            // Fetch the instance of MyClass from the map that corresponds
            // to the key (name) we've just grabbed.
            MyClass m = map.get(name);

            // Print its name to the console...
            System.out.println("Name: " + m.name);

            // Print an opening bracket for the array...
            System.out.print("[");
            // ...and now run through each of the integers in the array
            // and print those out, too.
            for (int j = 0; j < m.myIntArray.length; ++j)
            {
                // Print the integer at position j...
                System.out.print(m.myIntArray[j]);
                // ...and if it's not the last item in the array,
                // print a comma to separate it from the next one.
                if (j < m.myIntArray.length - 1) System.out.print(", ");
            }
            // Print the closing bracket, followed by two newlines to
            // separate the next class with whitespace.
            System.out.println("]\n");
        }
    }
}

Answer 2

你想封装对象，但你的成员字段没有很好地封装，将它们设为私有并添加setter和getter方法，

Wrapper类，它在运行时创建对象并将数据存储在数组中

2 个答案: