我可以將對象調用到另一個類嗎？

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

我不確定你的問題，但我試着回答： 你有靜態變量和「正常」變量。 當你創建一個類的對象時，你也爲它創建了每個正常的變量。例如：

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 

所以你也可以有OBJ文件是相同類型的類，例如：

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; 
}} 

訪問主：

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; 
}} 

然後訪問它們，他們都在主訪問：

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()); 

該解決方案還提供了更大的靈活性，因爲您可以針對不同的對象具有不同的值，例如，如果每隻動物有兩個鄰居

Answer 2

在class1和class2字段之前添加public修飾符，或者提供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教程來掌握面向對象的概念。