COMPOSITE


public abstract class ANod {
	public abstract String getDenumire();
	public abstract int getPret();

	public String getInfo(){
		return this.getDenumire() + " " + this.getPret();
	}

	public void adaugaNod(ANod elemStructura){
		throw new UnsupportedOperationException();
	}

	public void eliminaNod(ANod elemStructura){
		throw new UnsupportedOperationException();
	}

	public ANod getNod (int i){
		throw new UnsupportedOperationException();
	}
}


--------------------------------------------------------
public class Meniu {
	Structura structura;
	String numeRestaurant;

	public Meniu(Structura structura, String numeRestaurant){
		this.structura = structura;
		this.numeRestaurant = numeRestaurant;
	}

	public String getNumeRestaurant() {
		return numeRestaurant;
	}

	public void setNumeRestaurant(String numeRestaurant) {
		this.numeRestaurant = numeRestaurant;
	}

}

--------------------------------------------------------
public class Produs extends ANod{

	String denumire;
	int pret;

	public Produs(String denumire, int pret){
		this.denumire = denumire;
		this.pret = pret;
	}

	@Override
	public String getDenumire() {
		return this.denumire;
	}

	@Override
	public int getPret() {
		return this.pret;
	}

	public void setDenumire(String denumire) {
		this.denumire = denumire;
	}

	public void setPret(int pret) {
		this.pret = pret;
	}
}
---------------------------------------------------
import java.util.ArrayList;

public class Structura extends ANod{

	ArrayList<ANod> structura = new ArrayList<>();
	String numeStructura;

	public Structura(String numeStructura){
		this.numeStructura = numeStructura;
	}

	@Override
	public String getDenumire() {
		throw new UnsupportedOperationException();
	}

	@Override
	public int getPret() {
		throw new UnsupportedOperationException();
	}

	@Override
	public String getInfo(){
		String info = "";
		info += this.numeStructura + "\n";
		for(ANod n: structura){
			info += " " + n.getInfo();
			info += "\n";
		}
		return info;
	}

	@Override
	public void adaugaNod(ANod elemStructura){
		structura.add(elemStructura);
	}

	@Override
	public void eliminaNod(ANod elemStructura){
		structura.remove(elemStructura);
	}

	@Override
	public ANod getNod(int i){
		return (ANod)structura.get(i);
	}

}------------------------------------------------


public class TestComposite {

	public static void main(String[] args) {
		//definire nivel 0 arborescenta
		Structura structuraMeniu = new Structura("Meniu restaurant");

		Meniu meniu = new Meniu(structuraMeniu, "Pizzeria ASE");

		//definire nivel 1 arborescenta
		Structura structuraBauturi = new Structura("Bauturi");
		Structura structuraMancare = new Structura("Mancare");
		structuraMeniu.adaugaNod(structuraBauturi);
		structuraMeniu.adaugaNod(structuraMancare);

		//definire noduri nivel 2 arborescenta (Bauturi)
		structuraBauturi.adaugaNod(new Produs("CocaCola", 10));
		structuraBauturi.adaugaNod(new Produs("Pepsi", 9));

		//definire noduri nivel 2 arborescenta (Mancare)
		Structura structuraMancarePizza = new Structura("Pizza");
		Structura structuraMancarePaste = new Structura("Paste");
		structuraMancare.adaugaNod(structuraMancarePizza);
		structuraMancare.adaugaNod(structuraMancarePaste);

		//definire noduri nivel 3 arborescenta (Mancare - Pizza)
		structuraMancarePizza.adaugaNod(new Produs("Pizza Margherita", 25));
		structuraMancarePizza.adaugaNod(new Produs("Pizza Capriciosa", 29));

		//definire noduri nivel 3 arborescenta (Mancare - Paste)
		structuraMancarePaste.adaugaNod(new Produs("Paste carbonara", 27));
		structuraMancarePaste.adaugaNod(new Produs("Paste branza", 32));

		//afisare structura Meniu
		System.out.println(meniu.getNumeRestaurant());
		System.out.println(structuraMeniu.getInfo());
	}

}
================================================================
PROXY
public class Contract implements IContract{
	private String infContract = null;

	public Contract(String infContract) {
		this.infContract = infContract;
		imprimareContract();
	}

	@Override
	public void multiplicareContract() {
		System.out.println("Xerox de pe contractul " + infContract);
	}

	public void imprimareContract(){
		System.out.println("Imprimare contract " + infContract);
	}

}

-----------------------------------------------------------------
public interface IContract {
	public abstract void multiplicareContract();
}
----------------------------------------------------------------
public class ProxyContract implements IContract{
	private String infContract = null;
	private Contract contract = null;

	public ProxyContract(String infContract) {
		this.infContract = infContract;
	}

	@Override
	public void multiplicareContract() {
		if(contract == null)
			contract = new Contract(infContract);
		contract.multiplicareContract();
	}

}

--------------------------------------------------------------
public class TestProxy {

	public static void main(String[] args) {
		IContract contract1 = new ProxyContract("text");

		contract1.multiplicareContract();
		contract1.multiplicareContract();
		contract1.multiplicareContract();
	}

}
==============================================================
SINGLETON

public class MeseRestaurant {

	private static MeseRestaurant instance=null;
	private int nrMese=10;
	private boolean ocupareMese[]=new boolean[nrMese];

	private MeseRestaurant() throws Exception{
		if(instance!=null)
			throw new Exception("obiect deja creat");
	}

	public static MeseRestaurant getInstance() throws Exception{
		if(instance==null)
			instance=new MeseRestaurant();
		return instance;
	}

	public void setOcupareMasa(int i) {
		if(i>=1 && i<=nrMese && ocupareMese[i]==false)
			ocupareMese[i]=true;

	}
	public void setEliberareMasa(int i) {
		if(i>=1 && i<=nrMese && ocupareMese[i]==true)
			ocupareMese[i]=false;

	}

	@Override
	public String toString() {
		String rezultat = "";
		for(int i=0;i<nrMese;i++)
			rezultat += i + " " + ocupareMese[i] + " ";
		return rezultat;
	}

}
----------------------------------------------------------------------

public class Ospatar {
	private String nume;
	private MeseRestaurant mese;

	public Ospatar(String nume) throws Exception{
		this.nume=nume;
		mese=MeseRestaurant.getInstance();
	}
	public void setOcupareMasa(int i){
		mese.setOcupareMasa(i);
	}
	public void setEliberareMasa(int i){
		mese.setEliberareMasa(i);
	}
	public String getNume(){
		return nume;
	}
	public MeseRestaurant getMese() {
		return mese;
	}


}
-------------------------------------------------------------

public class TestSingleton {

	public static void main(String[] args) throws Exception {
		Ospatar o=new Ospatar("Ion");
		Ospatar p=new Ospatar("Gigi");
		if(o.getMese()==p.getMese())
			System.out.println("ref id");
		else System.out.println("ref nu sunt id");

		o.setOcupareMasa(3);
		System.out.println(o.getMese());
		System.out.println(p.getMese());


	}

}
================================================================
DECORATOR
public class CrownPizza extends DecoratorPizza{

	public CrownPizza(Pizza pizza) {
		super(pizza);
	}

	@Override
	String getComponente() {
		return super.getComponente() + ", blat crown";
	}

	@Override
	float getCost() {
		return super.getCost() + 10;
	}
}

--------------------------------------------------------------
public abstract class DecoratorPizza extends Pizza{
	protected Pizza pizza;

	public DecoratorPizza(Pizza pizza) {
		this.pizza = pizza;
	}

	@Override
	String getComponente() {
		return pizza.getComponente();
	}

	@Override
	float getCost() {
		return pizza.getCost();
	}
}
-------------------------------------------------

public abstract class Pizza {
	private String denumire;
	private float cost;

	abstract String getComponente();
	abstract float getCost();

}
---------------------

public class PizzaTipA extends Pizza{

	@Override
	String getComponente() {
		return "blat, sos rosii, branza, sunca";
	}

	@Override
	float getCost() {
		return 20;
	}

}
------------------------------
public class TestDecorator {

	public static void main(String[] args) {
		Pizza pizzaTipA = new PizzaTipA();
		System.out.println("Pizza de baza tip A");
		System.out.println(pizzaTipA.getComponente());
		System.out.println(pizzaTipA.getCost());

		pizzaTipA = new PizzaTipA();

		Pizza pizzaDecorataCrown = new CrownPizza(pizzaTipA);
		System.out.println("Pizza decorata Crown");
		System.out.println(pizzaDecorataCrown.getComponente());
		System.out.println(pizzaDecorataCrown.getCost());

	}

}


===================
FACADE
import java.util.ArrayList;

public class Bucatarie {
	protected ArrayList<Cuptor> listaCuptoare = new ArrayList<>();

	public Bucatarie(){
		Cuptor cuptor1 = new Cuptor("1", true);
		Cuptor cuptor2 = new Cuptor("2", true);
		listaCuptoare.add(cuptor1);
		listaCuptoare.add(cuptor2);
	}

	public void inchideCuptoare(){
		System.out.println("Se inchid cuptoarele");
		for(Cuptor cuptor: listaCuptoare)
			cuptor.setEsteInchis(true);
	}

	public void deschideCuptoare(){
		System.out.println("Se deschid cuptoarele");
		for(Cuptor cuptor: listaCuptoare)
			cuptor.setEsteInchis(false);
	}
}

----------------
public class Cuptor {
	private String codCuptor;
	private boolean esteInchis;

	public Cuptor(String codCuptor, boolean esteInchis) {
		this.codCuptor = codCuptor;
		this.esteInchis = esteInchis;
	}

	public String getCodCuptor() {
		return codCuptor;
	}

	public boolean isEsteInchis() {
		return esteInchis;
	}

	public void setEsteInchis(boolean esteInchis) {
		this.esteInchis = esteInchis;
	}

}

---------------------

public class RestaurantFacade {
	Bucatarie bucatarie;
	UsaIntrare usaIntrare;

	public RestaurantFacade(Bucatarie bucatarie, UsaIntrare usaIntrare) {
		this.bucatarie = bucatarie;
		this.usaIntrare = usaIntrare;
	}

	public void inchideRestaurant(){
		this.bucatarie.inchideCuptoare();
		this.usaIntrare.inchideUsa();
	}

	public void deschideRestaurant(){
		this.usaIntrare.deschideUsa();
		this.bucatarie.deschideCuptoare();
	}
}


----------------------
public class UsaIntrare {
	protected boolean esteInshisa = true;

	public void deschideUsa(){
		System.out.println("Se deschide usa");
		this.esteInshisa = false;
	}

	public void inchideUsa(){
		System.out.println("Se inchide usa");
		this.esteInshisa = true;
	}
}


---------------------
public class TestFacade {

	public static void main(String[] args) {
		Bucatarie bucatarie = new Bucatarie();
		UsaIntrare usaIntrare = new UsaIntrare();

		RestaurantFacade restaurant = new RestaurantFacade(bucatarie, usaIntrare);

		System.out.println("Procedura deschidere restaurant!");
		restaurant.deschideRestaurant();

		System.out.println("\nProcedura inchidere restaurant!");
		restaurant.inchideRestaurant();

	}

}
=======================
STATE
public class Angajat {
	private String numeAngajat;
	private IStare stareCurenta;

	public Angajat(String numeAngajat) {
		this.numeAngajat = numeAngajat;
		this.stareCurenta = new StarePauza();
	}

	public void setStare(EStari stare) {
		if(stare == EStari.StareConcediu)
			this.stareCurenta = new StareConcediu();
		else
			if(stare == EStari.StarePauza)
				this.stareCurenta = new StarePauza();
			else
				this.stareCurenta = new StareTura();
	}

	public void actiune(String mesaj){
		this.stareCurenta.actiune(mesaj);
	}
}

-----------------

public enum EStari {
	StareTura,
	StareConcediu,
	StarePauza
}
----------
public interface IStare {
	void actiune(String mesaj);
}

-------------
public class StareConcediu implements IStare{

	@Override
	public void actiune(String mesaj) {
		System.out.println("Angajat in concediu. Nu poate rezolva problema "
	+ mesaj);
	}

}
----------------
public class StarePauza implements IStare{

	@Override
	public void actiune(String mesaj) {
		System.out.println("Angajat in pauza. Se ocupa de problema "
	+ mesaj);
	}

}
---------------
public class StareTura implements IStare{

	@Override
	public void actiune(String mesaj) {
		System.out.println("Angajat pe tura. Se ocupa de problema "
	+ mesaj);
	}

}


-------------
public class TestState {

	public static void main(String[] args) {
		Angajat angajat = new Angajat("Costache Marian");
		angajat.actiune("TO DO");

		angajat.setStare(EStari.StareConcediu);
		angajat.actiune("TO DO");
	}

}

=============
CHAINOFRESP
public class Bucatar extends Handler{

	@Override
	void procesareComanda(Comanda comanda) {
		System.out.println("Bucatarul a procesat comanda "
				+ comanda.getProdus());

	}

}
--------------
public class Comanda {
	private String produs;
	private int cantitate;
	private int grad;

	public Comanda(String produs, int cantitate, int grad) {
		this.produs = produs;
		this.cantitate = cantitate;
		this.grad = grad;
	}

	public String getProdus() {
		return produs;
	}

	public int getCantitate() {
		return cantitate;
	}

	public int getGrad() {
		return grad;
	}

}

-------------
public abstract class Handler {
	protected Handler succesor = null;

	public void setSuccesor(Handler succesor) {
		this.succesor = succesor;
	}

	abstract void procesareComanda(Comanda comanda);
}

------------
public class Ospatar extends Handler{

	@Override
	void procesareComanda(Comanda comanda) {
		if(comanda.getGrad() <= 5)
			System.out.println("Ospatarul a procesat comanda "
		+ comanda.getProdus());
		else {
			System.out.println("Ospatarul nu poate procesa comanda");
			if(this.succesor != null)
				this.succesor.procesareComanda(comanda);
		}
	}

}
--------------
public class TestChain {

	public static void main(String[] args) {
		Ospatar ospatar = new Ospatar();
		Bucatar bucatar = new Bucatar();

		ospatar.setSuccesor(bucatar);

		Comanda comanda1 = new Comanda("Pizza", 2, 15);
		Comanda comanda2 = new Comanda("Bautura", 1, 3);
		Comanda comanda3 = new Comanda("Cafea", 1, 4);

		System.out.println("COMANDA 1");
		ospatar.procesareComanda(comanda1);

		System.out.println("\nCOMANDA 2");
		ospatar.procesareComanda(comanda2);

		System.out.println("\nCOMANDA 3");
		ospatar.procesareComanda(comanda3);
	}

}
==================
FACTORY


public abstract class AAngajat {
	private String nume;

	public void setNume(String nume) {
		this.nume = nume;
	}
	public abstract String getTip();
	public abstract void afisare();

}
---------------

public class AngajatFactory {
	public AAngajat creareAngajat(TipAngajat tip, String nume){
		AAngajat angajat=null;
		switch(tip){
		case Ospatar:
			angajat=new Ospatar();
			angajat.setNume(nume);
			break;
		case Bucatar:
			angajat=new Bucatar();
			angajat.setNume(nume);
			break;
		}
		return angajat;
	}
}
----------------

public class Bucatar extends AAngajat{

	@Override
	public String getTip() {
		// TODO Auto-generated method stub
		return "Bucatar";
	}

	@Override
	public void afisare() {
		System.out.println("E bucatar");

	}

}
---------------

public class Ospatar extends AAngajat{

	@Override
	public String getTip() {
		// TODO Auto-generated method stub
		return "Ospatar";
	}

	@Override
	public void afisare() {
		System.out.println("Este ospatar");

	}


}
-------------

public class TestFactory {

	public static void main(String[] args) {
		AngajatFactory af=new AngajatFactory();

		AAngajat a=af.creareAngajat(TipAngajat.Bucatar, "asd");
		AAngajat b=af.creareAngajat(TipAngajat.Ospatar, "bbb");

		System.out.println(a.getTip());
		b.afisare();
	}

}
------------

public enum TipAngajat {
	Ospatar,Bucatar
}
=========================
STRATEGY
import java.util.ArrayList;

public interface IProcesabil {
	OfertaMeniu alegereMeniu(ArrayList<OfertaMeniu> listaMeniuri);
}
--------------------
import java.util.ArrayList;

public class MeniuRestaurant {
	private ArrayList<OfertaMeniu> listaMeniuri = new ArrayList();
	private IProcesabil strategieAlegere;

	public void addOfertaMeniu(OfertaMeniu ofertaMeniu){
		this.listaMeniuri.add(ofertaMeniu);
	}

	public void setStrategieAlegere(IProcesabil strategieAlegere){
		this.strategieAlegere = strategieAlegere;
	}

	public OfertaMeniu alegereOferta(){
		if(strategieAlegere != null){
			return strategieAlegere.alegereMeniu(listaMeniuri);
		}
		else
			throw new UnsupportedOperationException();
	}

}
-------------------
public class OfertaMeniu {
	private String denumireMeniu;
	private int nrCalorii;
	private int nrCarbohidrati;

	public OfertaMeniu(String denumireMeniu, int nrCalorii, int nrCarbohidrati) {
		this.denumireMeniu = denumireMeniu;
		this.nrCalorii = nrCalorii;
		this.nrCarbohidrati = nrCarbohidrati;
	}

	public String getDenumireMeniu() {
		return denumireMeniu;
	}

	public int getNrCalorii() {
		return nrCalorii;
	}

	public int getNrCarbohidrati() {
		return nrCarbohidrati;
	}

	@Override
	public String toString() {
		return "OfertaMeniu [denumireMeniu=" + denumireMeniu + ", nrCalorii="
				+ nrCalorii + ", nrCarbohidrati=" + nrCarbohidrati + "]";
	}


}
-------------

import java.util.ArrayList;

public class StrategieCaloriiMinime implements IProcesabil{

	@Override
	public OfertaMeniu alegereMeniu(ArrayList<OfertaMeniu> listaMeniuri) {
		OfertaMeniu ofertaMeniuCaloriiMinime = listaMeniuri.get(0);
		for(OfertaMeniu oferta: listaMeniuri){
			if(oferta.getNrCalorii() < ofertaMeniuCaloriiMinime.getNrCalorii())
				ofertaMeniuCaloriiMinime = oferta;
		}

		return ofertaMeniuCaloriiMinime;
	}

}
--------------------
import java.util.ArrayList;

public class StrategieCarbohidratiMinim implements IProcesabil{

	@Override
	public OfertaMeniu alegereMeniu(ArrayList<OfertaMeniu> listaMeniuri) {
		OfertaMeniu ofertaMeniuCarbohidratiMinim = listaMeniuri.get(0);
		for(OfertaMeniu oferta: listaMeniuri){
			if(oferta.getNrCarbohidrati() < ofertaMeniuCarbohidratiMinim.getNrCarbohidrati())
				ofertaMeniuCarbohidratiMinim = oferta;
		}

		return ofertaMeniuCarbohidratiMinim;
	}

}
----------------------
public class TestStrategy {

	public static void main(String[] args) {
		MeniuRestaurant meniuRestaurant = new MeniuRestaurant();

		//adaugare meniuri in meniu restaurant
		OfertaMeniu meniu1 = new OfertaMeniu("Meniu1", 750, 70);
		OfertaMeniu meniu2 = new OfertaMeniu("Meniu2", 500, 80);
		OfertaMeniu meniu3 = new OfertaMeniu("Meniu3", 650, 20);
		OfertaMeniu meniu4 = new OfertaMeniu("Meniu4", 800, 90);

		meniuRestaurant.addOfertaMeniu(meniu1);
		meniuRestaurant.addOfertaMeniu(meniu2);
		meniuRestaurant.addOfertaMeniu(meniu3);
		meniuRestaurant.addOfertaMeniu(meniu4);

		//alegere meniu nr calorii minim
		meniuRestaurant.setStrategieAlegere(new StrategieCaloriiMinime());
		System.out.println("Meniu cu minim calorii" + meniuRestaurant.alegereOferta());

		//alegere meniu nr carbohidrati minim
		meniuRestaurant.setStrategieAlegere(new StrategieCarbohidratiMinim());
		System.out.println("Meniu cu minim carbohidrati" + meniuRestaurant.alegereOferta());

	}

}

=====================
FLYWEIGHT
public class Bon implements IPrintabil{
	private TipPrintareBon tipPrintare;
	private int costTotal;

	public Bon(TipPrintareBon tipPrintare) {
		this.tipPrintare = tipPrintare;
	}

	public int getCostTotal() {
		return costTotal;
	}

	public void setCostTotal(int costTotal) {
		this.costTotal = costTotal;
	}

	public TipPrintareBon getTipPrintare() {
		return tipPrintare;
	}

	@Override
	public void printeaza() {
		System.out.println("S-a printat un bon in format " +
	this.tipPrintare + " cu un cost total de " + this.costTotal);
	}

}
---------------

import java.util.HashMap;

public class BonFlyweightFactory {
	private static HashMap<TipPrintareBon, Bon> listaBonuri = new HashMap<>();
	private static int nrBonuriPrintate = 0;

	public Bon getBon(TipPrintareBon tipPrintare){
		nrBonuriPrintate++;
		Bon bon = listaBonuri.get(tipPrintare);
		if(bon == null){
			System.out.println("\nS-a creat o matrita pentru formatul de bon " +
		tipPrintare);
			bon = new Bon(tipPrintare);
			listaBonuri.put(tipPrintare, bon);
		}
		return bon;
	}

		public static int getNrBonuriPrintate(){
		return nrBonuriPrintate;
	}

	public static int getNrMatriteBonuri(){
		return listaBonuri.size();
	}
}
-----------------


public interface IPrintabil {
	void printeaza();
}


-------------------

public class TestFlyweight {

	public static void main(String[] args) {
		BonFlyweightFactory bonFactory = new BonFlyweightFactory();
		TipPrintareBon[] tipuriPrintare = TipPrintareBon.values();
		int nrTipuriBon = TipPrintareBon.values().length;
		int random;

		for (int i=1; i<=20; i++){
			random = (int) (Math.random() * nrTipuriBon);
			Bon bon = bonFactory.getBon(tipuriPrintare[random]);
			bon.setCostTotal(100 + 5*i);
			bon.printeaza();
		}

		System.out.println("\nS-au printat " +
		BonFlyweightFactory.getNrBonuriPrintate() + " bonuri");
		System.out.println("S-au generat " +
		BonFlyweightFactory.getNrMatriteBonuri() + " matrite bonuri");

	}

}
-------------
public enum TipPrintareBon {
	FORMAT1, FORMAT2, FORMAT3;
}


==============
TEMPLATE
=========================
public abstract class EvaluareDaune {
	abstract void identifyDamage();
	abstract void initialEvaluationDamage();
	abstract void sendEvaluationToManager();

	public void procedureDamageEvaluation(){
		identifyDamage();
		initialEvaluationDamage();
		sendEvaluationToManager();
	}
}
------------
public class KitchenDamageEvaluation extends EvaluareDaune{

	@Override
	void identifyDamage() {
		System.out.println("Identify damage");
	}

	@Override
	void initialEvaluationDamage() {
		System.out.println("Initial evaluation of the damage");
	}

	@Override
	void sendEvaluationToManager() {
		System.out.println("Send evaluation to the manager");
	}


}
-----------
public class TestTemplate {

	public static void main(String[] args) {
		KitchenDamageEvaluation kitchenDamageEvaluation =
				new KitchenDamageEvaluation();
		System.out.println("Damage evaluation procedure");
		kitchenDamageEvaluation.procedureDamageEvaluation();

	}

}
=======================
COMMAND
public class Bucatar {
	private String numeBucatar;

	public Bucatar(String numeBucatar) {
		this.numeBucatar = numeBucatar;
	}

	public void prelucreazaPizza(String tipPizza){
		System.out.println("Bucatar a preparat pizza " + tipPizza);
	}

	public void prelucreazaPaste(String tipPaste){
		System.out.println("Bucatar a preparat paste " + tipPaste);
	}
}
-------------------------
public class ComandaPaste implements IComanda{

	private Bucatar bucatar;
	private String tipPaste;

	public ComandaPaste(Bucatar bucatar, String tipPaste) {
		this.bucatar = bucatar;
		this.tipPaste = tipPaste;
	}

	@Override
	public void prelucreaza() {
		bucatar.prelucreazaPaste(tipPaste);
	}

}
------------
public class ComandaPizza implements IComanda{

	private Bucatar bucatar;
	private String tipPizza;

	public ComandaPizza(Bucatar bucatar, String tipPizza) {
		this.bucatar = bucatar;
		this.tipPizza = tipPizza;
	}

	@Override
	public void prelucreaza() {
		bucatar.prelucreazaPizza(tipPizza);

	}

}
--------------
public enum EComanda {
	ComandaPizza,
	ComandaPaste
}

---------

public interface IComanda {
	void prelucreaza();
}

------------
import java.util.ArrayList;

public class Ospatar {
	public ArrayList<IComanda> listaComenzi;

	public Ospatar(){
		listaComenzi = new ArrayList();
	}

	public void preiaComanda(IComanda comanda){
		listaComenzi.add(comanda);
	}

	public void transmiteComenzile(){
		for(IComanda c: listaComenzi)
			c.prelucreaza();
		listaComenzi.clear();
	}
}
----------------

public class TestCommand {

	public static void main(String[] args) {
		Bucatar bucatar = new Bucatar("Costache Marian");

		Ospatar ospatar = new Ospatar();
		ospatar.preiaComanda(new ComandaPizza(bucatar, "PizzaA"));
		ospatar.preiaComanda(new ComandaPizza(bucatar, "PizzaA"));
		ospatar.preiaComanda(new ComandaPaste(bucatar, "PasteB"));
		ospatar.transmiteComenzile();

	}

}
====================
MEMENTOpublic class Contract {
	private String clauzeContractuale;
	private String numeClient;

	public Contract(String numeClient) {
		this.numeClient = numeClient;
		this.clauzeContractuale = "";
	}

	public void adaugaClauzeContractuale(String clauza){
		this.clauzeContractuale += "\n" + clauza;
	}

	@Override
	public String toString() {
		return "Contract [clauzeContractuale=" + clauzeContractuale
				+ ", numeClient=" + numeClient + "]";
	}

	public void refacereVersiuneContractAnterior(VersiuneContract versiuneContract){
		this.clauzeContractuale = versiuneContract.getClauzeContractuale();
	}

	public VersiuneContract salvare(){
		System.out.println("Salvare versiune contract");
		return new VersiuneContract(clauzeContractuale);
	}
}--------------
import java.util.ArrayList;

public class ManagerContracte {
	private ArrayList<VersiuneContract> listaVersiuni = new ArrayList();

	public void adaugaVersiune(VersiuneContract versiuneContract){
		this.listaVersiuni.add(versiuneContract);
	}

	public VersiuneContract recuperareVersiune(int i){
		if(listaVersiuni.get(i) != null)
			return listaVersiuni.get(i);
		else
			return new VersiuneContract();
	}
}

------------------
public class TestMemento {

	public static void main(String[] args) {
		ManagerContracte managerContracte = new ManagerContracte();
		Contract contract = new Contract("Client1");

		//salvare versiuni contracte
		contract.adaugaClauzeContractuale("Clauza1");
		System.out.println(contract);
		contract.adaugaClauzeContractuale("Clauza2");
		System.out.println(contract);
		managerContracte.adaugaVersiune(contract.salvare());

		contract.adaugaClauzeContractuale("Clauza3");
		System.out.println(contract);
		managerContracte.adaugaVersiune(contract.salvare());

		//recuperare versiuni anterioare
		contract.refacereVersiuneContractAnterior
		(managerContracte.recuperareVersiune(0));
		System.out.println(contract);
	}

}
-------------
public class VersiuneContract {
	private String clauzeContractuale;

	public VersiuneContract() {
		this.clauzeContractuale = "";
	}

	public VersiuneContract(String clauzeContractuale) {
		this.clauzeContractuale = clauzeContractuale;
	}

	public String getClauzeContractuale() {
		return clauzeContractuale;
	}

}
=======================
ADAPTER
public class AdapterClient extends EvaluareClientFirmaA
	implements IEvaluareClientFirmaB{

	public int costTotalEvenimente(Client client){
		int costTotalEvenimente = 0;
		for(int i=0; i<client.getNrEvenimente(); i++)
			costTotalEvenimente += client.getCostEvenimente()[i];
		return costTotalEvenimente;
	}

	@Override
	public void analizaClientFirmaB(Client client) {
		System.out.println("Metoda analiza client Firma B");
		this.analizaClientFirmaA(costTotalEvenimente(client));

	}
}

------------------
public class Client {
	private String numeClient;
	private int nrEvenimente;
	private int[] costEvenimente;

	public Client(String numeClient, int nrEvenimente,
			int[] costEvenimente) {
		this.numeClient = numeClient;
		this.nrEvenimente = nrEvenimente;
		this.costEvenimente = costEvenimente;
	}

	public String getNumeClient() {
		return numeClient;
	}

	public int getNrEvenimente() {
		return nrEvenimente;
	}

	public int[] getCostEvenimente() {
		return costEvenimente;
	}

}
-------------------
public class EvaluareClientFirmaA implements IEvaluareClientFirmaA{

	@Override
	public void analizaClientFirmaA(int costTotalEvenimente) {
		System.out.println("Metoda analiza client Firma A");
		double procentDiscount = 0;

		if(costTotalEvenimente > 1000)
			procentDiscount = 0.10;
		else
			if(costTotalEvenimente >500)
				procentDiscount = 0.05;
			else procentDiscount = 0.00;
		System.out.println("S-a oferit un discount de "+
			procentDiscount);
	}
}


------------
public interface IEvaluareClientFirmaA {
	void analizaClientFirmaA(int costTotalEvenimente);
}

-------------
public interface IEvaluareClientFirmaB {
	void analizaClientFirmaB(Client client);
}

-----------
public class TestAdapter {

	public static void main(String[] args) {
		int[] costEvenimente = new int[]{1000,2000,20000,1000,5000};
		Client client = new Client("XYZ", 5, costEvenimente);
		IEvaluareClientFirmaB evaluareClientB = new AdapterClient();
		evaluareClientB.analizaClientFirmaB(client);

	}

}
===================
PROTOTYPE

import java.util.ArrayList;

public class ContractCorporate extends ContractEveniment{

	public ContractCorporate(){
		System.out.println("Incarcare contract corporate");
		listaClauze = new ArrayList<>(3);
		this.tip = "corporate";
	}

	@Override
	void printare() {
		System.out.println("Contract de tip "+ this.tip);
	}

}
---------


import java.util.ArrayList;

public abstract class ContractEveniment implements Cloneable{
	private String id;
	protected String tip;
	protected ArrayList<String> listaClauze;

	public String showListaClauze(){
		String rez = "Start ";
		for(int i=0 ; i<listaClauze.size(); i++)
			rez += listaClauze.get(i) + " ";
		return rez;
	}

	public void modifListaClauze(int i, String clauzaNoua){
		listaClauze.set(i, clauzaNoua);
	}

	abstract void printare();

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}

	public String getTip() {
		return tip;
	}

	public ArrayList<String> getListaClauze() {
		return listaClauze;
	}

	@Override
	public String toString() {
		return "ContractEveniment [id=" + id + ", tip=" + tip + "]";
	}

	@Override
	public ContractEveniment clone()
	{
		Object clone = null;
		try {
			clone = super.clone();
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}

		return (ContractEveniment) clone;
	}

}


------------------


import java.util.ArrayList;

public class ContractParty extends ContractEveniment{


	public ContractParty() {
		System.out.println("Incarcare contract party");
		listaClauze = new ArrayList<>();
		listaClauze.add("clauza 1");
		listaClauze.add("clauza 2");
		this.tip = "party";
	}

	@Override
	void printare() {
		System.out.println("Contract de tip " + this.tip);
	}

	@Override
	public ContractEveniment clone() {
		ContractEveniment clone = super.clone();
		clone.listaClauze = new ArrayList<>();
		for(int i=0; i<this.listaClauze.size(); i++){
			clone.listaClauze.add(this.listaClauze.get(i));
		}

		return clone;
	}



}

--------------

import java.util.HashMap;

public class PrototypeFactory {
	private static HashMap<String, ContractEveniment> prototipuriContracte = new HashMap<>();

	static {
		System.out.println("Initializare contracte");

		ContractEveniment contractParty = new ContractParty();
		prototipuriContracte.put("party", contractParty);

		ContractEveniment contractCorporate = new ContractCorporate();
		prototipuriContracte.put("corporate", contractCorporate);
	}

	public static ContractEveniment getPrototipContract(String id) {
		ContractEveniment contractEveniment = null;
		ContractEveniment prototipContract = prototipuriContracte.get(id);
		if(prototipContract != null)
			contractEveniment = prototipContract.clone();
		return contractEveniment;
	}
}

------------------

public class TestPrototype {

	public static void main(String[] args) {
		ContractCorporate contractCorporate1 = new ContractCorporate();
		contractCorporate1.setId("1");
		System.out.println(contractCorporate1);

		ContractCorporate contractCorporate2 = new ContractCorporate();
		contractCorporate2.setId("2");
		System.out.println(contractCorporate2);

		ContractEveniment contractCorporate3 = PrototypeFactory.getPrototipContract("party");
		if(contractCorporate3 != null) {
			contractCorporate3.setId("3");
			System.out.println(contractCorporate3);
		}

		System.out.println(contractCorporate3.showListaClauze());
		contractCorporate3.modifListaClauze(0, "New");

		ContractEveniment contractCorporate4 = PrototypeFactory.getPrototipContract("party");
		if(contractCorporate4 != null){
			contractCorporate4.setId("4");
			System.out.println(contractCorporate4);
		}
		System.out.println(contractCorporate4.showListaClauze());

		//testare shallow-copy fara Prototype
		System.out.println("\nTestare shallow-copy fara Prototype");
		if(contractCorporate1.getListaClauze() == contractCorporate2.getListaClauze())
			System.out.println("Aceleasi clauze contractuale");
		else
			System.out.println("Referinte la obiecte diferite");

		//testare shallow-copy cu Prototype
		System.out.println("Testare shallow-copy cu Prototype");
		if(contractCorporate3.getListaClauze() == contractCorporate4.getListaClauze())
			System.out.println("Aceleasi clauze contractuale");
		else
			System.out.println("Referinte la obiecte diferite");

	}

}
=======================
BUILDER

public class Bucatar {
	private PizzaBuilder pizzaBuilder;

	public void setPizzaBuilder(PizzaBuilder pizzaBuilder) {
		this.pizzaBuilder = pizzaBuilder;
	}

	public Pizza getPizza(){
		return pizzaBuilder.getPizza();
	}

	public void construiestePizza(){
		pizzaBuilder.createPizza();
		pizzaBuilder.buildBlat();
		pizzaBuilder.buildSos();
		pizzaBuilder.buildTopping();
	}
}


---------------
public class ConcreteBuilder1 extends PizzaBuilder{

	@Override
	void buildBlat() {
		pizza.setBlat("Blat basic");
	}

	@Override
	void buildSos() {
		pizza.setSos("dulce");
	}

	@Override
	void buildTopping() {
		pizza.setTopping("branza, rosii");
	}

}

------------------
public class ConcreteBuilder2 extends PizzaBuilder{

	@Override
	void buildBlat() {
		pizza.setBlat("Blat basic");
	}

	@Override
	void buildSos() {
		pizza.setSos("dulce, iute");
	}

	@Override
	void buildTopping() {
		pizza.setTopping("branza, rosii, ardei, sunca");
	}
}
---------------
public class Pizza {
	//componente obiect complex
	private String blat = "";
	private String sos = "";
	private String topping = "";

	public void setBlat(String blat) {
		this.blat = blat;
	}

	public void setSos(String sos) {
		this.sos = sos;
	}

	public void setTopping(String topping) {
		this.topping = topping;
	}

	@Override
	public String toString() {
		return "Pizza [blat=" + blat + ", sos=" + sos + ", topping=" + topping
				+ "]";
	}

}
--------------
public abstract class PizzaBuilder {
	//obiectul care trebuie creat
	protected Pizza pizza;

	public Pizza getPizza(){
		return this.pizza;
	}

	public void createPizza(){
		pizza = new Pizza();
	}

	/*metode abstracte pentru a fi particularizate concret
	 in Builder Concrete
	 */
	abstract void buildBlat();
	abstract void buildSos();
	abstract void buildTopping();
}


--------------
public class TestBuilder {

	public static void main(String[] args) {
		Bucatar bucatar = new Bucatar();
		PizzaBuilder pb1 = new ConcreteBuilder1();
		PizzaBuilder pb2 = new ConcreteBuilder2();
		bucatar.setPizzaBuilder(pb1);
		bucatar.construiestePizza();

		Pizza pizza1 = bucatar.getPizza();
		bucatar.setPizzaBuilder(pb2);
		bucatar.construiestePizza();
		Pizza pizza2 = bucatar.getPizza();

		System.out.println("Concrete Builder 1");
		System.out.println(pizza1 + "\n" + pizza2);

		bucatar.setPizzaBuilder(pb2);
		bucatar.construiestePizza();

		Pizza pizza3 = bucatar.getPizza();
		System.out.println("\nConcrete Builder 2");
		System.out.println(pizza3);
	}

}
===================