超級類別重置已經存在的對象

Question

這有點困難，但我會盡力解釋我的問題。我創建了一個超類（RichIndustrialist）兩個子類（PredecessorRichIndustrialist和另一個我沒有添加）的程序和4個子類（CrazyRichIndustrialist和另外3個）。現在，該程序太難以解釋，但問題其實很簡單。我的構造函數在超類中，每個子類都使用它來初始化。每次我創建一個像CrazyRichIndustrialist這樣的新子類對象時，它都會將所有已存在的子類（從任何子類）重置爲新對象的值。我不知道如何解決這個問題。預先感謝您...

RichIndustrialist：

package Mortal; 

import java.util.Random; 

public class RichIndustrialist implements Mortal { 

    private static String Name; 
    private static double holdings; 
    private static int Alive; 

    public RichIndustrialist(String Rich_Name, double Rich_holdings) { 
     this.Name = Rich_Name; 
     this.holdings = Rich_holdings; 
     this.Alive = 1; 
    } 

    public int isAlive() { 
     return (this.Alive); 
    } 

    public void setHoldings(double new_holdings) { 
     this.holdings = new_holdings; 
    } 

    public double getHoldings() { 
     return (this.holdings); 
    } 

    public String getName() { 
     return (this.Name); 
    } 

    public void die() { 
     this.Alive = 0; 
    } 

    public void getHeritage(double heritage) { 
     this.holdings = this.holdings + heritage; 
    } 
} 

PredecessorRichIndustrialist：

package Mortal; 

import java.util.Arrays; 

public class PredecessorRichIndustrialist extends RichIndustrialist { 

    private static String Name; 
    private static double holdings; 
    private RichIndustrialist[] successors = {}; 
    private static int Alive; 

    public PredecessorRichIndustrialist(String Rich_Name, double Rich_holdings) { 
     super(Rich_Name,Rich_holdings); 
    } 

    public void die() { 
     super.die(); 
    } 

    public void Inheritance(double holdings, RichIndustrialist[] successors) { 
     int i = 0; 
     while (i < successors.length) { 
      int Alive = successors[i].isAlive(); 
      System.out.println(Alive); 
      if (Alive == 0) { 
       removeSuccessor(successors[i]); 
       i++; 
      } else { 
       i++; 
      } 
     } 
    } 

    public void addSuccessor(RichIndustrialist new_successor) { 
     RichIndustrialist[] new_successors = new RichIndustrialist[successors.length + 1]; 
     if (successors.length == 0) { 
      new_successors[0] = new_successor; 
      successors = new_successors; 
     } else { 
      for (int i = 0; i < successors.length; i++) { 
       new_successors[i] = successors[i]; 
      } 
      new_successors[new_successors.length - 1] = new_successor; 
     } 
     this.successors = new_successors; 
    } 

    public void removeSuccessor(RichIndustrialist removed_successor) { 
     RichIndustrialist[] new_successors = new RichIndustrialist[this.successors.length - 1]; 
     int j = 0; 
     for (int i = 0; i < this.successors.length; i++) { 
      if (!this.successors[i].equals(removed_successor)) { 
       new_successors[j] = this.successors[i]; 
      } else { 
       j--; 
      } 
      j++; 
     } 
    } 

    public RichIndustrialist[] getSuccessors() { 
     return successors; 
    } 
} 

CrazyRichIndustrialist：

package Mortal; 

import java.util.Random; 

public class CrazyRichIndustrialist extends PredecessorRichIndustrialist { 

    private RichIndustrialist[] successors = {}; 
    private static String Name; 
    private static double holdings; 
    private static int Alive; 

    public CrazyRichIndustrialist(String Rich_Name, double Rich_holdings) { 
     super(Rich_Name,Rich_holdings); 
    } 
    public void die() { 
     super.die(); 
     Inheritance(getHoldings(),getSuccessors()); 
    } 

    public void addSuccessor(RichIndustrialist new_successor) { 
     super.addSuccessor(new_successor); 
    } 

    public void removeSuccessor(RichIndustrialist removed_successor) { 
     super.removeSuccessor(removed_successor); 
    } 

    public void Inheritance (double holdings , RichIndustrialist[] successors) { 
     super.Inheritance(holdings, successors); 
     for (int i=0; i<successors.length-1; i++) 
     { 
      double random = new Random().nextDouble(); 
      double amount = this.holdings * random; 
      successors[i].getHeritage(amount); 
      holdings = this.holdings - amount; 
     } 
     successors[successors.length-1].getHeritage(this.holdings); 
     this.holdings = 0; 
    } 

    public String getName(){ 
     return super.getName(); 
    } 
    public double getHoldings(){ 
     return super.getHoldings(); 
    } 
    public RichIndustrialist[] getSuccessors(){ 
     return super.getSuccessors(); 
    } 
    public void setHoldings(double new_holdings){ 
     super.setHoldings(new_holdings); 
    } 
    public int isAlive() { 
     return super.isAlive(); 
    } 
    public void getHeritage(double heritage) { 
     super.getHeritage(heritage); 
    } 

} 

Answer 1

你的大部分領域都static。這意味着你的類的所有實例都具有相同的值。在調用構造函數時，會修改靜態字段，這會影響所有現有實例。

例如：

this.Name = Rich_Name; 

實際上應該已被寫入：

RichIndustrialist.Name = Rich_Name; 

你可以閱讀有關this tutorial實例和類（或靜態）成員之間的差異。

Answer 2

以下字段應聲明爲非靜態。當這些字段被聲明爲靜態時，每個實例將共享這些字段及其分配的值。聲明它們爲非靜態的允許每個RichIndustrialist實例擁有自己的這些字段的副本，這些副本與RichIndustrialist的其他實例無關。

private String Name; 
private double holdings; 
private int Alive; 

這裏是靜態的Java教程

一個很好的說明有時候，你想有一個適用於所有對象的變量。 這是用靜態修飾符完成的。在其聲明中使用了靜態修飾符的字段稱爲靜態字段或類 變量。他們與班級相關聯，而不是與任何 對象關聯。每個類的實例在內存中的一個固定位置共享一個類變量，即 。任何對象都可以更改 類變量的值，但也可以在不使用 創建類的實例的情況下操作類變量。

Answer 3

您聲明中所有的類的Name成員字段，你應該只宣佈它在super -class並讓其他sub - 班（重新）使用。

此外，您將該字段聲明爲static，您班級的所有實例將使用相同的字段，這可能不是您想要的，所以請刪除static部分。

同樣適用於所有其他成員字段。

注意：不要啓動大寫字段的成員字段：Name應該被定義並用作name。另一方面，類名應該以大寫開頭！這是一個普遍接受的Java約定，使事情更加清晰/分離。

Answer 4

您的屬性/變量是靜態的。我們知道所有對象之間共享靜態變量。

這是最後一個對象會取代你的變量的現有值的原因

建議：

改變你的static修飾符來實例修改

從

private static String Name; 
private static double holdings; 
private static int Alive; 

要

private String Name; 
private double holdings; 
private int Alive; 

我相信你的問題會解決。