Java 关于新对象

我在游戏中有一个用于统计数据的基本对象。每次我为战斗地图上的40个求和单位开始战斗时，我都会复制该对象

然后修改每个单元的stats对象。我当然不想以参考的方式通过。基本统计数据对象填充了大约50个基本体。因此，我创建了一个对象的构造函数类，并乏味地复制了每个原语。这似乎是我在谷歌上找到的最安全的方法

示例代码

-问题-

这是非常令人沮丧和混乱的。值得我花时间研究实现内置克隆功能吗

如果我的stats类最终包含其他对象，那么其中包含的所有对象是否也需要实现克隆功能

有没有更简单的方法

附带问题：在安卓系统上，拥有40个单独的100个基本类的内存消耗仍然很低，对吧？

---

谢谢，我爱你们：）

这是实现统计类的最好方法。它可能看起来令人沮丧和混乱，但从功能上讲，这个类非常简单

如果STAT值没有机会，可以考虑使STATS为静态类。那么，你永远不需要复制它。例如：

static class Stats
{
    private int x = 10;
    private int y = 12;
    private int b = 13;
    ...
    public int getX()
    {
        return x;
    }
    public int getY()
    {
        return y;
    }
    public int getB()
    {
        return b;
    }
}

要获取这些值，您需要调用Stats.getX（），并且不必实例化Stats类。缺点是所有引用它的对象的统计数据都是相同的

如果需要独立的stat值，则应使用当前实现

如果所有stat对象的起始值都相同，则可以创建其他构造函数来设置这些值

class Stats{
    int x;
    int y;
    int b;

    public Stats()
    {
        this.x = 10;
        this.y = 11;
        this.b = 12;
    }
}

---

要回答第二个问题，假设40个对象和100个原语都是双倍的，那么它们最多需要32000字节或~32KB。在现代硬件上，这应该不是问题，但是如果您可以重用数据，我鼓励您这样做。

这是实现Stats类的最佳方法。它可能看起来令人沮丧和混乱，但从功能上讲，这个类非常简单

如果STAT值没有机会，可以考虑使STATS为静态类。那么，你永远不需要复制它。例如：

static class Stats
{
    private int x = 10;
    private int y = 12;
    private int b = 13;
    ...
    public int getX()
    {
        return x;
    }
    public int getY()
    {
        return y;
    }
    public int getB()
    {
        return b;
    }
}

要获取这些值，您需要调用Stats.getX（），并且不必实例化Stats类。缺点是所有引用它的对象的统计数据都是相同的

如果需要独立的stat值，则应使用当前实现

如果所有stat对象的起始值都相同，则可以创建其他构造函数来设置这些值

class Stats{
    int x;
    int y;
    int b;

    public Stats()
    {
        this.x = 10;
        this.y = 11;
        this.b = 12;
    }
}

---

要回答第二个问题，假设40个对象和100个原语都是双倍的，那么它们最多需要32000字节或~32KB。在现代硬件上，这应该不是问题，但是如果您可以重用数据，我鼓励您这样做。

这是实现Stats类的最佳方法。它可能看起来令人沮丧和混乱，但从功能上讲，这个类非常简单

如果STAT值没有机会，可以考虑使STATS为静态类。那么，你永远不需要复制它。例如：

static class Stats
{
    private int x = 10;
    private int y = 12;
    private int b = 13;
    ...
    public int getX()
    {
        return x;
    }
    public int getY()
    {
        return y;
    }
    public int getB()
    {
        return b;
    }
}

要获取这些值，您需要调用Stats.getX（），并且不必实例化Stats类。缺点是所有引用它的对象的统计数据都是相同的

如果需要独立的stat值，则应使用当前实现

如果所有stat对象的起始值都相同，则可以创建其他构造函数来设置这些值

class Stats{
    int x;
    int y;
    int b;

    public Stats()
    {
        this.x = 10;
        this.y = 11;
        this.b = 12;
    }
}

---

要回答第二个问题，假设40个对象和100个原语都是双倍的，那么它们最多需要32000字节或~32KB。在现代硬件上，这应该不是问题，但是如果您可以重用数据，我鼓励您这样做。

这是实现Stats类的最佳方法。它可能看起来令人沮丧和混乱，但从功能上讲，这个类非常简单

如果STAT值没有机会，可以考虑使STATS为静态类。那么，你永远不需要复制它。例如：

static class Stats
{
    private int x = 10;
    private int y = 12;
    private int b = 13;
    ...
    public int getX()
    {
        return x;
    }
    public int getY()
    {
        return y;
    }
    public int getB()
    {
        return b;
    }
}

要获取这些值，您需要调用Stats.getX（），并且不必实例化Stats类。缺点是所有引用它的对象的统计数据都是相同的

如果需要独立的stat值，则应使用当前实现

如果所有stat对象的起始值都相同，则可以创建其他构造函数来设置这些值

class Stats{
    int x;
    int y;
    int b;

    public Stats()
    {
        this.x = 10;
        this.y = 11;
        this.b = 12;
    }
}

---

要回答第二个问题，假设40个对象和100个原语都是双倍的，那么它们最多需要32000字节或~32KB。在现代硬件上，这不应该是一个问题，但是如果您可以重用数据，我鼓励您这样做。

如果您有这么多原语（50），为什么不使用HashMap？：

    public static void main (String[] args)
{
    HashMap<String, Integer> stats = new HashMap<String,Integer>();
    stats.put("x",3);
    stats.put("y",4);
    stats.put("z",5);
    stats.put("b",9);
    HashMap<String, Integer> statsCopy = new HashMap<String,Integer>();

    statsCopy.putAll(stats);//this will copy all the values from the base object
}

publicstaticvoidmain（字符串[]args）
{
HashMap stats=newhashmap（）；
统计数据。放置（“x”，3）；
统计数据。放置（“y”，4）；
统计数据。放置（“z”，5）；
统计数字。推杆（“b”，9）；
HashMap statsCopy=newhashmap（）；
statsCopy.putAll（stats）；//这将从基本对象复制所有值
}

如果您有这么多的原语（50），为什么不使用HashMap呢

    public static void main (String[] args)
{
    HashMap<String, Integer> stats = new HashMap<String,Integer>();
    stats.put("x",3);
    stats.put("y",4);
    stats.put("z",5);
    stats.put("b",9);
    HashMap<String, Integer> statsCopy = new HashMap<String,Integer>();

    statsCopy.putAll(stats);//this will copy all the values from the base object
}

publicstaticvoidmain（字符串[]args）
{
HashMap stats=newhashmap（）；
统计数据。放置（“x”，3）；
统计数据。放置（“y”，4）；
统计数据。放置（“z”，5）；
统计数字。推杆（“b”，9）；
HashMap statsCopy=newhashmap（）；
statsCopy.putAll（stats）；//这将从基本对象复制所有值
}

如果您有这么多的原语（50），为什么不使用HashMap呢

    public static void main (String[] args)
{
    HashMap<String, Integer> stats = new HashMap<String,Integer>();
    stats.put("x",3);
    stats.put("y",4);
    stats.put("z",5);
    stats.put("b",9);
    HashMap<String, Integer> statsCopy = new HashMap<String,Integer>();

    statsCopy.putAll(stats);//this will copy all the values from the base object
}

publicstaticvoidmain（字符串[]args）
{
HashMap stats=newhashmap（）；
统计数据。放置（“x”，3）；
统计数据。放置（“y”，4）；
统计数据。放置（“z”，5）；
统计数字。推杆（“b”，9）；
HashMap statsCopy=newhashmap（）；
statsCopy.putAll（stats）；//这将从基本对象复制所有值
}

如果您有这么多的原语（50），为什么不使用HashMap呢

    public static void main (String[] args)
{
    HashMap<String, Integer> stats = new HashMap<String,Integer>();
    stats.put("x",3);
    stats.put("y",4);
    stats.put("z",5);
    stats.put("b",9);
    HashMap<String, Integer> statsCopy = new HashMap<String,Integer>();

    statsCopy.putAll(stats);//this will copy all the values from the base object
}

p