传递给 Setter 和 Getter 方法

Question

我有一个面包 class 和一个馅料 class 设置面包类型和每片卡路里以及一个馅料 class 设置馅料类型和每份卡路里...我似乎无法弄清楚如何将它们正确地传递到三明治 class 中。我的总卡路里计算不出来

    private class Sandwich {
        private Bread bread;
        private Filling filling;
        private Bread caloriesPerSlice;
        private Filling caloriesPerServing;



    private Sandwich(String breadType, int caloriesPerSlice, String fillingType, int caloriesPerServing) {
        setBread(bread);
        setBread(caloriesPerSlice);
        setFilling(caloriesPerServing);
        setFilling(filling);
    }

    public Bread getBread() {
        return bread;
    }

    public void setBread(Bread bread) {
        this.bread = bread;

    }

    public Filling getFilling() {
        return filling;
    }

    public void setFilling(Filling filling) {
        this.filling = filling;

    }

    public int getTotalCalories(int caloriesPerSlice,int caloriesPerServing) {

        (caloriesPerSlice) * 2 + caloriesPerServing =  totalCalories;
        return this.totalCalories;
    }

}

Answer 1

(caloriesPerSlice) * 2 + caloriesPerServing = totalCalories; 并不像你想象的那样。

也许你的意思是

totalCalories = (caloriesPerSlice) * 2 + caloriesPerServing;

Answer 2

你的变量赋值倒退了。

(caloriesPerSlice) * 2 + caloriesPerServing = totalCalories; 无效。被赋值的变量必须在左边。

尝试： totalCalories = (caloriesPerSlice) * 2 + caloriesPerServing;

Answer 3

class错误较多：

您有一个 Bread caloriesPerSlice，但构造函数使用与 int 相同的变量。
与填充caloriesPerServing和int caloriesPerServing相同。
它有一个私有的构造函数。此构造函数指定您可以访问此类型的 class 的唯一方法是通过 class 中的静态方法，即 returns 一个 Sandwich 对象（类似于单例模式），它是这里不是这样。
class是私有的：也许我错了，但是java中的私有class意味着没有人可以访问它。
构造器：比如breadType是一个字符串对象，没有用到。您正在尝试使用私有变量设置面包...那是什么？
构造函数：caloriesPerSlice 是一个 int 类型，您可以在接收 Bread 类型的 setBread() setter 中使用它。你是混合类型。
与setFilling()中使用的caloriesPerServing相同，接收一个Filling对象....
getTotalCalories：分配在右边，而不是左边。

我觉得你对OO有误解。例如，让我们看看面包 class:

如果面包 class 具有属性 caloriesPerSlice 和 breadType 它们可能是面包类型的一部分。让我们更改 class 以反映这些属性：

    public class Bread {
      private int caloriesPerSlice;
      private String type;

      public Bread(String type, int caloriesPerSlice)
      {
        this.type = type;
        this.caloriesPerSlice = caloriesPerSlice;
      }

      public int getCaloriesPerSlice()
      {
        return this.caloriesPerSlice;
      }

      public String getType()
      {
        return this.type;
      }
    }

在这种情况下，Bread 是通过其构造函数完全定义的。可以看到class没有setter。那是因为我决定了，但是如果你想要一个无参数的构造函数和 class 中的 setters 则取决于你。在这种情况下，我只定义了 getter。让我们看看填充 class:

    public class Filling {
      private int caloriesPerServing;
      private String type;

      public Filling(String type, int caloriesPerServing) {
        this.caloriesPerServing = caloriesPerServing;
      }

      public int getCaloriesPerServing()
      {
        return hits.caloriesPerServing;
      }

      public void setCaloriesPerServing(int calories)
      {
        this.caloriesPerServing = calories;
      }

      public String getType()
      {
        return this.type;
      }

      public void setType(String type)
      {
        this.type = type;
      }
    }

这里的 Filling class 有吸气剂和 setters。这只是为了说明目的：在 Filling class 中，您可以通过构造函数或通过 setter 设置属性，而在 Bread 中，您只能通过构造函数定义属性。

现在三明治也许可以接收定义面包和馅料的所有属性（如您的情况），或者它可以接收面包和馅料）。先来看第一种情况：

    public class Sandwich {
        private Bread bread;
        private Filling filling;

        public Sandwich(String breadType, int caloriesPerSlice, String fillingType, int caloriesPerServing) {
            this.bread = new Bread(breadType, caloriesPerSlice);
            this.filling = new Filling(fillingType, caloriesPerServing);
        }

        public Bread getBread() {
            return bread;
        }

        public void setBread(Bread bread) {
            this.bread = bread;

        }

        public int getTotalCalories() {
            return this.bread.getCaloriesPerSlice() * 2 + this.filling.getCaloriesPerServing();
        }
    }

如您所见，我们在三明治构造函数中收到了定义面包和馅料的所有参数。然后，我们创建了 Bread 和 Filling 对象，并传递了它们的参数。最后，getTotalCalories 只不过是面包和馅料属性的简单数学运算。

这段代码是用文本编辑器写的。好不好我没看

在这个例子中，Sandwich 变成了一个 class 和一个工厂，class 的一个非常重要的组件。如您所见，面包和馅料 classes 的构建是通过三明治完成的。它的优点是三明治控制对象的创建，但问题是：三明治负责吗？也许不是，因为当你在家里做三明治时，你会得到面包和其他配料，你只需将它们放在面包片上……三明治不负责制作面包片……这在现实生活中没有意义。然后，删除 Sandwich 构造函数中的对象创建也许是个好主意：

        public Sandwich(Bread bread, Filling filling) {
            this.bread = bread;
            this.filling = filling
        }

这种情况更多 'correct' 因为您正在用内存中已经生成的元素制作三明治。自己在家做三明治也是一样的：拿到面包，馅料，然后做三明治。

我希望这可以进一步阐明 OO。

您好！

Answer 4

我发现您的代码存在一些问题：

为什么 Sandwich 的实例中应该有两个 Bread 对象？三明治通常由一种面包制成。
caloriesPerSlice和caloriesPerServing应该分别是Bread和Filling的属性。
您不能将 String 参数传递给 setFilling(Filling filling) 方法。
(caloriesPerSlice) * 2 + caloriesPerServing 不是有效的左值，也不是有效的表达式，因为 caloriesPerSlice 和 caloriesPerServing 是对象。

这是您想法的基本实现：

Bread.java

public class Bread
{
    private String type;
    private int caloriesPerSlice;

    public Bread(String type, int caloriesPerSlice)
    {
        this.type = type;
        this.caloriesPerSlice = caloriesPerSlice;
    }

    public String getType() { return type;}

    public int getCaloriesPerSlice() { return caloriesPerSlice; }

    public String toString()
    {
        return type + " (" + caloriesPerSlice + "cal)";
    }
}

Filling.java

public class Filling
{
    private String name;
    private int caloriesPerServing;

    public Filling(String name, int caloriesPerSlice)
    {
        this.name = name;
        this.caloriesPerServing = caloriesPerSlice;
    }

    public String getName() { return name;}

    public int getCaloriesPerServing() { return caloriesPerServing; }

    public String toString()
    {
        return name + " (" + caloriesPerServing + "cal)";
    }
}

Sandwich.java

public class Sandwich
{
    private Bread bread;
    private Filling filling;

    public Sandwich(Bread bread, Filling filling)
    {
        this.bread = bread;
        this.filling = filling;
    }

    public int getTotalCalories()
    {
        return 2 * bread.getCaloriesPerSlice() + filling.getCaloriesPerServing();
    }

    public String toString()
    {
        return "Bread: " + bread.toString() + "\nFilling: " + filling.toString();
    }
}

Main.java

public class Main
{
    public static void main(String args[])
    {
        Bread bread = new Bread("Baguette", 150);
        System.out.println("I would like a " + bread.toString());

        Filling filling = new Filling("Prosciutto di Parma", 75);
        System.out.println("with " + filling.toString());

        Sandwich sandwich = new Sandwich(bread, filling);
        System.out.println("Your order is:");
        System.out.println(sandwich.toString());

        int totalCalories = sandwich.getTotalCalories();
        System.out.println("The total calories are " + totalCalories);
    }
}

这是输出：

I would like a Baguette (150cal)
with Prosciutto di Parma (75cal)
Your order is:
Bread: Baguette (150cal)
Filling: Prosciutto di Parma (75cal)
The total calories are 375

传递给 Setter 和 Getter 方法

Passing to Setter and Getter methods

java

methods

getter

setter

inner-classes