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

以下字段应声明为非静态字段。当这些字段声明为static时，每个RichIndustrialist实例将共享这些字段及其指定的值。将它们声明为非静态允许每个RichIndustrialist实例拥有自己的这些字段的副本，这些字段与RichIndustrialist的其他实例无关。

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

以下是Java Tutorial

中静态的一个很好的描述

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

Answer 3

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

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

建议：

将静态修改器更改为实例修改器

这

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

要

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

我相信你的问题会解决。

Answer 4

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

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

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

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

超类重置已经活动的对象

4 个答案: