Question

我正在制作一个太阳系模型，该模型通过使用类来使用不同的太阳系和行星集。我选择使用数组列表来存储太阳系内行星的每个对象，尽管现在正努力以合适的格式输出数据。

我在toString（）方法中寻找的格式是：“行星X的质量为A地球，BAU来自恒星，并且轨道运行C年：可以居住吗？ D'

我尝试使用for循环打印每个行星，但是不相信这是正确的方法，因为返回会导致循环停止。非常感谢

SolarSystem.java

import java.util.ArrayList;
public class SolarSystem {

    private String systemName;
    private double systemLuminosity;


    public SolarSystem(String name, double luminosity) {
        this.systemName = name;
        this.systemLuminosity = luminosity;
    }

    ArrayList<Planet> list = new ArrayList<>();

    public void addPlanet(String name, double mass, double distance) {

        list.add(new Planet(name, mass, distance, systemLuminosity));

    }

    public void planetProperties() {

    }

    public String toString() {
        System.out.println(list.size());
        String results = "+";
        for (Planet planet : list) {
            results += planet.getName(); //if you implement toString() for Dog then it will be added here
        }
        return results;
    }
}

Planet.java

    public class Planet {

        private String planetName;
        private double planetMass;
        private double distanceFromStar;
        private double orbitalPeriod;
        private String isHabitable;

        public Planet(String name, double mass, double distance, double systemLuminosity) {

            setName(name);
            setMass(mass);
            setDistanceFromSun(distance);
            setOrbitalPeriod(distance);
            setIsHabitable(mass, distance, systemLuminosity);


        }

        public void setName(String name) {
            planetName = name;
        }

        public  String getName() {
            return planetName;
        }

        public  void setMass(double mass) {
            planetMass = mass;
        }

        public double getMass() {
            return planetMass;
        }

        public void setDistanceFromSun(double distance) {
            distanceFromStar = distance;
        }

        public double getDistanceFromStar() {
            return distanceFromStar;
        }

        public void setOrbitalPeriod(double distance) {
            orbitalPeriod = Math.sqrt(distance*distance*distance);
        }

        public double getOrbitalPeriod() {
            return orbitalPeriod;
        }

        public void setIsHabitable(double mass, double distance, double luminosity) {
            if (mass >= 0.6 && mass <= 7.0) {
                if ((distance >= 0.75 * Math.sqrt(luminosity)) && (distance <= 2.0 * Math.sqrt(luminosity))) {
                    isHabitable = "yes";
                } else {
                    isHabitable = "no";
                }
            } else {
                isHabitable = "no";
            }

        }

        public String getIsHabitable() {
            return isHabitable;
        }
    }

Main.java

public class Main {

    public static void main(String[] args) {

        //Create our solar system
        SolarSystem ourSystem = new SolarSystem("Our System",1.0);

        //Add planets in our solar system
        ourSystem.addPlanet("Mercury", 0.055, 0.387);
        ourSystem.addPlanet("Venus", 0.815, 0.723);
        ourSystem.addPlanet("Earth", 1.0, 1.0);
        ourSystem.addPlanet("Mars", 0.107, 1.52);
        ourSystem.addPlanet("Jupiter", 317.8, 5.20);
        ourSystem.addPlanet("Saturn", 95.2, 9.58);
        ourSystem.addPlanet("Uranus", 14.5, 19.20);
        ourSystem.addPlanet("Neptune", 17.1, 30.05);

        System.out.println(ourSystem.toString());



    }
}

Answer 1

您需要在toString()类内实现Planet方法，例如：

class Planet {
    private String planetName;
    private double planetMass;
    private double distanceFromStar;
    private double orbitalPeriod;
    private String isHabitable;

    @Override
    public String toString() {
        return String.format(
                "Planet %s has a mass of %f Earths, is %f from its star, and orbits in %f years: could be habitable? %s%n",
                this.planetName, this.planetMass, this.distanceFromStar, this.orbitalPeriod, this.isHabitable);
    }

}

然后在您的SolarSystem类中，您可以创建一个具有以下内容的列表，您的那部分已经几乎正确了，但是我已将getName更改为toString：

@Override
public String toString() {
    StringBuilder buf = new StringBuilder();

    for (Planet planet : list) {
        buf.append(planet);
    }

    return buf.toString();
}

Answer 2

如果要打印出整个太阳系（行星的整个阵列列表）的描述，我建议在Planet类中实现toString（）方法。这样做将使您可以简单地遍历Planets数组列表，并仅调用planet.toString（）。在“行星”类中封装单个行星的逻辑是必经之路。

Answer 3

您必须在toString类中重新定义Planet，并替换toString中的SolarSystem才能使用它。

public class Planet {
  ...
  public String toString() {
     return "Planet " + planetName + " has a mass of " + planetMass + 
            " Earths, is BAU from its star, and orbits in " + orbitalPeriod + 
            " years: could be habitable? " + isHabitable;
  }
}

public class SolarSystem {
  ...

  public String toString() {
    String results = "";
     for (Planet planet : list) {
        results += planet.toString() + "\n"; // Use the toString of planet and add a new line 
     }
     return results;
  }
}

注意：出于性能原因，如oleg所述，最好使用StringBuilder连接字符串。在这种情况下，您的物品很少，问题与演奏无关，您可以离开+运算符。

增加您的Java知识，您会发现有用的功能，例如String.join：

返回一个新的String，该字符串由CharSequence元素的副本与指定的分隔符的副本组成。

这将帮助您更轻松，更清洁地替换以下代码：

public String toString() {
    String results = "";
     for (Planet planet : list) {
        results += planet.toString() + "\n"; // Use the toString of planet and add a new line 
     }
     return results;
  }

使用

public String toString() {
  return String.join("\n", list);
}

但是我的技巧是从Java基础开始，然后再尝试使用更高级的功能。否则，您将在不知道幕后发生情况的情况下使用它们

Answer 4

要回显其他海报，您需要首先在Planet类中定义一个自定义toString（）方法。请在下面查看我的建议。

但是伪代码应该为可能的解决方案提供一个思路。如果您还有问题，请打我。

根据您的要求：

我在toString（）方法中寻找的格式是'Planet X has 大量的A地球，从其恒星BAU开始，并在C年内运行：宜居？ D'

您的Planet.toString方法可以如下所示（这是伪代码，不一定可以编译，但是您可以找到要点）。

public class Planet {

    /* your class as it is, with the 
     * addition of a possible toString 
     * implementation */

        public String toString(){
                return String.format(
                    "Planet: %s, " + 
                    "mass: %f, " + 
                    "distance: %f, " + 
                    "orbital period: %f, " + 
                    "habitable: %b" 
                    this.getName(), 
                    this.getMass(), 
                    this.getDistanceFromStar(), 
                    this.getOrbitalPeriod(),
                    this.getIsHabitable());
        }
}

然后，您的SolarSystem类应该具有适当的toString方法，该方法循环遍历其中的行星。您最初的toString方法有一个正确的主意，我只是在扩展这个概念。

public class SolarSystem {

    /* 
    Your solar system class plus some changes 

    ... 
    */

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

    public String getLuminosity(){
        return this.systemLuminosity;
    }

    public int getPlanetCount(){
        return this.list.size();
    }

    public String toString() {
        final StringBuffer buffer = new StringBuffer();
        buffer.append(
            String.format("System: %s\nLuminosity: %f\nPlanet Count:%d\n",
                this.getName(),
                this.getLuminosity(),
                this.getPlanetCount()
            )
        );
        for (final Planet planet : list) {
            buffer.append('\t')
                .append(planet.getString())
                .append('\n');
        }
        return buffer.toString();
    }

}

现在，我对此有些困惑：

我尝试使用for循环打印每个行星，但是不要相信这是正确的方法，因为返回会导致循环停。非常感谢

如果在循环内完成返回，则return语句将停止循环。

在循环中调用的函数中完成的return语句不会结束循环。

也就是说，返回仅结束进行返回调用的函数，而不是调用链中的函数。

比较

for(Foo f : fooList){
  if(something){ 
    return; // this will stop the loop
  }
}

有了这个

for(Foo f : fooList){
   if(something){
      callThisFu(); // the return within callThisFu *will not* exit the loop
   }
}

希望这可以解决这个问题。

Java-通过toString（）方法以特定格式打印ArrayList对象

4 个答案: