Sunteți pe pagina 1din 20

Ministerul Educației al Republicii Moldova

Universitatea Tehnică a Moldovei

Facultatea Calculatoare, Informatica și Micorelectronică

Catedra Automatica și Tehnologii Informaționale

Raport

Lucrarea de laborator nr. 1

La disciplina: Ingineria Produselor Program


Tema: Șabloane creaționale

A efectuat: st.gr.TI132 Primblas Alexandru

A verifica: lector asistent Ciudin Sergiu

Chișinău 2016
Scopul și sarcina
De studiat și de implimentat șabloane creationale Abstract Factory, Singleton, Prototype, Builder,
Factory Method.

Noțiuni Teoretice
Șabloanele creaționale de proiectare, abstractizeaza procesul de instanțiere. Ele ajuta de a face un
system independent de modul in care sunt create compuse si reprezentate obiectele acestuia. Un șablon
creațional de clasa folosește moștenirea pentru a varia clasa care este instantiată, in timp ce un șablon
creational de obiect va delega instanțierea către un alt obiect.

Șabloanele creaționale devin din ce în ce mai importante, pe măsura ce sistemele evolueaza spre a
depinde mai mult de compunerea obiectelor decat de moștenirea de clasă. Prin urmare, crearea obiectelor
cu un anumit comportament va necesita mai mult decăt simpla insțantiere a unei clase.

Abstract Factory
Abstract Factory furnizează un nivel de abstractizare în crearea de familii de obiecte înrudite sau
dependente fără a specifica direct clasele lor concrete. Obiectul „fabrică“ are responsabilitatea de a oferi
servicii pentru crearea unei întregi familii de platforme. Clienții nu vor crea niciodată platforme în mod
direct, ci vor apela la „fabrică“ pentru a face acest lucru.

Acest mecanism face schimbarea familiilor de produse mai simplă deoarece clasa concretă de tip
factory apare o singură dată în aplicație, atunci când este instanțiată. Aplicația poate înlocui întreaga familie
de produse prin simpla instanțiere a unei alte clase concrete de tipul abstract factory.

Patternul Abstract Factory va defini o metodă Factory la nivel de produs. Fiecare astfel de metodă va
încapsula operatorul new precum și implementarea concretă a produsului. Fiecare „platformă“ este apoi
modelată folosind o clasă de tip Factory, derivată.

Abstract Factory are urmatoarele avanaje:

 utilizeaza clase concrete


 simplifica schimbul famiilor de produse
 asigura compatibiliatea produselor
Dezavantaje:
 este dificil de a aduga suport pentru noi tipuri de produse
În aceasta figura este reprezentată diagrama de clasă pentru șablonul Abstract Factory
class AbstractFactory

«interface»
AbstracFabrica
+ AbstractFactory.Avion createAvion();
+ Masina createMasina()

ProduceAutoMobileMari ProduceAutoMobileMici

+ createAvion() : AvionMare + createAvion() : AvionMic


+ createMasina() : AutoMobilMare + createMasina() : AutoMobilMic

Av ion
Class3
Masina - aaltitudine: int
- culoare: char
- culoare: char - viteza: int
- viteza: int
+ ArataCaracteristi() : String
+ ArataCaracteristi() : char + getAltitudine() : int
+ getCuloare() : char + getCuloare() : char
+ getViteza() : int + getViteza() : int

AutoMobilMare Av ionMare AutoMobilMic Av ionMic


- capacitatea: int - denumire: String - capacitate: int - denumire: String
- denumire: String - denumire: String
+ ArataCaracteristi() : String + ArataCaracteristi() : String
+ ArataCaracteristi() : String
+ ArataCaracteristi() : String

Fig.1 Abstract Factory

Factory Method
Șablonul definește o interfața pentru crearea unui obiect, dar permite subclaselor să decidă ce clasa
vor instanția. De asemenea acest șablon permite unei clase sa delege instanțierea la alte subclase.

Cadrele de dezvoltare utilizeaza clase abstracte pentru a define si intreține relațiile între obiecte.
Deseori, un cadru de dezvoltare este de asemenea responsabil și de crearea acestor obiecte.

Șablonul Factory Method incapsulează cunoașterea tipului de subclasa Document care va fi creat și
scoate aceasta cunoaștere din cadrul de dezvoltare. Subclasele Application redefines operatia abstractă
CreateDocument a clasei Application, astfel incat aceasta sa returneze subclasa Document corecta.

Șablonul Factory Method se utilizeaza cînd:

 O clasă nu poate anticipa clasa obiectelor pe care trebuie să le creeze


 O clasa dorește ca subclasele sale sa precizeze obiectele pe care le creeaza
 Clasele deleaga responsabilitatea către una dintre mai multe subclase ajutatoare, de asemenea
duce contul subclasei ajutatoare delegate

Avanataje:

 Permite crearea codului mult mai universal, adică obiectul să nu fie legat de anumite clase, si care
functioneaza cu o interfaîa comună.

Dejavantaje:

 Creatorul trebuie să creeze un nou moștenitor pentru fiecare tip de produs (ConcreteProduct).
Cu toate acestea, limbaje de programare moderne permit relizarea șablonui Fabrica fară
ierarhizare claselor Creator.

În aceasta figură este reprezentată diagrama de clase pentru șablonul Factory Method
class FactoryMethod

«interface»
«interface»
AutoMobilMare
ProduceAutomobile
+ ArataCaracteristici() : String
+ createAutoMobilMare(String) : AutoMobilMare

ProduceAutoMobileMari

+ createAutoMobilMare(String) : Volvo
+ createAutoMobilMare() : Mercedes

Volv o Mercedes

- capaciate: String - capacitate: String


- culoare: String - culoare: String
- denumire: String - denumire: String
- viteza: String - viteza: String

+ ArataCaracteristici() : String + ArataCaracteristici() : String


+ createAutoMobilMare(String) : AutoMobilMare

Fig.2 Factory Methode

Singleton
În inginerie software, modelul Singleton este un model de design care restricționează instanțierea
unei clase la un singur obiect. Acest lucru este util atunci când este nevoie de exact un obiect pentru a
coordona acțiunile în cadrul sistemului. Conceptul este uneori generalizat la sisteme care funcționează mai
eficient atunci când există un singur obiect, sau care limitează instanțierea unui anumit număr de obiecte.
Sunt unii care sunt critici fața de model Singleton și consideră că acesta este un anti-model, care este
frecvent utilizat în scenarii în cazul în care aceasta nu este benefic, introduce restricții inutile în situații în
care nu este necesară, de fapt o instanță exclusivă a unei clase, și introduce starea globală într-o aplicație.

O implementare a modeluli Singleton trebuie sa ne asigure cu:

 Să asigure că o instanța a clasei sinleton exista și oferă acces global la acea instanță.

Acest lucru se realizează prin: constructorii sa fie private, oferind o metoda statică care returneaza o
referința la instanta.

Instanța este stocată, de obicei ca o variabilă statică privată; instanța este creată atunci când variabila este
inițializat, la un moment dat, înainte de metoda statică este solicitată. Ceea ce urmează este o implementare de a
șablonului singleton în Java. În acest exemplu, initializatorul statică este rulat atunci când clasa este inițializat, după
clasa de încărcare, dar înainte de clasa este utilizat de orice tip de fir.

Figura repezintă diagrama de clasa pentru șablonul singleton

class Singleton

Av ion

- altitudine: int
- Avion: Avion
- culoare: String
- dnumire: String
- nrLocuri: int

+ afiseazaCarateristica() : String
+ getInstance() : Avion

Fig.3 Singleton

Builder Pattern

Șablonul Builder determină un algoritm care separă faza de proiectare a produsului complex, (obiect)
al reprezentării sale externe, astfel încât, prin intermediul aceluiași algoritm poate se obține puncte de
vedere diferite ale produsului. Pentru acesta, șablonul Builder determină un algoritm de crearea treptată a
unui produs într-o clasă specială de director (manager) și responsabil pentru coordonarea procesului de
asamblare a părților individuale ale produsului impune ierarhiei clasei Builder. În această ierarhie, in
șablonul Builder, clasa de bază anunță interfețe pentru construirea părților ale produsului și subclasele
relevante ConcreteBuilder le pune în aplicare în mod adecvat, de exemplu, să creeze sau să obțină resursele
necesare pentru a menține rezultatele intermediare, de a monitoriza rezultatele operațiunilor.
Diagrama de clasă petnru șablonul Builder.

class BuiilderPatern

AutoMobil
«interface»
AutoMobilBuilder - capacitate: int
AutoMobilDirector
+ caracteristica() : AutoMobil - culoare: String
- builder: AutoMobilBuilder + setCapacitate(int) : void - denumire: String
+ setCuloare(String) : void - nrUsi: int
+ construct() : AutoMobil + setDenumire(String) : void
+ setNrUsi(int) : void + caracteristica() : AutoMobil
+ getDenumire() : String
+ setCapacitate(int) : void
+ setCuloare(String) : void
+ setDenumire(String) : void
+ setNrUsi(int) : void

AutoMobilMare

- autoMobil: AutoMobil

Fig.4 Builder Patern

Șablonul Prototype
Acest șablon creaza obiectele clonînd un obiect existent. Șablonul acesta poate fi utilizat atunci cind
sistemul ar trebui sa fie independent de modul in care sunt create produsele sale.

Șablonul Prototype se utilieaza în urmatoarele cazuri:

 Atunci cînd un anumit tip de obiecte care urmează a fi create, clasele care desfinesc aceste
obiecte sunt create in mod dinamic.
 Atunci cind se dorește creare unei ierahii de clase separată de clasele factory.
 În cazul cînd clonarea unui obiect este opțiunea cea mai perfectă, mai degraba chiar și de cît
constuctorul. De asemena cînd obiectul poate accepta un număr mic de stări posibile.
Diagrama de clasă pentru șablonul Prototype.

class PrototypePatern

«interface»
CloneFactory
AutoMobil
+ getClone(AutoMobil) : AutoMobil + makeCopy() : AutoMobil

Mercedes

+ makeCopy: AutoMobil

Fig.5 Prototype Pattern


Concluzie

În acestă lucrare de laborator am studiat șabloanele de proiectare. Fiecare șablon descrie o problemă
care apare in domeniul de acivitate și indică soluția acelei probleme intr-un mod care permite reutilizarea
acestei soluții de nenumarate ori în contexte diferite. Un șablon reprezintă o solutie comuna a unei probleme
într-un anumit context. Un șablon nu este o clasa sau o librărie, el este un model care trebuie impelmenta
în situația corectă. De asemena șabloanele nu sunt specififie unui anumit limbaj.
Anexa A

Abstract_Factory
package AbstractFactory;

/**
* Created by nicolae on 28.10.2016.
*/
public interface AbstracFabrica {
Masina createMasina();
AbstractFactory.Avion createAvion();
}

package AbstractFactory;

/**
* Created by nicolae on 28.10.2016.
*/
public class AutoMobilMare extends Masina {
private String denumire;
private int capacitatea;

public AutoMobilMare(int viteza, String culoare, String denumire, int capacitate)


{
super(viteza, culoare);
this.denumire = denumire;
this.capacitatea = capacitate;
}

@Override
public String ArataCaracteristi() {
return denumire + ", " + capacitatea + ", "
+ getViteza() + ", " + getCuloare();
}
}
package AbstractFactory;

/**
* Created by nicolae on 28.10.2016.
*/
public class AutoMobilMic extends Masina {
private String denumire;
private int capacitatea;
public static final String SPACE = ", ";

public AutoMobilMic(String denumire, int capacitatea, int viteza, String culoare)


{
super(viteza, culoare);
this.denumire = denumire;
this.capacitatea = capacitatea;
}

@Override
public String ArataCaracteristi() {
return denumire + SPACE + capacitatea + ", "
+ getCuloare() + ", " + getViteza();
}

}
package AbstractFactory;

/**
* Created by nicolae on 28.10.2016.
*/
public abstract class Avion {
private int viteza;
private String culoare;
int altitudine;

public Avion(int viteza, String culoare, int altitudine) {


this.viteza = viteza;
this.culoare = culoare;
this.altitudine = altitudine;
}

public int getViteza() {


return viteza;
}

public String getCuloare() {


return culoare;
}

public int getAltitudine() {


return altitudine;
}

public abstract String ArataCaracteristi();

}
package AbstractFactory;

/**
* Created by nicolae on 28.10.2016.
*/
public class AvionMare extends Avion {
private String denumire;

public AvionMare(int viteza, String culoare, int altitudine, String denumire) {


super(viteza, culoare, altitudine);
this.denumire = denumire;
}

@Override
public String ArataCaracteristi() {
return denumire + ", " + getViteza()+ ", "
+ getCuloare()+ ", " + getAltitudine();
}
}
package AbstractFactory;

/**
* Created by nicolae on 28.10.2016.
*/
public class AvionMic extends Avion {
private String denumire;

public AvionMic(int viteza, String culoare, int altitudine, String denumire) {


super(viteza, culoare, altitudine);
this.denumire = denumire;
}
@Override
public String ArataCaracteristi() {
return denumire + ", " + getViteza()+ ", "
+ getCuloare()+ ", " + getAltitudine();
}
}
package AbstractFactory;

/**
* Created by nicolae on 28.10.2016.
*/
public abstract class Masina {
private int viteza;
private String culoare;

public Masina(int viteza, String culoare) {


this.viteza = viteza;
this.culoare = culoare;
}

public int getViteza() {


return viteza;
}

public String getCuloare() {


return culoare;
}

public abstract String ArataCaracteristi();


}
package AbstractFactory;

import static java.lang.System.out;

/**
* Created by nicolae on 28.10.2016.
*/
public class ProduceAutoMobileMari implements AbstracFabrica{
@Override
public Masina createMasina() {
out.print("Fabrica de producere a automobilelor: ");
return new AutoMobilMare(80, "Rosie", "Volvo", 500);
}

@Override
public Avion createAvion() {
out.print("Fabrica de producere a avioanelor: ");
return new AvionMare(200, "ALba", 5000, "AirBus");
}
}
package AbstractFactory;

import static java.lang.System.out;

/**
* Created by nicolae on 28.10.2016.
*/
public class ProduceAutoMobileMici implements AbstracFabrica{
@Override
public Masina createMasina() {
out.print("Fabrica de producere a automobilelor: ");
return new AutoMobilMic("Lada", 20, 120, "Neagra");
}

@Override
public Avion createAvion() {
out.print("Fabrica de producere a avioanelor: ");
return new AvionMic(50, "Albastra/Rosie", 500, "Tu-40");
}
}
Anexa B

Builder_Patter
package BuilderPattern;

/**
* Created by nicolae on 28.10.2016.
*/
public class AutoMobil {
private int nrUsi;
private String culoare;
private int capacitate;
private String denumire;

public String getDenumire() {


return denumire;
}

public void setDenumire(String denumire) {


this.denumire = denumire;
}

public void setNrUsi(int nrUsi) {


this.nrUsi = nrUsi;
}

public String getCuloare() {


return culoare;
}

public void setCuloare(String culoare) {


this.culoare = culoare;
}

public void setCapacitate(int capacitate) {


this.capacitate = capacitate;
}

public String toString() {


return "Automobilul: " + denumire + ", "
+ culoare + ", " + nrUsi + ", " +capacitate;
}
}
package BuilderPattern;

/**
* Created by nicolae on 28.10.2016.
*/
public interface AutoMobilBuilder {
void setDenumire(String denumire);
void setNrUsi(int nrUsi);
void setCuloare(String culoare);
void setCapacitate(int capacitate);

AutoMobil caracteristica();

}
package BuilderPattern;

/**
* Created by nicolae on 28.10.2016.
*/
public class AutoMobilDirector {
private AutoMobilBuilder builder;

public AutoMobilDirector(AutoMobilBuilder builder) {


this.builder = builder;
}

public AutoMobil construct() {


builder.setDenumire("Mercedes");
builder.setCuloare("Rosie");
builder.setCapacitate(40);
builder.setNrUsi(4);
return builder.caracteristica();
}
}
package BuilderPattern;

/**
* Created by nicolae on 28.10.2016.
*/
public class AutoMobilMare implements AutoMobilBuilder {
private AutoMobil autoMobil;

public AutoMobilMare() {
autoMobil = new AutoMobil();
}

@Override
public void setDenumire(String denumire) {
autoMobil.setDenumire(denumire);
}

@Override
public void setNrUsi(int nrUsi) {
autoMobil.setNrUsi(nrUsi);
}

@Override
public void setCuloare(String culoare) {
autoMobil.setCuloare(culoare);
}

@Override
public void setCapacitate(int capacitate) {
autoMobil.setCapacitate(capacitate);
}

@Override
public AutoMobil caracteristica() {
return autoMobil;
}
}
Anexa C
FactoryMethode

package FactoryMethod;

/**
* Created by nicolae on 28.10.2016.
*/
public interface AutoMobilMare {
String ArataCaracteristici();

}
package FactoryMethod;

/**
* Created by nicolae on 28.10.2016.
*/
public class Mercedes implements AutoMobilMare {
private String denumire;
private String culoare;
private String capacitate;
private String viteza;

public Mercedes(String denumire, String culoare, String capacitate, String


viteza) {
this.denumire = denumire;
this.culoare = culoare;
this.capacitate = capacitate;
this.viteza = viteza;
}

@Override
public String ArataCaracteristici() {
return "Automobilul: " + denumire + ", "
+ culoare + ", " + capacitate + ", " + viteza;

}
}
package FactoryMethod;

/**
* Created by nicolae on 28.10.2016.
*/
public interface ProduceAutomobile {
AutoMobilMare createAutoMobilMare(String denumire);
}

package FactoryMethod;

import java.util.InputMismatchException;

/**
* Created by nicolae on 28.10.2016.
*/
public class ProduceAutoMobileMari implements ProduceAutomobile {
@Override
public AutoMobilMare createAutoMobilMare(String denumire) {
if (denumire.equals("Volvo")) {
return new Volvo("Volov", "Alba", "20 Tone", "152 KM");
}
if (denumire.equals("Mercedes")) {
return new Mercedes("Mercedes", "Neagrea", "25 Tone", "140 Km");
}
throw new InputMismatchException("Nu exisata asa marca de Automobile: "
+denumire);
}
}
package FactoryMethod;

/**
* Created by nicolae on 28.10.2016.
*/
public class Volvo implements AutoMobilMare {
private String denumire;
private String culoare;
private String capacitate;
private String viteza;

public Volvo(String denumire, String culoare, String capacitate, String viteza) {


this.denumire = denumire;
this.culoare = culoare;
this.capacitate = capacitate;
this.viteza = viteza;
}

@Override
public String ArataCaracteristici() {
return "Automobilul: " + denumire + ", "
+ culoare + ", " + capacitate + ", " + viteza;

}
}
Anexa D
Prototype Patern
package PrototypePattern;

/**
* Created by nicolae on 28.10.2016.
*/
public interface AutoMobil extends Cloneable {
AutoMobil makeCopy();
}
package PrototypePattern;

/**
* Created by nicolae on 28.10.2016.
*/
public class CloneFactory {

public AutoMobil getClone(AutoMobil autoMobil) {


return autoMobil.makeCopy();
}
}
package PrototypePattern;

/**
* Created by nicolae on 28.10.2016.
*/
public class Mercedes implements AutoMobil {
public AutoMobil makeCopy() {
System.out.println("Mercedes...");
Mercedes sheepObject = null;
try {
sheepObject = (Mercedes) super.clone();
}
catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return sheepObject;
}
public String toString(){
return "Automobil Mercedes";
}
}
Anexa E

Singletone
package Singleton;

/**
* Created by nicolae on 28.10.2016.
*/
public class Avion {
private String denumire;
private int nrLocuri;
private String culoare;
private int altitudine;
private static Avion avion;

private Avion(String denumire, int nrLocuri, String culoare, int altitudine) {


this.denumire = denumire;
this.nrLocuri = nrLocuri;
this.culoare = culoare;
this.altitudine = altitudine;
}
public static Avion getInstance() {
if (avion == null) {
avion = new Avion("AirBus", 200, "Alba", 2000);
}
return avion;
}
public String afiseazaCarateristica() {
return "Avionul: " + denumire + ", " + nrLocuri + ", "
+ culoare + ", " + altitudine;
}
}
Anexa F

MainClass
package MainClass;

import AbstractFactory.*;
import BuilderPattern.AutoMobilBuilder;
import AbstractFactory.*;
import AbstractFactory.Avion;
import BuilderPattern.*;
import BuilderPattern.AutoMobilMare;
import FactoryMethod.ProduceAutomobile;
import PrototypePattern.CloneFactory;
import PrototypePattern.Mercedes;
//import FactoryMethod.ProduceAutomobile;
//import Singleton.*;

import static java.lang.System.out;

import static java.lang.System.out;

/**
* Created by nicolae on 28.10.2016.
*/
public class MainClass {
public static void main(String[] args) {
AbstracFabrica abstracFabrica = new ProduceAutoMobileMari();
out.print("Abstract Factory Design Pattern. "); // Abstract Factory Design
Pattern.
out.println("Producator automobile/avioane Mari.....");
ArataProducatoriMasini(abstracFabrica);
out.print("\n");
out.print("Abstract Factory Pattern. ");
out.println("Producator automobile/avioane Mici.....");
abstracFabrica = new ProduceAutoMobileMici();
ArataProducatoriMasini(abstracFabrica);

out.print("\n"); // Factory Method Design Pattern


out.println("Factory Method Pattern.....");
ProduceAutomobile automobile = new FactoryMethod.ProduceAutoMobileMari();
FactoryMethod.AutoMobilMare mobilMare =
automobile.createAutoMobilMare("Volvo");
out.println(mobilMare.ArataCaracteristici());
mobilMare = automobile.createAutoMobilMare("Mercedes");
out.println(mobilMare.ArataCaracteristici());

out.print("\n");
out.println("Builder Pattern....."); // Builder pattern
AutoMobilBuilder builder = new AutoMobilMare();
AutoMobilDirector autoMobilDirector = new AutoMobilDirector(builder);
out.print(autoMobilDirector.construct());

out.println("\n");
out.println("Singleton Pattern..... "); //Singleton Pattern
Singleton.Avion avion = Singleton.Avion.getInstance();
out.print(avion.afiseazaCarateristica());

out.println("\n");
out.println("Prototype Pattern..."); // Prototype Pattern
CloneFactory factory = new CloneFactory();
Mercedes mercedes = new Mercedes();
Mercedes clonedSheep = (Mercedes) factory.getClone(mercedes);
System.out.println(mercedes);
System.out.println(clonedSheep);
}

private static void ArataProducatoriMasini(AbstracFabrica abstracFabrica) {


Masina masina = abstracFabrica.createMasina();
out.println(masina.ArataCaracteristi());

Avion avion = abstracFabrica.createAvion();


out.println(avion.ArataCaracteristi());
}