Question

我在AP计算机科学（高中阶段），我仍在努力掌握一些我们在课堂上学习的东西。我们最近得到了修改'Pizza'资源类的任务。他在工作表上的指示是：</ p>

第1部分： 修改之前写的旧的Pizza类。添加一个equals（）方法，该方法将覆盖Object类中的方法。如果浇头，尺寸和成本相同，则两个Pizza对象相等。使用PizzaMatch类测试新方法。

第2部分： 添加compareTo（）方法以实现Comparable接口。这个compareTo（）应该可以帮助你找到pizza.txt中最便宜的披萨。**

他想要的输出是

**Part 1 Output
Input a Pizza topping, size, and cost: 
sloppyJoe 15 15.30
That pizza is # 20 in the file.
ÏÏÏ
Input a Pizza topping, size, and cost: 
cheese 12 12.99
That pizza is not in the file.
Part 2 Output
The cheapest pizza: The 9 inch olive pizza will cost   $7.99**

这是Pizza（资源类）

 import java.util.*; 
 import java.io.*;
 class Pizza 
{ 
  private int size; 
  private double cost; 
  private String topping; 
  public Pizza(int pizzaSize, double pizzaCost,String pizzaTopping) 
  { 
     size = pizzaSize; 
     cost = pizzaCost; 
     topping = pizzaTopping; 
  } 
  public void setSize(int input) 
  { 
     size = input; 
  } 
  public void setCost(double input) 
  { 
     cost = input; 
  } 
  public void setTopping(String input) 
  { 
     topping = input; 
  } 
  public int getSize() 
  { 
     return size; 
  } 
  public double getCost() 
  { 
     return cost; 
  } 
  public String getTopping() 
  { 
     return topping; 
  } 

  public String toString() 
  { 
     return (size + " inch " + topping + " pizza will cost $" + cost); 
  } 
}

这是PizzaMatch

  import java.util.*;
  import java.io.*;

public class PizzaMatch   {
   public static void main (String [] args)throws Exception
   {

     Scanner keyboard = new Scanner(System.in);
     System.out.println("Input a Pizza topping, size, and cost: "); 
     String top = keyboard.next();  
     int size = keyboard.nextInt();
     double cost = keyboard.nextDouble();
     Pizza input = new Pizza(size, cost, top);
     int counter =1;
     boolean found = false;
     while(inFile.hasNext())
     {
        String t = inFile.next();  
        int s = inFile.nextInt();
        double c = inFile.nextDouble();
        Pizza temp = new Pizza(s,c,t);
       //System.out.println("Pizza #"+counter+"\t" + temp);
        if(temp.equals(input))
        {
           System.out.println ( "That pizza is # " + counter 
              + " in the file.");
           found = true;
        }
        counter++;         
     }
     if(!found)
        System.out.println("That pizza was not in the file.");

  }
}

基本上，我不知道从哪里开始。我还有点不确定接口。我意识到我们必须制作.equals（）方法，但是怎么做？我开始写作

public Boolean equals(Pizza p)
{
 if(p==/*this is where I don't know what to write*/)
return true;
}

对于作业的第1部分和第2部分，我们将非常感谢任何帮助！非常感谢:)。

Answer 1

如果要覆盖基类的方法，通常子类方法应该具有相同的基类签名。

如果您查看Object.equals()的文档，就可以看到它实际上返回的是boolean，而不是Boolean。此外，它需要Object参数，而不是Pizza参数。因此，在您的情况下，Pizza，您需要：

public boolean equals (Object o) {
    if (!(o instanceof Pizza))
        return false; // its null, or its not Pizza
    Pizza p = (Pizza)o;
    // compare relevant fields of 'this' with 'p' and return result.
    return ...;
}

顺便说一句，请注意，Java有一个@Override注释，您应该使用它来标记旨在覆盖基本方法的方法：

@Override
public boolean equals (Object o) {
    if (!(o instanceof Pizza))
        return false; // its null, or its not Pizza
    Pizza p = (Pizza)o;
    // compare relevant fields of 'this' with 'p' and return result.
    return ...;
}

如果您在原始示例中使用了此注释，则编译器会生成错误，指出您的equals()方法实际上并未覆盖基础。

至于实际实施，这取决于你。如何使一个Pizza与另一个相等？您的要求中列出了标准，因此实施equals会涉及比较this和p的字段，并确定两者是否相等。

compareTo()的策略类似。您的Pizza必须实施，例如Comparable<Pizza>，然后覆盖int compareTo(Pizza);实现的行为应该与Comparable.compareTo()的文档中定义的一致，并且您用于确定结果的确切逻辑取决于问题描述中给出的要求。

我建议阅读第1部分Overriding Methods的官方教程，第2部分的Object Ordering官方教程。这些教程简洁，写得很好，并且会为您提供所需的工具。解决这些类型的问题。

Answer 2

要覆盖方法，您需要声明它与原始方法完全相同。使用@Override注释来强制执行此操作会很有帮助。

如果是equals()，您可以从：

开始

@Override
public boolean equals(Object o) {
  :
}

骨架通常是：

@Override
public boolean equals(Object o) {
  if (o instanceof Pizza) {
    // Do the comparison for Pizza objects.
  } else {
    // A Pizza object can only be equal to other Pizza objects.
    return false;
  }
}

Answer 3

首先，你应该在equals函数上面添加一个@Override标记，因为你要覆盖Object的equals（）函数。你的教授告诉你要验证两个披萨的顶部，大小和成本是否相同，这意味着你应该比较两个披萨的某些变量，而不是试着比较一个完整的披萨和你现在正在做的另一个（p == ??）。

Answer 4

你会想要这样的东西：

@Override
public Boolean equals(Object o)
{
    //Make sure its a pizza
    if (o instanceof Pizza == false)
        return false;

    //Cast to a pizza
    Pizza p = (Pizza)o;

    //Compare the fields
    if(this.size == p.getSize() && this.cost == p.getCost() && this.topping == p.getTopping())
        return true;
    else
        return false;
}

Answer 5

非常简单，您可以通过在派生类中使用相同的方法签名定义方法来覆盖超类中的方法。在Object中，.equals方法定义为：

public boolean equals(Object obj)

因此，您在类中使用相同的签名创建方法并提供实现。你没有要求接口部分，但无论如何不好包括它。接口是合同。它定义了对象在实现接口时必须具有的方法签名，但它不提供实现。如果您没有在签名与接口中定义的内容匹配的方法中提供实现，则会导致编译时错误。在这里，您只需要添加关键字implements，然后添加您希望在类声明上实现的接口，然后使用equals方法完成您所做的，只使用compareTo。

请参阅此处的.equals http://docs.oracle.com/javase/7/docs/api/java/lang/Object.html 并比较到http://docs.oracle.com/javase/7/docs/api/java/lang/Comparable.html

Answer 6

对于equals（），你需要这样的东西：

public boolean equals (Object o){
    boolean res=false;
    if (o instanceof Pizza){
        Pizza p0 = (Pizza) o;
        res=getTopping().equals(p0.getTopping())&&getSize().equals(p0.getSize())&&getCost().equals(p0.getCost());
    }
    return res;

}

如何覆盖资源类中的equals（）方法？

6 个答案: