4

这有点困难，但我会尽力解释我的问题。我创建了一个程序，其中包含一个超类 ( 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);
    }

}
4

4 回答 4

7

你的大部分领域都是static. 这意味着您的类的所有实例共享相同的值。当您调用构造函数时，会修改静态字段，这会影响所有现有实例。

例如：

this.Name = Rich_Name;

实际上应该写成：

RichIndustrialist.Name = Rich_Name;

您可以在本教程中了解实例和类（或静态）成员之间的区别。

于 2012-12-20T10:04:07.330 回答
6

以下字段应声明为非静态字段。当这些字段被声明为静态时，每个RichIndustrialist实例将共享这些字段及其分配的值。将它们声明为非静态允许每个RichIndustrialist实例拥有这些字段的自己的副本，该副本独立于RichIndustrialist.

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

这是Java教程中对静态的一个很好的描述

有时，您希望拥有所有对象共有的变量。这是通过静态修饰符完成的。声明中带有 static 修饰符的字段称为静态字段或类变量。它们与类相关联，而不是与任何对象相关联。类的每个实例共享一个类变量，该变量位于内存中的一个固定位置。任何对象都可以更改类变量的值，但也可以在不创建类实例的情况下操作类变量。

于 2012-12-20T10:04:16.113 回答
3

您的属性/变量是静态的。我们知道静态变量在所有对象之间共享。

这就是最后一个对象将替换变量的现有值的原因

建议：

将您的静态修饰符更改为实例修饰符

从

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

至

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

我相信你的问题会解决的。

于 2012-12-20T10:12:43.827 回答
2

您Name在所有类中声明成员字段，您应该只在super-class 中声明它并让其他sub-classes（重新）使用它。

此外，您将该字段声明为static，您的类的所有实例都将使用相同的字段，这可能不是您想要的，因此请删除该static部分。

您的所有其他成员字段也是如此。

注意：不要以大写开头的成员字段：Name应定义并用作name. 另一方面，类名应该以大写开头！这是一个普遍接受的 Java 约定，并使事情更加清晰/分离。

于 2012-12-20T10:05:08.650 回答