传递给Setter和Getter方法

时间：2015-05-21 22:01:34

标签： java methods inner-classes setter getter

我有一个Bread类和一个Filling类，它设置每个切片的面包类型和卡路里以及一个填充类，它设置每个服务的填充类型和卡路里......我似乎无法弄清楚如何通过他们正确地进入夹心阶层。我的总卡路里不起作用

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

}

4 个答案:

答案 0 :(得分：3)

(caloriesPerSlice) * 2 + caloriesPerServing = totalCalories;没有按照您的想法行事。

也许你的意思是

totalCalories = (caloriesPerSlice) * 2 + caloriesPerServing;

答案 1 :(得分：3)

你的变量分配向后。

(caloriesPerSlice) * 2 + caloriesPerServing = totalCalories;无效。分配给的变量必须在左侧。

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

答案 2 :(得分：1)

该课有很多错误：

  • 你有一个面包caloriesPerSlice，但构造函数使用与int相同的变量。

  • 与Filling caloriesPerServing和int caloriesPerServing相同。

  • 它有一个私有构造函数。这个构造函数指定你可以访问这个类的类的唯一方法是通过类中的静态方法返回一个Sandwich对象（就像单例模式一样），这不是这里的情况。

  • 这个类是私有的：也许我错了，但java中的私有类意味着没有人可以访问它。

  • 构造函数：例如， breadType 是一个字符串对象，并未使用它。您正在尝试使用私有变量setBread ...那是什么？

  • 构造函数：caloriesPerSlice是一个int类型，您可以在接收Bread类型的setBread（）setter中使用它。你是混合类型。

  • 与setFilling（）中使用的caloriesPerServing相同，后者接收填充对象....

  • getTotalCalories：分配在右边而不是左边。

我认为你对OO有误解。例如，让我们看一下Bread类：

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

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

在这种情况下，面包是通过他的构造函数完全定义的。你可以看到该类没有setter。那是因为我决定了它，但如果你想要一个无参数的构造函数和类中的setter，这取决于你。在这种情况下，我只定义了getter。我们来看看填充类：

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

这里的填充类有getter和setter。它仅用于解释目的：在Filling类中，您可以通过构造函数或通过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();
        }
    }

如您所见，我们在Sandwich构造函数中收到了定义面包和填充的所有参数。然后，我们创建了Bread和Filling对象，并传递了它们的参数。最后，getTotalCalories只是面包和填充属性的简单数学。

此代码只是在文本编辑器中编写。我没有检查是否可以。

在这个例子中，Sandwich成为一个类和一个工厂，是该类的一个非常重要的组成部分。正如您所看到的，面包和灌装课程的构建是通过三明治完成的。它的优点是三明治可以控制对象的创建，但事实是：三明治是否负责？也许不是，因为当你在家里做三明治时，你会得到面包和其他成分，你只需把它们放在切片上......三明治不负责制作面包片......它在现实生活中没有意义。然后，也许在Sandwich构造函数中删除对象创建是个好主意：

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

这种情况更“正确”，因为你正在用已经在内存中生成的元素制作三明治。你在家里做三明治时也是这样：你拿到面包，馅料然后做三明治。

我希望这可以澄清一些关于OO的内容。

问候！

答案 3 :(得分：0)

我在你的代码中看到了一些问题：

  • 为什么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
相关问题
最新问题