Reputation: 384

Passing to Setter and Getter methods

I have a Bread class and a Filling class which set the bread type and calories per slice as well as a filling class which sets the filling type and calories per serving... I can't seem to figure out how to pass them into the sandwich class correctly. My total calories doesn't work out

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

}

Upvotes: 0

Answers (4)

user4118249

Reputation:

I see some problems in your code:

why does an instance of Sandwich should have two Bread object within? A sandwich is usually made by one type of bread.
the caloriesPerSlice and caloriesPerServing should be respectively attributes of Bread and Filling.
you can't pass a String parameter to setFilling(Filling filling) method.
(caloriesPerSlice) * 2 + caloriesPerServing is not a valid left-value and is not a valid expression because caloriesPerSlice and caloriesPerServing are objects.

This is a really basic implementation of your idea:

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

This is the output:

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

Upvotes: 0

jparaya

Reputation: 1339

The class has a lot of errors:

You have a Bread caloriesPerSlice, but the constructor uses the same variable as int.
The same with the Filling caloriesPerServing and the int caloriesPerServing.
It has a private constructor. This constructor specify that the only way you can access a class of this type is through a static method in the class that returns an Sandwich object (like with the singleton pattern), which is not the case here.
The class is private: maybe I'm wrong, but a private class in java means that no one can access it.
The constructor: for example, breadType is a string object, and it's not used. You are trying to setBread with the private variable... what is that?
The constructor: caloriesPerSlice is an int type and you use it in the setBread() setter which receives a Bread type. You are mixing types.
The same with caloriesPerServing which is used in setFilling(), which receives a Filling object....
getTotalCalories: the assignment goes on the right, not the left.

I think you have a misunderstanding of OO. For example, let's see the Bread class:

If the bread class has the properties caloriesPerSlice and breadType they maybe are part of the bread type. Let's change the class to reflect those properties:

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

Here in this case the Bread is completely defined though his constructor. You can see that the class has no setter. That's because I decided it, but it's up to you if you want a parameterless constructor and setters in the class. Here in this case I only defined getters. Let's see the Filling 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;
      }
    }

Here the Filling class has getters and setters. It's just for explanation purposes: in the Filling class you can set the properties through constructor or through the setters, whilst in the Bread you can only define the properties through the constructor.

Now the Sandwich maybe can receive all the properties that define a bread and a filling (like in your case), or maybe it can receive a bread and a filling). Let's see the first case:

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

As you can see, we received in the Sandwich constructor all the parameters which define a bread and a filling. Then, we created the Bread and Filling objects, passing their parameters. Finally, the getTotalCalories is nothing but a simple math of the bread and filling properties.

This code was just writen in a text editor. I did not checked if it's ok or not.

In this example, Sandwich becomes a class and a factory, a very important component of the class. As you can see, the construction of the Bread and Filling classes is made through the Sandwich. It has the advantage that the Sandwich controls the creation of objects, but the thing is: Is the sandwich responsible of that? Maybe not, because when you make a sandwich in your home you get the bread and the other ingredients and you just put them on the slices... the sandwich is not responsible of the creation of a bread slice... it does not make sense in the real life. Then, maybe it's a good idea to remove the object creation in the Sandwich constructor:

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

This case is more 'correct' because you're making a sandwich with the elements already generated in memory. It's the same when you make a sandwich in your home: you get the bread, the filling and then you make a sandwich.

I hope this can clarify a little more about OO.

Greetings!

Upvotes: 0