制作一个不可改变的类

我正在尝试创建一个表示自然数的不可变类。我使用递归来处理Increment和Decrement方法。由于这些字段是最终的，我做了一个私有构造函数来在递减/递增时将新值赋给必要的字段。在测试这个实现之后，我似乎无法指出问题所在。如果我递减100，那么它将是10.如果我递增99，它将是9.如果我递增/递减一个不在边界上的数字，我会得到一长串乱码。我想我需要向正确的方向推动。如果它是可变的，我可以很好地工作，因为我不必担心最后的字段。制作一个不可改变的类

public final class SlowBigNatural implements BigNatural{ 
final private int natural[]; 
final private int nSize; 
final private int HIGHEST = 9; 

public SlowBigNatural() { 
    this.nSize = 1; 
    this.natural = new int[1]; 
    this.natural[0] = 0; 
} 

public SlowBigNatural(int p) { 
    this(Integer.toString(p)); 
} 

public SlowBigNatural(String s) { 
    this.nSize = s.length(); 
    this.natural = new int[nSize]; 
    for (int i = 0; i < nSize; i++) { 
     this.natural[i] = Character.digit(s.charAt(i), 10); 
    } 
} 

public SlowBigNatural(BigNatural c) { 
    this(c.toString()); 
} 

private SlowBigNatural(int[] natural, int nSize){ 
    this.nSize = nSize - 1; 
    this.natural = new int[this.nSize]; 
    for (int i = 0; i < this.nSize; i++) { 
     this.natural[i] = natural[i]; 
    } 
} 

public BigNatural increment() { 
    int[] nClone = new int[nSize]; 
    System.arraycopy(natural, 0, nClone, 0, nSize); 
    if (nSize == 1 || nClone[nSize - 1] != HIGHEST) { 
     nClone[nSize - 1]++; 
     BigNatural nInc = new SlowBigNatural(nClone.toString()); 
     return nInc; 
    } 

    else { 
     nClone[nSize - 1] = 0; 
     BigNatural temp = new SlowBigNatural(nClone, nSize); 
     temp.increment(); 
     return temp; 
    } 
} 

public BigNatural decrement() { 
    int[] nClone = natural.clone(); 
    if (nClone[nSize - 1] != 0) { 
     nClone[nSize - 1]--; 
     BigNatural nDec = new SlowBigNatural(nClone.toString()); 
     return nDec; 
    } 
    else { 
     if (nSize != 1) { 
      nClone[nSize - 1] = HIGHEST; 
      BigNatural temp = new SlowBigNatural(nClone, nSize); 
      temp.decrement(); 
      return temp; 
     } 
     else{ 
      BigNatural nDec = new SlowBigNatural(0); 
      return nDec; 
     } 
    } 
} 

public String toString() { 
    String nString = ""; 
    for (int i = 0; i < nSize; i++) { 
     nString += String.valueOf(natural[i]); 
    } 
    return nString.replaceFirst("^0+(?!$)", ""); 
} 
}

我跨过我的代码，并且当我将数组转换为字符串并将其传递给构造函数时，似乎发生错误。它将数组变成一堆疯狂。继续调查。

来源

2011-10-16 Franklin

你的代码没有多大意义。例如，为什么在这个语句中，'if（nSize == 1 || nClone [nSize-1]！= HIGHEST）' - 你测试nSize == 1？为什么在接下来的其他章节中，如果你的类被认为是不可变的，你会先执行'temp.increment（）'然后返回temp，然后返回'temp.increment（）'的结果？ –

还没有完全看着它，但如果SlowBigNatural真的是正确不可改变的，那么下面：

BigNatural temp = new SlowBigNatural(nClone, nSize); 
temp.increment(); 
return temp;

不太可能是有用的，据我可以看到。以上呼吁temp.increment（）创建一个新对象，您忽略，看到您返回临时本身，而不是temp.increment（）的结果。

你能尝试改变上述这样：

BigNatural temp = new SlowBigNatural(nClone, nSize); 
return temp.increment();

如果作品，为递减（）这样做。

来源

2011-10-16 23:29:53 TacticalCoder

我尝试了你的建议，现在当我设置一个新的BigNatural等于增加的BigNatural时，我会随机乱读。我目前正试图通过代码，看看我到底发生了什么错误。 – Franklin

制作一个不可改变的类

回答

相关问题