Шаблони проектування
Abstract factory (Абстрактна фабрика)
Abstract factory (Абстрактна фабрика) - Шаблон проектування, що дозволяє змінювати поведінку системи, варіюючи створювані об'єкти, при цьому зберігаючи інтерфейси. Він дозволяє створювати цілі групи взаємопов'язаних об'єктів, які, будучи створеними однією фабрикою, реалізують загальну поведінку. Шаблон реалізується створенням абстрактного класу Factory, який представляє собою інтерфейс для створення компонентів системи (Наприклад, для віконного інтерфейсу, він може створювати вікна і кнопки). Потім пишуться спадщини від нього класи, що реалізують цей інтерфейс.
Мета
Надає інтерфейс для створення сімейств взаємопов'язаних або взаємозалежних об'єктів, не спеціфіціруя їх конкретних класів
Плюси
ізолює конкретні класи;
спрощує заміну сімейств продуктів;
гарантує сполучуваність продуктів.
Мінуси
складно додати підтримку нового виду продуктів.
Застосовність
Система не повинна залежати від того, як створюються, компонуються і представляються входять до неї об'єкти; Вхідні в сімейство взаємопов'язані об'єкти повинні використовуватися разом і вам необхідно забезпечити виконання цього обмеження; Система повинна конфігуруватися одним із сімейств складових її об'єктів; вимагається надати бібліотеку об'єктів, розкриваючи тільки їхні інтерфейси, але не реалізацію.
Приклад C + +
p>
# include
// AbstractProductA
class ICar
{
public:
virtual void info () = 0;
}
// ConcreteProductA1
class Ford: public ICar
{
public:
virtual void info ()
{
std :: cout <<"Ford" <
}
};
// ConcreteProductA2
class Toyota: public ICar
{
public:
virtual void info ()
{
std :: cout <<"Toyota" <
}
};
// AbstractProductB
class IEngine
{
public:
< p> virtual void getPower () = 0;
};
// ConcreteProductB1
class FordEngine: public IEngine
{
public:
virtual void getPower ()
{
std :: cout <<"Ford Engine 4.4" <
}
};
// ConcreteProductB2
class ToyotaEngine: public IEngine
{
public:
virtual void getPower ()
{
std :: cout << "Toyota Engine 3.2" <
}
};
// AbstractFactory
class CarFactory
{
public:
ICar * getNewCar ()
{
return createCar ()
}
IEngine * getNewEngine ()
{
return createEngine ();
}
protected:
virtual ICar * createCar () = 0;
virtual IEngine * createEngine () = 0;
};
// ConcreteFactory1
class FordFactory: public CarFactory
{
protected:
// from CarFactory
virtual ICar * createCar ()
{
return new Ford ();
}
virtual IEngine * createEngine ()
{
return new FordEngine ();
}
};
//ConcreteFactory2
class ToyotaFactory: public CarFactory
{
protected:
// from CarFactory
virtual ICar * createCar ()
{
return new Toyota ();
}
virtual IEngine * createEngine ()
{
return new ToyotaEngine ();
}
};
int main ()
{
CarFactory * curFactory = NULL;
ICar * myCar = NULL;
IEngine * myEngine = NULL;
ToyotaFactorytoyotaFactory;
FordFactoryfordFactory;
curFactory = & toyotaFactory;
myCar = curFactory-> getNewCar ();
myCar- > info ();
myEngine = curFactory-> getNewEngine ();
myEngine-> getPower ();
delete myCar;
delete myEngine;
curFactory = & fordFactory;
myCar = curFactory-> getNewCar ();
myCar-> info ();
myEngine = curFactory-> getNewEngine ();
myEngine-> getPower ();
delete myCar;
< p> delete myEngine;
return 0;
}
Builder (Будівник) - шаблон проектування, що породжує об'єкти.
Мета
Відокремлює конструювання складного об'єкта від його представлення, так що в результаті одного і того ж процесу конструювання можуть виходити різні уявлення.
Плюси
дозволяє змінювати внутрішнє представлення продукту;
ізолює код, реалізує конструювання та уявлення;
дає більш тонкий контроль над процесом конструювання.
Застосування
алгоритм створення складного об'єкта не повинен залежати від того, з яких частин складається об'єкт і як вони стикуються між собою;
процес конструювання повинен забезпечувати різні уявлення конструируемого об'єкта.
Приклад на C + +
# include
# include
# include
// Product
< p> class Pizza
{
private:
std :: string dough;
std :: string sauce;
std :: string topping;
public:
Pizza () {}
~ Pizza () {}
void SetDough (const std :: string & d) {dough = d;};
void SetSauce (const std :: string & s) {sauce = s;};
void SetTopping (const std :: string & t) {topping = t;}
void ShowPizza ()
{
std :: cout < <"Yummy!" <
<<"Pizza with Dough as" <
< ; <", Sauce as" <
<<"and Topping as" <
<<" ;! "<
}
};
// Abstract Builder
class PizzaBuilder
{
protected:
std :: auto_ptr pizza;
public:
PizzaBuilder () {}
virtual ~ PizzaBuilder () {}
std :: auto_ptr GetPizza () {return pizza;}
void createNewPizzaProduct () { pizza.reset (new Pizza);}
virtual void buildDough () = 0;
virtual void buildSauce () = 0;
virtual void buildTopping ( ) = 0;
};
// ConcreteBuilder
class HawaiianPizzaBuilder: public PizzaBuilder
{
public:
HawaiianPizzaBuilder (): PizzaBuilder () {}
~ HawaiianPizzaBuilder () {}
void buildDough () {pizza-> SetDough (" ; cross ");}
void buildSauce () {pizza-> SetSauce (" mild ");}
void buildTopping () {pizza-> SetTopping (" ; ham and pineapple ");}
};
// ConcreteBuilder
class SpicyPizzaBuilder: public PizzaBuilder
{
public:
SpicyPizzaBuilder (): PizzaBuilder () {}
~ SpicyPizzaBuilder () {}
void buildDough () {pizza-> ; SetDough ("pan baked");}
void buildSauce () {pizza-> SetSauce ("hot");}
void buildTopping () {pizza- > SetTopping ("pepperoni and salami");}
};
// Director
class Waiter
{
private:
PizzaBuilder * pizzaBuilder;
public:
Waiter (): pizzaBuilder (NULL) {}
< p> ~ Waiter () {}
void SetPizzaBuilder (PizzaBuilder * b) {pizzaBuilder = b;}
std :: auto_ptr GetPizza () {return pizzaBuilder-> ; GetPizza ();}
void ConstructPizza ()
{
pizzaBuilder-> createNewPizzaProduct ();
pizzaBuilder-> ; buildDough ();
pizzaBuilder-> buildSauce ();
pizzaBuilder-> buildTopping ();
}
}...
