设计模式（一）简单工厂(创建型)(Java&&PHP)

搜索泥称

　　面向对象设计的基本原则                                                                 

• 单一职责
  系统中的每一个对象应该只有一个单独的职责，所有对象关注的应该是自身职责的完成。
  基本思想：高内聚，低耦合。
  
• 开闭原则
  一个对象对扩展开放，对修改关闭。
  基本思想：对类的改动是通过增加代码进行的，而不是修改现有的代码。
  
• 里氏替换原则
  在任意父类出现的地方，都可以使用子类来替代。
  
• 依赖注入原则
  要依赖于抽象，不要依赖于具体的实现。
  基本思想：在开发中尽量的面向接口编程。
  
• 接口分离原则
  不要去使用一些不需要使用的功能。
  基本思想：一个接口不要提供太多的行为。
  
• 迪米特原则
  一个对象对其他的对象应该尽可能少的了解。
  基本思想：降低耦合。
  
• 优先使用组合而不是继承原则
  基本思想：在复用对象的时候，要优先考虑组合，而不是继承。因为父类的任何改变都可能直接音响子类的
  

　　设计分类                                                                                    

• 创建型模式：创建对象。
  
• 结构行模式：对象的组成及对象的关系。
  
• 行为型模式：对象的行为。对象能够做什么。
  

　　简单工厂模式                                                                                 
　　简单工厂模式是指专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。

　　从图中我们可以清楚的看到，该模式中主要包含下面3种角色：

• 工厂（Creator）角色
  

　　它是工厂模式的核心，负责实现创建所有势力的内部逻辑。工厂类可以被外界直接调用，创建所需的产品的对象。

• 抽象（Product）角色
  

　　简单工厂模式所创建的所有对象的父类，负责描述所有实例所共有的公共接口。

• 具体产品（Concrete Product）角色
  

　　是该模式的创建目标，所有创建的对象都是充当这个角色的某个具体类的实例。一般来讲是抽象产品类的子类，实现了抽象产品类中定义的所有接口方法。
　　举个例子：

　　代码说明一切                                                                                



//Animal.java  抽象产品角色
public abstract class Animal {
public abstract void eat();
}


//Dog.java   具体产品角色
public class Dog extends Animal {
@Override
public void eat() {
System.out.println("dog eat");
}
}


//Pig.java   具体产品角色
public class Pig extends Animal {
@Override
public void eat() {
System.out.println("pig eat");
}
}


//AnimalFactory.java  工厂角色
public class AnimalFactory {
private AnimalFactory(){}
public static Animal animalFactory(String string)
{
if(string.equals("dog"))
return new Dog();
else if(string.equals("pig"))
return new Pig();
else
return null;
}
}


//AnimalTest.java 客户端调用
public class AnimalTest {
public static void main(String[] args) {
Animal dog = AnimalFactory.animalFactory("dog");
dog.eat();
Animal pig = AnimalFactory.animalFactory("pig");
pig.eat();
Animal ani = AnimalFactory.animalFactory("dog");
ani.eat();
ani = AnimalFactory.animalFactory("pig");
ani.eat();
}
}
　　优缺点                                                                                    
　　对象的创建比较复杂的时候，就考虑使用工厂来实现。
　　优点：在简单工厂模式中，客户端不再负责对象的创建，而是把这个责任丢给了工厂类，客户端值负责对象的调用，从而明确了各个类的职责（单一职责）。
　　缺点：由于这个工厂类负责所以的对象的创建，那么当子类不断增多的时候，我们就需要去修改工厂的代码，这样就违反了开闭原则。
　　PHP                                                                                                      



<?php
define('DB_TYPE','pdo');
interface IDB{
function select();
}
class DBMysql implements IDB{
private $tableName;
private $link;
function __construct($tableName){
$this->tableName=$tableName;
$this->link=mysql_connect('localhost','root','');
mysql_select_db('base',$this->link);
}
function select(){
//从数据库中获取数据
$sql="select * from {$this->tableName}";
$result=mysql_query($sql);
if($result && mysql_num_rows($result)>0){
while($row=mysql_fetch_assoc($result)){
$data[]=$row;
}
return $data;
}else{
return false;
}
}
}
class DBPdo implements IDB{
private $tableName;
private $handler;
function __construct($tableName){
$this->tableName=$tableName;
$dsn="mysql:host=localhost;dbname=ztz";
$this->handler=new Pdo($dsn,'root','');
}
function select(){
//从数据库中获取数据
$sql="select * from {$this->tableName}";
$stmt=$this->handler->query($sql);
return $stmt->fetchAll(PDO::FETCH_ASSOC);
}
}

class DBFactory{
public static function getInstance($tableName='factory'){
$class='DB'.DB_TYPE;
$obj=new $class($tableName);
if($obj instanceof IDB){
return $obj;
}else{
die('该类没有能实现IDB接口');
}
}
}
$m=DBFactory::getInstance();
$arr=$m->select();
echo "<pre>";
print_r($arr);
echo "</pre>";
?>
　　
　　PHP的简单工厂和Java的意思差不多，但是感觉PHP灵活的多。这里是考虑的是数据库连接，如果换服务器，数据库也跟着换了，那么数据库的连接怎么办，不可能每次都边吧，所以这里就用简单工厂来实现不同数据库的连接。
　　我是天王盖地虎的分割线                                                               
　　源代码：http://pan.baidu.com/s/1dD1Qx01
　　java工厂.zip