Java 全球数据，静态和新数据

从结构化到对象编程的基本问题。。。希望不要太简单

我希望在我的应用程序中有一个由不同类共享的大型数据数组。 这样做的最佳实践是什么？ 这是正确的吗

public class LargeData {
    private static long[] myData;
    private static final int MAX = 100000;

    public LargeData() {
        myData = new long[MAX];
        // ... initialize
    }

    public long getData(int x) {
    // ... do whatever and return a long
    }
}

如果这是正确的，那么从我的任何类访问这些数据的正确方法是什么？我应该做一个决定吗

LargeData ld = new LargeData();

在每个想要访问myData的类中

---

谢谢你，很抱歉太简单了……：）

为此使用单例模式。

为此使用单例模式。

立即初始化数组。在当前的实现中，只有创建

LargeData

的对象，才能使用静态数组

另外，如果类仅用于保存数组，则通过将其设置为

final

和构造函数为

private

来防止其实例化和扩展

public final class LargeData {
    public static long[] myData = new long[100000];

    private LargeData() { }
}

---

并以

LargeData.myData

的身份访问，立即初始化数组。在当前的实现中，只有创建

LargeData

的对象，才能使用静态数组

另外，如果类仅用于保存数组，则通过将其设置为

final

和构造函数为

private

来防止其实例化和扩展

public final class LargeData {
    public static long[] myData = new long[100000];

    private LargeData() { }
}

每次你打电话时，都可以通过

LargeData.myData

访问

LargeData ld = new LargeData();

在您的代码中，您将有效地调用

myData = new long[MAX];

这是错误的

您可以做的是：

public class LargeData {

    private static final int MAX = 100000;
    public static long[] myData = new long[MAX];
}

并从任何地方以

LargeData.myData

的身份访问它。

每次您呼叫

LargeData ld = new LargeData();

在您的代码中，您将有效地调用

myData = new long[MAX];

这是错误的

您可以做的是：

public class LargeData {

    private static final int MAX = 100000;
    public static long[] myData = new long[MAX];
}

---

然后从任何地方以

LargeData.myData

的身份访问它。

如果不进行空检查，将值从实例构造函数分配给静态变量是一个坏主意-如果您从这个类实例化两个对象，第二个将导致您丢失存储在数组中的所有数据（当第二次实例化覆盖静态引用时，您将丢失对旧数组的引用）。使用null check也是一个坏主意，除非您真的需要以一种“全局变量”的方式使用一个实例中的数据。最好将静态引用视为所有人都可以查看的全局变量（如果它们是公共的）或仅从您在其中定义的类（private）或介于两者之间的内容（受保护或包保护的访问）中可见。您几乎希望在所有情况下都避免使用它们，并在类中使用单例模式而不是静态变量。使用单例模式，您可以使用实例变量和非静态getter来访问数据

然而，我不明白你写的东西为什么需要一个单例模式来解决这个特殊的问题——你只想把数据存储在一个对象中，然后共享这个对象，对吗

您可以像这样在不使用静态关键字的情况下修复发布的代码，这允许多个LargeData实例在您的应用程序中同时处于活动状态：

public class LargeData {
private  long[] myData; // instance variable to store the data
private static final int MAX = 100000; // max length


public LargeData() {
     myData = new long[MAX];

}

然后，您可以将数据用作：

LargeData ld = new LargeData();
long[] = ld.getData();

您可以使用存储在ld中的引用，您可以在其他类中传递它，等等

更好的办法是不公开阵列，而是创建一个API，通过该API使用存储的数据。例如：

public long getLong(int n) { return myData[n]; }
public void setLong(int n, long value) { myData[n] = value; }

---

现在，如果您不想传递对存储在ld中的LargeData实例的引用，您可以使用LargeData中的静态变量来存储引用和静态getter，该静态getter允许您从任何其他java代码访问引用。如果您需要多个LargeData实例来使用，您可以创建一个封装映射的LargeDataRegistry类存储每个实例化的LargeData实例的位置。

如果不进行空检查，则将值从实例构造函数分配给静态变量是一个坏主意-如果从此类实例化两个对象，则第二个将导致丢失存储在数组中的所有数据（当第二次实例化覆盖静态引用时，您将丢失对旧数组的引用）。使用null check也是一个坏主意，除非您真的需要以一种“全局变量”的方式使用一个实例中的数据。最好将静态引用视为所有人都可以查看的全局变量（如果它们是公共的）或仅从您在其中定义的类（private）或介于两者之间的内容（受保护或包保护的访问）中可见。您几乎希望在所有情况下都避免使用它们，并在类中使用单例模式而不是静态变量。使用单例模式，您可以使用实例变量和非静态getter来访问数据

然而，我不明白你写的东西为什么需要一个单例模式来解决这个特殊的问题——你只想把数据存储在一个对象中，然后共享这个对象，对吗

您可以像这样在不使用静态关键字的情况下修复发布的代码，这允许多个LargeData实例在您的应用程序中同时处于活动状态：

public class LargeData {
private  long[] myData; // instance variable to store the data
private static final int MAX = 100000; // max length


public LargeData() {
     myData = new long[MAX];

}

然后，您可以将数据用作：

LargeData ld = new LargeData();
long[] = ld.getData();

您可以使用存储在ld中的引用，您可以在其他类中传递它，等等

更好的办法是不公开阵列，而是创建一个API，通过该API使用存储的数据。例如：

public long getLong(int n) { return myData[n]; }
public void setLong(int n, long value) { myData[n] = value; }

---

现在，如果您不想传递对存储在ld中的LargeData实例的引用，您可以使用LargeData中的静态变量来存储引用和静态getter，该静态getter允许您从任何其他java代码访问引用。如果您需要多个LargeData实例来使用，您可以创建一个封装映射的LargeDataRegistry类您将在其中存储每个实例化的LargeData实例。

使用

Singleton

模式仅保存数组引用的目的是什么？Singleton不是执行延迟初始化的好方法吗？好吧，为了保持简单…通过使用static，您依赖于类加载器永不放弃