Question

我有两个课程，如下所示：

public class JavaApplication12 {

public static void main(String[] args) {
   NewClass aclass = new NewClass("rabbit", "bungalow");
   System.out.println(aclass.toString());
}}

和

public class NewClass {
String animal;
String building;

public NewClass(String A, String B){
animal=A;
building=B;}

NewClass class1 = new NewClass("cat", "house");
NewClass class2 = new NewClass("dog", "shed");

@Override
public String toString(){
    return animal+building;
}}

所以我在JavaApplication12中有一个名为aclass的对象，我已经能够打印出一个toString。我希望能够打印出NewClass中对象class1和class2的toString，但是我想在JavaApplication12中打印它们，因为这是我可以运行的主类。如果我只是写

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

在JavaApplication12中，它显然不知道该怎么做，因为它无法在JavaApplication12中看到对象class1。有没有办法在JavaApplication12中打印出class1的toString？

修改

所以我想我已经知道我不能以我的方式存储猫，狗等信息 - 我想也许这就是我如何设法让一些人感到困惑而对不起关于那个！有没有办法可以将这样的信息存储在第二个类中，并且能够将其调用到主类，即我希望能够在JavaApplication1中打印cat, dog但是将此信息存储在NewClass中，以及存储许多此类其他信息。那会是一个ArrayList吗？再次抱歉混淆。

Answer 1

我不确定你的问题，但是我试着回答：你有静态变量和＆＃34;正常＆＃34;变量。创建类的对象时，也会为它创建每个普通的var。例如：

class Foo {
public int a; //For each obj
public static int b=3; //Global var of the class, acessable from anywhere
public Foo(int a) {
this.a=a;
}
}

System.out.println(new Foo(0).a); //-> 0

当然还有静态变量，并且每个对象都没有，在类中。

System.out.println(Foo.b); //-> 3

所以你也可以在你的班级中拥有相同班级类型的objs，例如：

public Foo f;

解决方案1：正如其他一些人所建议的那样，您可以将它们移至主要方法：

public class JavaApplication12 {

public static void main(String[] args) {
   NewClass aclass = new NewClass("rabbit", "bungalow");
   NewClass class1 = new NewClass("cat", "house");
   NewClass class2 = new NewClass("dog", "shed");
   System.out.println(aclass.toString());
}}

和

public class NewClass {
String animal;
String building;

public NewClass(String A, String B){
animal=A;
building=B;}


@Override
public String toString(){
    return animal+building;
}}

在main中访问：

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

解决方案2：将它们设为静态，以便您可以从主方法中获取它们

public class NewClass {
String animal;
String building;
public static NewClass class1 = new NewClass("cat", "house");
public static NewClass class2 = new NewClass("dog", "shed");

public NewClass(String A, String B){
animal=A;
building=B;}


@Override
public String toString(){
    return animal+building;
}}

然后在main中访问它们：

System.out.println(NewClass.class1.toString());

请注意，因此您不会有G_H指出的无限递归。

解决方案3：为每个obj拥有它们（仅在您需要时）

public class NewClass {
String animal;
String building;
public NewClass class1 = new NewClass("cat", "house");
public NewClass class2 = new NewClass("dog", "shed");

public NewClass(String A, String B){
animal=A;
building=B;}


@Override
public String toString(){
    return animal+building;
}}

请注意，您必须从obj访问它们，例如aclass：

System.out.println(aclass.class1.toString());

该解决方案还提供了更大的灵活性，因为您可以为不同的obj提供不同的值，例如，如果每只动物有两个邻居

Answer 2

在public和class1字段之前添加class2修饰符，或提供getter method。然后在你的主要课程中这样做：

System.out.println(aclass.class1.toString());
System.out.println(aclass.class2.toString());

或者如果你提供了getter方法：

System.out.println(aclass.getClass1().toString());
System.out.println(aclass.getClass2().toString());

Answer 3

如果我理解正确，您创建了class1和class2作为NewClass的属性，您必须移动到主方法。然后就像你使用aclass一样打印它：

public class JavaApplication12 {
    public static void main(String[] args) {
       NewClass aclass = new NewClass("rabbit", "bungalow");
       System.out.println(aclass.toString());
       NewClass class1 = new NewClass("cat", "house");
       System.out.println(class1.toString());
       NewClass class2 = new NewClass("dog", "shed");
       System.out.println(class2.toString());
    }
}

public class NewClass {
    String animal;
    String building;

    public NewClass(String A, String B){
    animal=A;
    building=B;}

    // move these two lines to main
    //NewClass class1 = new NewClass("cat", "house");
    //NewClass class2 = new NewClass("dog", "shed");

    @Override
    public String toString(){
        return animal+building;
    }
}

Answer 4

实例化NewClass类型的对象将导致您的情况下出现堆栈溢出错误。为什么？因为您已将class1和class2定义为实例字段，这些字段会立即分配。它们又是NewClass。

的实例

这意味着如果你这样做：

NewClass aclass = new NewClass("rabbit", "bungalow");

它还尝试创建这两个字段：

NewClass class1 = new NewClass("cat", "house");
NewClass class2 = new NewClass("dog", "shed");

反过来也会这样做。这是一个无休止的创建新对象的递归。

我建议您首先阅读哪些类和实例，构造函数如何工作，字段访问和可见性以及实例字段和静态字段之间的区别。按照一些Java教程来掌握面向对象的概念。

我可以将对象调用到另一个类吗？

4 个答案: