Question

我有一种情况，其中所有子类实例都应该返回相同的值。由于会有很多实例，我想减少使用的内存量。我做了以下实验：

1）使用字段并实现一次方法。（此实现使用24个字节）

private abstract class A{

    private String string;
    private int i;

    public A(String string, int i) {
        this.string = string;
        this.i = i;
    }

    public String getName() {
        return string;
    }

    public int getAge() {
        return i;
    }

}

private class B extends A{


    public B() {
        super("B",10);
    }

}

2）为每个班级重新实施方法。（此实现使用16个字节）

private abstract class A{

    public abstract String getName();
    public abstract int getAge();

}

private class B extends A{

    @Override
    public String getName() {
        return "B";
    }

    @Override
    public int getAge() {
        return 10;
    }

}

我使用VisualVm读取对象大小。有没有人看到我只能在减少使用的内存量的情况下实现方法一次的方法？

提前谢谢。

编辑：由于我的问题被投票了几次，请告诉我如何改进它。

Answer 1

更微妙。实际上，您希望让每个子类具有其特定的类（静态）常量。因此，Java似乎没有提供其他方法。

虽然看起来不那么整洁，但第二种解决方案似乎更充足。我的代码风格很难理解。

我建议收集一个不可变类中的所有常量，并使用任一方法，第二个更好，但需要一个方法。

然而，可以在使用类静态常量的 intent 后执行此操作，和最佳内存 resp。不在每个字段中复制相同的数据：

class MetaData {
    public final String string;
    public final int i;
    MetaData(String string, int i) {
        this.string = string;
        this.i = i;
    }
}

每个儿童班只有一个实例。实际上，可以考虑不使用子类，而是使用A类中的工厂和委托。

private abstract class A {
    protected final MetaData metaData;

    public A(MetaData metaData) {
        this.metaData = metaData;
    }

    public String getName() {
        return metaData.string;
    }

    public int getAge() {
        return metaData.i;
    }

    public MetaData getMetaData() {
        return metaData;
    }
}

private class B extends A {

    private static final MetaData b = new MetaData("B", 10);
    public B() {
        super(b);
    }
}

当然不是构造函数+超级字段，而是可以更好地制作

    protected abstract MetaData getMetaData();

    @Override
    protected MetaData getMetaData() {
        return b;
    }

优点是稍后必须在层次结构中添加额外的常量。

优化所有类实例返回相同值时使用的内存和LOC

1 个答案: