# Java Programm PIZZA



## Niksan (29. Dez 2009)

Hallo alle zusammenm.
Ich hab da ein mächtiges Problem, und zwar muss ich für die Uni ne aufgabe bewältigen, d.h. son Java Programm implementieren. Jedoch komm ich da irgendwie garnicht zurecht ...

hier ist die Aufgabe 

https://sol.cs.hm.edu/course/st/se1a-lab/slide0047.html

Ich hab zwar schon alle Klassen erstellet, aber komm nicht weiter, wo sind Objektvariablen, Kostruktoren und so, ich steh irgendwie voll aufm Schlauch ...

Wäre cool wenn einer mir etwas weiterhelfen könnte 

Danke schon mal im vorraus 
Grüße Niko


----------



## Der Müde Joe (29. Dez 2009)

Dann poste mal die Klassen und wo darin das Problem liegt/liegen


----------



## javimka (29. Dez 2009)

Niksan hat gesagt.:


> wo sind Objektvariablen, Kostruktoren und so


Wenn du die noch nicht einprogrammiert hast, sind die noch nirgendwo. Objektvariabeln sind Objekte, die für das ganze Objekt einer Klasse sichtbar sind, also in der Klasse stehen. Die musst du, genau wie Konstruktoren, selber schreiben.

Ein Beispiel: "Crusty" ist ein Pizzaboden und erbt also von der abstrakten Klasse "Bottom". Jeder Boden hat einen Preis, also ist "Preis" eine Objektvariable, die in die Klasse "Bottom" gehört. Die Klasse "Crusty" braucht einen Konstruktor. Dieser Konstruktor ruft optimalerweise den Konstruktor der Vaterklasse "Bottom" auf und übergibt dieser gleich den Preis:

```
public class Crusty extends Bottom {

// hier stehen die Objektvariabeln

public Crusty() { // Konstruktor
  super(340); // übergebe den Preis.
}
...
}
```

Mit super(340) wird dem Konsruktor der Vaterklasse einen int übergeben. Logischerweise, braucht die Klasse Bottom also einen Konstruktor, der einen int aufnimmt: [c]public Bottom(int preis) { ... }[/c]


Die Aufgabenstellung finde ich übrigens insofern unglücklich, dass jeder Pizzaboden und jede Pizzaauflage selbst eine Pizza ist. Man kann es sich zwar schon zurechtbiegen, dass es stimmt, aber dennoch - unglücklich.
Und die main Mehtode: [c]Pizza p = print(new Crusty());[/c], naja...


----------



## Marco13 (30. Dez 2009)

Ja, kann nicht schaden: Java Probramm Pizza - Byte-Welt Forum


----------



## Niksan (30. Dez 2009)

Ok also schaut bei mir dann die Bottom Klasse schon mal so aus:


```
abstract public class Bottom implements Pizza
{
   protected int price;
   protected boolean veg = true;
   protected boolean hot = false;

   public Bottom (int price)
    {
        this.price = price;
    }
    
   public int getPrice()           // Preis in Cent
    {
        return price;
    }
            
   public boolean isVegetable()  // Pizza ist vegetarisch?
    {
        return true;            //ja, Boden immer vegetarisch
    }

   public boolean isHot()        // Pizza ist scharf?
    {
        return false;           //nein, Boden immer unscharf
    }
}
```

Passt das so oder fehlt da was ?! ...
Und brauch ich eigentlich nicht nur in der Vaterklasse die Obj. Variablen, die werden ja mit vererbt ?!?!, was so viel heisst wie, dass z.B. Crusty keine Obj.Var. hat ?!
OK, demzufolge hab ich die Topping Klasse erstellt, die noch so ausschaut:


```
public abstract class Topping implements Pizza // Auflage mit allem darunter
{
    private final Pizza below; // die Pizza darunter <--- might not have been initialized

    protected final int price;
    protected final boolean veg;
    protected final boolean hot;

    public Topping (Pizza p)
    {
        ?????
    }

    public Topping (int price, boolean veg, boolean hot)
    {
        this.price = price;
        this.veg = veg;
        this.hot = hot;
    }
 
  public int getPrice()           // Preis in Cent
    {
        return price;
    }

  public boolean isVegetable()  // Pizza ist vegetarisch?
    {
        return veg;
    }

  public boolean isHot()        // Pizza ist scharf?
    {
        return hot;
    }
}
```

Hmm ich versteh nicht so ganz wo die "feste" Pizza laut UML hier zusandekommt und was in dem Konstruktor "public Topping (Pizza p)" stehen soll ...


----------



## Der Müde Joe (30. Dez 2009)

Ich hab mal eine Variante geschrieben:

```
public abstract class Bottom implements Pizza {

	@Override
	public abstract int getPrice();

	@Override
	public final boolean isHot() {
		return false;
	}

	@Override
	public final boolean isVegetable() {
		return true;
	}
}

class CrustyBottom extends Bottom {
	
	public final int PRICE = 340;

	@Override
	public int getPrice() {
		return PRICE;
	}
	
}

class MunchyBottom extends Bottom {
	
	public final int PRICE = 395;

	@Override
	public int getPrice() {
		return PRICE;
	}
	
}
```


```
public abstract class Topping implements Pizza{

	private final Pizza below;
	
	public Topping(Pizza pizza) {
		this.below = pizza;
	}
}

class Salami extends Topping {
	
	private static final int PRICE = 225;
	private static final boolean IS_HOT = true;
	private static final boolean IS_VEGETABLE = false;

	public Salami(Pizza below) {
		super(below);
	}
	
	@Override
	public int getPrice() {return PRICE;}

	@Override
	public boolean isHot() {return IS_HOT;}

	@Override
	public boolean isVegetable() {return IS_VEGETABLE;}
}
```

Die andere Möglichkeit wäre

```
public abstract class Topping implements Pizza{

	private final Pizza below;
	
	private int price;
	private boolean isHot;
	private boolean isVegetable;
	
	public Topping(Pizza pizza, int price, boolean isHot, boolean isVegetable) {
		this.below = pizza;
		this.price = price;
		this.isHot = isHot;
		this.isVegetable = isVegetable;
	}

	@Override
	public int getPrice() {return this.price;}

	@Override
	public boolean isHot() {return this.isHot;}

	@Override
	public boolean isVegetable() {return this.isVegetable;}
}

class Salami extends Topping {
	
	private static final int PRICE = 225;
	private static final boolean IS_HOT = true;
	private static final boolean IS_VEGETABLE = false;

	public Salami(Pizza below) {
		super(below,PRICE,IS_HOT,IS_VEGETABLE);
	}
}
```

EDIT:
Natürlich ist das noch nicht die fertige lösung:
zB 
der preis aller zutaten muss wohl  addiert werden (below.getPrice() + this.getPrice())
das gleiche für vegetarisch ( return below.isVegetarian() && this.isVegetarian();
und auch mit scharf

(dafür ist dann wohl die 2. Möglichkeit besser geeignet)


----------



## Niksan (4. Jan 2010)

so frohes neues erstma, Dank dir Joe, hast mir viel weitergeholfen, hab noch ein problem, hab ich schon im anderen Forum gepostet, und da ja anscheinend gleiche leute unterweg sind, poste ich mal nur den link hier rein 

Java Probramm Pizza - Seite 2 - Byte-Welt Forum

danke nochma
grüße Niko


----------



## Der Müde Joe (4. Jan 2010)

Such dir alle Below zusammen und adde alle hot zusammen.
Also:
counter = 0;
1. wenn ein below vorhanden und ist und hot -> counter +1
2 .wenn below topping ist..gehe mit dem below zu 1 sonst 3
3. ist hot wenn counter >= 2

schöne rekursion.... ;-)


----------



## Landei (4. Jan 2010)

Ich hab's mir nicht so genau angeschaut, aber wenn es um das flexible Zusammensetzen unter Einhaltung bestimmter Randbedingungen (Hmmm, ich liebe den Pizza-Rand!), hilft vielleicht das Typesafe Builder Pattern weiter.


----------



## Niksan (5. Jan 2010)

so danke, hat alles geklappt, Programm ist endlich fertig !
Vielen Dank für die Hilfe 
Grüße Niko


----------

