初始化ArrayList<&燃气轮机；（）在方法或构造函数中 import java.util.ArrayList； 公开课小组{ 私有字符串名称； 私人ArrayList团队； 公共团队（字符串名称）{ this.name=名称； //为什么我必须在构造函数中初始化它才能看到完整的列表？ this.team=new ArrayList（）； } 公共无效添加玩家（玩家）{ //为什么我不能在方法中初始化它，这会给我一个最近添加的列表？ //this.team=new ArrayList（）； 此.team.add（玩家）； } public void printPlayers（）{ （球员：本队）{ System.out.println（播放器）； } } 公共字符串getName（）{返回this.name；} } 我正在试图弄清楚为什么this.team=new ArrayList（）必须在构造函数中 为什么我不能在方法中初始化this.team=new ArrayList（） 我知道当我使用构造函数中的代码运行它时，它会按预期工作（添加内容时，它会给出完整的列表） 但是当它在方法中初始化时，它只列出列表中最后一个给定的添加项。在方法中初始化它是错误的吗 另外，将其初始化为private ArrayList team=new ArrayList（）有什么区别在构造函数之前

仅回答以下问题：

另外，将其初始化为

private ArrayList team=new ArrayList（）有什么区别在构造函数之前

除了
团队
将在
名称
之前初始化之外，什么都没有

字段初始值设定项是语法糖，例如初始值设定项。因此：

import java.util.ArrayList;
public class Team {  

    private String name;
    private ArrayList<Player> team;

    public Team(String name)    {
        this.name = name;
        //how come i have to initialize it here in the constructor to see the full list?          
        this.team = new ArrayList<Player>();
    }

    public void addPlayer(Player player)    {
        //why can't i initialize it here in the method, this gives me a list of only recent add?
        //this.team = new ArrayList<Player>(); 
        this.team.add(player);
    }

    public void printPlayers()  {            
        for(Player players : this.team) {
            System.out.println(players);
        }
    }
    public String getName() { return this.name; }
}

private ArrayList<Player> team;

{
  // This is an instance initializer.
  team = new ArrayList<Player>();
}

与以下内容相同：

public class Team {  

    private ArrayList<Player> team = new ArrayList<>();

    public Team(String name)    {
      this.name = name;
    }
}

公共类团队{
私人ArrayList团队；
公共团队（字符串名称）{
超级（）；
this.team=new ArrayList（）；
this.name=名称；
}
}
因为每个构造函数调用都会产生一个新的不同对象，行
this.team=new ArrayList（）每个实例只调用一次，因此在这种特定情况下，每个对象只有一个实例

另一方面，
addPlayer
方法可以在给定对象上调用任意次数，因此
this.team=new ArrayList（）addPlayer方法中的code>将在每次方法调用中替换（覆盖）上一个列表

我试图弄明白为什么这个.team=new ArrayList（）必须在构造函数中

它没有，在使用之前必须初始化它。只要之前不调用printPlayer（）或addPlayer（），就可以在任何地方初始化它

为什么我不能在方法中初始化this.team=new ArrayList（）

你真的可以。请参见此示例：

public class Team {  

    private ArrayList<Player> team;

    public Team(String name)    {
      super();

      this.team = new ArrayList<>();

      this.name = name;
    }
}

但是当它在方法中初始化时，它只列出列表中最后一个给定的添加项。在方法中初始化它是错误的吗

不，没有错。如果按照上述示例的方式进行，则通常称为“延迟初始化”或“按需”

另外，将其初始化为private ArrayList team=new ArrayList（）有什么区别；在构造器之前

差别不大，在于它是在什么时候初始化的

public void addPlayer(Player player) {
    if (team == null) {
        team = new ArrayList();
    }

    team.add(player);
}

public void printPlayers() {
    if (team != null) {
        for (Player p : team) {
            System.out.println(p);
        }
    }
}

公共类示例{
public static List myList=new ArrayList（）；//首先执行此操作
公共静态列表列表；
公共列表；
静止的{
//这也是首先完成的（在类加载时）
aList=新的ArrayList（）；
}
{ 
//这是在构造器之前完成的（我相信）
//它被称为“初始化块”
someList=newArrayList（）；
}
公共示例（）{
//这个你已经知道了。。。
}
}
您可以这样做（防止在每个addPlayer方法调用上重新创建ArrayList）：

public void addPlayer（播放器）{
如果（this.team==null）{
this.team=new ArrayList（）；
}
此.team.add（玩家）；
}

但这将是非常奇怪的代码。。。更好的做法是在构造函数内初始化“团队”列表或在字段声明中内联。他们两人做同样的事情。我更喜欢在构造函数中初始化字段，但这只是我的习惯。其他程序员可能更喜欢内联版本，这并没有什么错/不好

为什么我不能在方法中初始化this.team=new ArrayList（）

您每次都要创建一个新的ArrayList并将其分配给
this.team
。因此，每次调用
addPlayer
，您都将用一个新的空ArrayList替换
此.team
，然后用
此.team.add（player）
添加一个玩家，因此始终只有最后添加的玩家在ArrayList中

如果你真的不想在构造函数中创建ArrayList，你可以做的是检查
这个。每次你添加玩家时，团队
是否为空，如果ArrayList没有创建或为空，只需创建一个即可

    public void addPlayer(Player player)  {
        if (this.team == null) {
            this.team = new ArrayList<Player>();
        }
        this.team.add(player);
    }

public void addPlayer（播放器）{
如果（this.team==null）{
this.team=new ArrayList（）；
}
此.team.add（玩家）；
}

另外，将其初始化为private ArrayList team=new ArrayList（）有什么区别；在构造器之前

如果您想知道private关键字是否改变了什么，您应该阅读访问修饰符上的Java文档：

除此之外，在构造函数之前初始化在这种情况下不会改变任何内容。
“为什么我不能在方法中初始化this.team=new ArrayList（）”，因为每次尝试添加内容时，都会删除列表并创建一个新列表。想一想，每次你可以
public class Example {
    public static List<T> myList = new ArrayList<T>(); // this is done first
    public static List<T> aList;
    public List<T> someList;
    static {
        // this is also done first (on class load)
        aList = new ArrayList<T>();
    }

    { 
        // this is done right before the constructor (I believe)
        // it is called an 'initialization block'
        someList = new ArrayList<T>();
    }

    public Example() {
        // this one you already know...
    }
}

    public void addPlayer(Player player)  {
        if (this.team == null) {
            this.team = new ArrayList<Player>();
        }
        this.team.add(player);
    }

public void addPlayer(Player player)    {
    if (this.team == null) {
        this.team = new ArrayList<Player>();
    }
    this.team.add(player);
}