Java 我试图编写一个封装团队概念的团队类，但我可以'；我似乎无法比较这两个队

这是我到目前为止所做的，包括测试课程，我只是不知道如何比较这两个团队这是作业。。。。。。。。。。。。。。。。团队只有一个属性，即团队名称（例如巴塞罗那）

包括以下内容：

• 建造师

• 吸气剂/评估剂法

• 变异/设置方法

• toString方法

• 相等法

班级团队

public class Team {

private String name;

public Team(String name) { // Constructor

    this.name = name;
}

public void setName(String name) { // The Setter set's the name

    this.name = name;
}

public String getName() { // The Getter get's the the name

    return name;
}

@Override
public String toString() { // This returns a String object

    return "The team name is " + name;
}

@Override
public boolean equals(Object o) {

    if (o instanceof Team) {

        Team t = (Team) o;

        if (t.getName().equalsIgnoreCase(getName())) { //I'm not sure what i'm missing here

            return true;
        }

        else {
            return false;

        }

    }

    else {

        return false;
    }
}

}

测试类

public class TeamMain {
public static void main(String[] args) {

    Team team = new Team("ManUnited");

    Team team2 = new Team("ManCity");
    System.out.println(team.equals("ManUnited"));

    System.out.println(team2.equals("ManCity"));

    System.out.println(team.getName());
    team.setName("ManCity");
    System.out.println(team.toString());
}

}

在这方面：

System.out.println(team.equals("ManUnited"));

您正在将您的

团队

与

字符串

进行比较，因此您的代码正确地返回

false

，因为您的

o

不是

团队

的实例。与

团队相比

：

System.out.println(team.equals(new Team("ManUnited")));

在这方面：

System.out.println(team.equals("ManUnited"));

您正在将您的

团队

与

字符串

进行比较，因此您的代码正确地返回

false

，因为您的

o

不是

团队

的实例。与

团队相比

：

System.out.println(team.equals(new Team("ManUnited")));

在这方面：

System.out.println(team.equals("ManUnited"));

您正在将您的

团队

与

字符串

进行比较，因此您的代码正确地返回

false

，因为您的

o

不是

团队

的实例。与

团队相比

：

System.out.println(team.equals(new Team("ManUnited")));

在这方面：

System.out.println(team.equals("ManUnited"));

您正在将您的

团队

与

字符串

进行比较，因此您的代码正确地返回

false

，因为您的

o

不是

团队

的实例。与

团队相比

：

System.out.println(team.equals(new Team("ManUnited")));

---

如果你问团队是否等于一个字符串，而该字符串中恰好有字母“ManUnited”，那么它们就不一样了，因为字符串不是团队

System.out.println(team.equals("ManUnited"));

团队

是一个

团队

，它包含一个

字符串

，“ManUnited”实际上是一个

字符串

对equals方法的正确测试是

   Team team = new Team("ManUnited");
   Team team2 = new Team("ManCity");
   Team team3 = new Team("ManUnited");

   System.out.println(team.equals("team2")); //prints false
   System.out.println(team.equals("team3")); //prints true

正确评估平等性（注意下面的hashcode问题）

散列值 此外（但不是问题的直接原因）您正在重写

.equals（）

方法而没有重写

.hashCode（）

方法，这可能会导致使用hashCode作为评估相等性的捷径的类/方法出现意外行为（例如HashSet）。一个好的IDE将（提示）为您重写哈希代码

---

hashcode是一个函数，它返回一个整数，对于相等的对象，该整数保证相等；对于不相等的对象，不太可能等于。在非重写状态下，equals（）和hashCode（）都会评估对象是否为同一个对象的相等性。你已经（相当合法地）改变了等值方法来考虑“看起来相同”的对象是相等的，但是哈希代码仍然在查看对象是否是相同的；因此，出现了意外行为

您会问，如果团队等于一个字符串，而该字符串中恰好有字母“ManUnited”，那么它们就不一样了，因为字符串不是团队

System.out.println(team.equals("ManUnited"));

团队

是一个

团队

，它包含一个

字符串

，“ManUnited”实际上是一个

字符串

对equals方法的正确测试是

   Team team = new Team("ManUnited");
   Team team2 = new Team("ManCity");
   Team team3 = new Team("ManUnited");

   System.out.println(team.equals("team2")); //prints false
   System.out.println(team.equals("team3")); //prints true

正确评估平等性（注意下面的hashcode问题）

散列值 此外（但不是问题的直接原因）您正在重写

.equals（）

方法而没有重写

.hashCode（）

方法，这可能会导致使用hashCode作为评估相等性的捷径的类/方法出现意外行为（例如HashSet）。一个好的IDE将（提示）为您重写哈希代码

---

hashcode是一个函数，它返回一个整数，对于相等的对象，该整数保证相等；对于不相等的对象，不太可能等于。在非重写状态下，equals（）和hashCode（）都会评估对象是否为同一个对象的相等性。你已经（相当合法地）改变了等值方法来考虑“看起来相同”的对象是相等的，但是哈希代码仍然在查看对象是否是相同的；因此，出现了意外行为

您会问，如果团队等于一个字符串，而该字符串中恰好有字母“ManUnited”，那么它们就不一样了，因为字符串不是团队

System.out.println(team.equals("ManUnited"));

团队

是一个

团队

，它包含一个

字符串

，“ManUnited”实际上是一个

字符串

对equals方法的正确测试是

   Team team = new Team("ManUnited");
   Team team2 = new Team("ManCity");
   Team team3 = new Team("ManUnited");

   System.out.println(team.equals("team2")); //prints false
   System.out.println(team.equals("team3")); //prints true

正确评估平等性（注意下面的hashcode问题）

散列值 此外（但不是问题的直接原因）您正在重写

.equals（）

方法而没有重写

.hashCode（）

方法，这可能会导致使用hashCode作为评估相等性的捷径的类/方法出现意外行为（例如HashSet）。一个好的IDE将（提示）为您重写哈希代码

---

hashcode是一个函数，它返回一个整数，对于相等的对象，该整数保证相等；对于不相等的对象，不太可能等于。在非重写状态下，equals（）和hashCode（）都会评估对象是否为同一个对象的相等性。你已经（相当合法地）改变了等值方法来考虑“看起来相同”的对象是相等的，但是哈希代码仍然在查看对象是否是相同的；因此，出现了意外行为

您会问，如果团队等于一个字符串，而该字符串中恰好有字母“ManUnited”，那么它们就不一样了，因为字符串不是团队

System.out.println(team.equals("ManUnited"));

团队

是一个

团队

，它包含一个

字符串

，“ManUnited”实际上是一个

字符串

对equals方法的正确测试是

   Team team = new Team("ManUnited");
   Team team2 = new Team("ManCity");
   Team team3 = new Team("ManUnited");

   System.out.println(team.equals("team2")); //prints false
   System.out.println(team.equals("team3")); //prints true

正确评估相等性（注意哈希代码iss