Archive for the ‘Php’ Category.
16 Temmuz 2010, 12:08
Factory method pattern factory objelerini implement eden desing pattern lardır. Elimizde class olmadan o class a ait objelerin oluşturulmasını sağlar.
UML :
Örnek :
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
| abstract class Pizza {
public abstract int getPrice (); // count the cents
}
class HamAndMushroomPizza extends Pizza {
public int getPrice () {
return 850;
}
}
class DeluxePizza extends Pizza {
public int getPrice () {
return 1050;
}
}
class HawaiianPizza extends Pizza {
public int getPrice () {
return 1150;
}
}
class PizzaFactory {
public enum PizzaType {
HamMushroom,
Deluxe,
Hawaiian
}
public static Pizza createPizza (PizzaType pizzaType ) {
switch (pizzaType ) {
case HamMushroom :
return new HamAndMushroomPizza ();
case Deluxe :
return new DeluxePizza ();
case Hawaiian :
return new HawaiianPizza ();
}
throw new IllegalArgumentException("The pizza type " + pizzaType + " is not recognized.");
}
}
class PizzaLover {
/*
* Create all available pizzas and print their prices
*/
public static void main (String args []) {
for (PizzaFactory. PizzaType pizzaType : PizzaFactory. PizzaType. values()) {
System. out. println("Price of " + pizzaType + " is " + PizzaFactory. createPizza(pizzaType ). getPrice());
}
}
} |
Output:
Price of HamMushroom is 850
Price of Deluxe is 1050
Price of Hawaiian is 1150
Php
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
| <?php
abstract class Pizza
{
protected $_price;
public function getPrice ()
{
return $this->_price ;
}
}
class HamAndMushroomPizza extends Pizza
{
protected $_price = 8.5;
}
class DeluxePizza extends Pizza
{
protected $_price = 10.5;
}
class HawaiianPizza extends Pizza
{
protected $_price = 11.5;
}
class PizzaFactory
{
public static function createPizza ($type)
{
$baseClass = 'Pizza';
$targetClass = ucfirst($type).$baseClass;
if (class_exists($targetClass) && is_subclass_of($targetClass, $baseClass))
return new $targetClass;
else
throw new Exception ("The pizza type '$type' is not recognized.");
}
}
$pizzas = array('HamAndMushroom','Deluxe','Hawaiian');
foreach($pizzas as $p) {
printf(
"Price of %s is %01.2f".PHP_EOL ,
$p ,
PizzaFactory ::createPizza($p)->getPrice()
);
}
// Output:
// Price of HamAndMushroom is 8.50
// Price of Deluxe is 10.50
// Price of Hawaiian is 11.50
?> |
Kaynak: wikipedia
09 Temmuz 2010, 09:06
Kullanılan algoritma runtime de sürekli değişiyorsa strategy pattern kullanılması uygun olur. Algoritmalar bir interface ile encapsulate edilerek runtime da değiştirilebilir hale getirilir. Algoritmaları kullanan objenin bu değişiklerden haberi olmaz. Ayrıca başka bir algoritma interface i implement ederek kolayca sisteme eklebilir.
UML :
Java Örneği:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
| //StrategyExample test application
class StrategyExample {
public static void main (String[] args ) {
Context context ;
// Three contexts following different strategies
context = new Context(new ConcreteStrategyAdd ());
int resultA = context. executeStrategy(3, 4);
context = new Context(new ConcreteStrategySubtract ());
int resultB = context. executeStrategy(3, 4);
context = new Context(new ConcreteStrategyMultiply ());
int resultC = context. executeStrategy(3, 4);
}
}
// The classes that implement a concrete strategy should implement this
// The context class uses this to call the concrete strategy
interface Strategy {
int execute (int a, int b );
}
// Implements the algorithm using the strategy interface
class ConcreteStrategyAdd implements Strategy {
public int execute (int a, int b ) {
System. out. println("Called ConcreteStrategyAdd's execute()");
return a + b ; // Do an addition with a and b
}
}
class ConcreteStrategySubtract implements Strategy {
public int execute (int a, int b ) {
System. out. println("Called ConcreteStrategySubtract's execute()");
return a - b ; // Do a subtraction with a and b
}
}
class ConcreteStrategyMultiply implements Strategy {
public int execute (int a, int b ) {
System. out. println("Called ConcreteStrategyMultiply's execute()");
return a * b ; // Do a multiplication with a and b
}
}
// Configured with a ConcreteStrategy object and maintains a reference to a Strategy object
class Context {
private Strategy strategy ;
// Constructor
public Context(Strategy strategy ) {
this. strategy = strategy ;
}
public int executeStrategy (int a, int b ) {
return strategy. execute(a, b );
}
} |
Php Örneği:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
| <?php
class StrategyExample {
public function __construct() {
$context = new Context(new ConcreteStrategyA());
$context->execute();
$context = new Context(new ConcreteStrategyB());
$context->execute();
$context = new Context(new ConcreteStrategyC());
$context->execute();
}
}
interface IStrategy {
public function execute();
}
class ConcreteStrategyA implements IStrategy {
public function execute() {
echo "Called ConcreteStrategyA execute method\n";
}
}
class ConcreteStrategyB implements IStrategy {
public function execute() {
echo "Called ConcreteStrategyB execute method\n";
}
}
class ConcreteStrategyC implements IStrategy {
public function execute() {
echo "Called ConcreteStrategyC execute method\n";
}
}
class Context {
private $strategy;
public function __construct(IStrategy $strategy) {
$this->strategy = $strategy;
}
public function execute() {
$this->strategy->execute();
}
}
new StrategyExample();
?> |
Kaynak: wikipedia
