设计模式一创建型设计模式

设计模式总概念之创建型设计模式详解

设计模式分类：

创建型设计模式：对象怎么来的，主要用于创建对象。

结构型设计模式：对象和谁有关系，主要用于描述对象之间的关系。

行为型设计模式：对象和对象在干嘛，主要用于描述对象的动作。

J2EE型设计模式：对象联合起来要干嘛，主要用于描述对象联合的目的。

设计模式的六大原则：

开闭原则：对扩展开放，对修改关闭。

里氏代换原则：任何基类可以出现的地方，子类一定可以出现

依赖倒转原则：针对接口编程，依赖于抽象而不依赖于具体类

接口隔离原则：使用多个隔离的接口好过于使用一个接口，降低类之间的耦合性

迪米特法则：实体之间尽少相互作用，系统功能模块尽量独立；

合成复用原则：尽量使用聚合和组合，而不是继承；

创建型设计模式：

工厂模式 ； 抽象工厂模式  ； 单例模式 ； 建造者模式 ； 原型模式

工厂模式：

　　创建一个接口，创建多个实现接口的实体类

　　创建一个工厂类，通过工厂创建对象。

定义Animal接口： Animal.java

public interface Animal
{
　　void eat();
}

定义接口实现类1 Dog.java

public class Dog implements Animal
{
　　@Override
　　public void eat()
　　{
　　　　System.out.println("eat meat ~");
　　}
}

定义接口实现类2 Cat.java

public class Cat implements Animal
{
　　@Override
　　public void eat()
　　{
　　　　System.out.println("eat fish ~");
　　}
}

定义工厂类 AnimalFactory.java

public class AnimalFactory
{
　　public AnimalFactory getAnimalFactory(String  animalName)
　　{
　　　　if(animalName.equalsIgnoreCase("DOG"))
　　　　{
　　　　　　return new Dog();
　　　　}
　　　　else if(animalName.equalsIgnoreCase("Cat"))
　　　　{
　　　　　　return new Cat();
　　　　}
　　　　else
　　　　{
　　　　　　return null;
　　　　}

　　}

}

通过工厂类创建对象类 AnimalFactoryTest.java

public class AnimalFactoryTest
{
     public static void main(String[] args) 
    {　　
　　　　//创建工厂对象
    　　AnimalFactory animalFactory = new AnimalFactory();
　　　　
　　　　//通过工厂对象创建对应的接口实现类对象，而后调用类实现的方法
　　　　Dog dog = animalFactory.getAnimalFactory("dog");
　　　　dog.eat();
　　　　
       Cat cat= animalFactory.getAnimalFactory("cat");
　　　　cat.eat();　　

    }
    
}

 输出结果为：

eat meat ~

eat fish ~

抽象工厂模式：

　　创建多个接口，创建对应每个接口的多个实现类

　　创建一个抽象工厂类 里面包含得到每个接口类型变量的抽象方法 

　　创建多个工厂继承抽象工厂，实现对应的方法，不对应的采用空实现

与工厂模式的不同之处： 接口对应的工厂类继承抽象工厂，工厂生成器生成工厂，再通过工厂创建对象

定义Shape接口： Shape.java

public interface Shape
{
  void draw();            
}

定义Circle实现SHape接口类： Circle.java

public class Circle implements Shape
{
   public void draw()
   {
    System.out.println("draw--circle");
   }
}

定义Square实现SHape接口类： Square.java

public class Square implements Shape
{
   public void draw()
   {
    System.out.println("draw--square");
   }
}

定义Color接口： Color.java

public interface Color
{
  void fill();            
}

定义Red实现Color接口类： Red.java

public class Red implements Color
{
   public void fill()
   {
    System.out.println("fill--Red");
   }
}

定义Green实现Color接口类： Green.java

public class Green implements Color
{
   public void fill()
   {
    System.out.println("fill--green");
   }
}

 创建获取接口的抽象工厂： AbstractFactory.java

public abstract class AbstractFactory
{
  abstract Shape getShape(String shape);
  abstract Color getColor(String color);   
}

创建Shape接口对应的工厂，并且继承抽象工厂： ShapeFactory.java

public class ShapeFactory extends AbstractFactory
{
  @Override
   public Shape getShape(String shape)
    {
       if(shape.equals("Circle"){
          return new Circle();
       }else if(shape.equals("Square")){
          return new Square();
       }else{
          return null;
       }
    }    

   @Override
   public Color getColor(String color)
   {
　　　　return null;　　
   }

} 

创建Color接口对应的工厂，并且继承抽象工厂：ColorFactory.java

public class ColorFactory extends AbstractFactory
{
  @Override
   public Color getColor(String color)
    {
       if(color.equals("red"){
          return new Red();
       }else if(color.equals("green")){
          return new Green();
       }else{
          return null;
       }
    }    

   @Override
   public Shape getShape(String shape)
    {
          return null;
    }    

} 

  创建工厂生成器类用来得到相应的接口对应的工厂： BuilderFactory.java

public class BuilderFactory
{
  public static AbstractFactory getFactory(String factory)
  {
     if(factory.equals("ShapeFactory")){
       return new ShapeFactory();
    }else  if(factory.equals("ColorFactory")){
       return new ColorFactory();
    }else{
       return null;
    }
  }
}    

测试类：AbstractFactoryTest.java

public class AbstractFactoryTest
{
　　public static void main(String[] args){
　　　　//得到Shape接口对应的工厂
　　　　AbstractFactory shapeFactory = BuilderFactory.getFactory("ShapeFactory");
　　　　//通过工厂创建Circle对象
　　　　Circle circle = shapeFactory.getShape("Circle");
　　　　circle.draw();

　　　　//通过工厂创建Square对象
　　　　Square square= shapeFactory.getShape("Square");
　　　　square.draw();

　　　　//得到Color接口对应的工厂
　　　　AbstractFactory colorFactory = BuilderFactory.getFactory("ColorFactory");
　　　　//通过工厂创建Red对象
　　　　Red red= colorFactory .getColor("red");
　　　　red.fill();

　　　　//通过工厂创建Green对象
　　　　Green green= colorFactory .getColor("green");
　　　　green.fill();

　　}
}

输出结果为：

draw--circle

draw--square

fill--red

fill--green

单例模式：

　　保证只有一个对象的存在

　　构造方法私有化

　　饱汉式单例与饿汉式单例

包汉式单例 Singleton.java

特点：

创建静态全局变量

定义私有构造方法

创建静态方法获取对象，先判断对象是否存在，存在直接返回对象，不存在通过new创建对象再返回。

public class Singleton {  
    private static Singleton instance;  
    private Singleton (){}  
  　　
　　//synchronized存在的时候表示这是线程安全的，不存在的时候表示线程不安全
    public static synchronized Singleton getInstance() {  
    if (instance == null) {  
        instance = new Singleton();  
    }  
    return instance;  
    }  

   public void showMessage(){
      System.out.println("Hello World!");
   }

} 

饿汉式单例：Singleton.java

特点：

定义私有的构造方法

直接定义静态全局变量并且创建对象为其赋值，

创建静态方法获取时直接返回对象。

public class Singleton {  
    private static Singleton instance = new Singleton();  
    private Singleton (){}  
    public static Singleton getInstance() {  
    return instance;  
    }  

   public void showMessage(){
      System.out.println("Hello World!");
   }

} 

测试类： SingletonTest.java

public class SingletonTest{
   public static void main(String[] args) {

      //不合法的构造函数
      //编译时错误：构造函数 Singleton () 是不可见的
      //Singleton object = new Singleton ();

      //获取唯一可用的对象
      Singleton object = Singleton .getInstance();

      //显示消息
      object.showMessage();
   }
}

输出结果：

Hello world!

 

知识点：抽象类实现接口可以不实现的接口的所有方法，未实现的接口方法可以交给抽象类的子类去实现。

建造者模式：

使用多个简单的对象一步一步构建成一个复杂的对象。

一个 Builder 类会一步一步构造最终的对象。该 Builder 类是独立于其他对象的。

步骤 1

创建一个表示食物条目和食物包装的接口。

Item.java

public interface Item {
   public String name();
   public Packing packing();
   public float price();    
}

Packing.java

public interface Packing {
   public String pack();
}

步骤 2

创建实现 Packing 接口的实体类。

Wrapper.java

public class Wrapper implements Packing {

   @Override
   public String pack() {
      return "Wrapper";
   }
}

Bottle.java

public class Bottle implements Packing {

   @Override
   public String pack() {
      return "Bottle";
   }
}

步骤 3

创建实现 Item 接口的抽象类，该类提供了默认的功能。（这里只实现一个方法，其余两个交给子类去实现）

Burger.java

public abstract class Burger implements Item {

   @Override
   public Packing packing() {
      return new Wrapper();
   }

   @Override
   public abstract float price();
}

ColdDrink.java

public abstract class ColdDrink implements Item {

    @Override
    public Packing packing() {
       return new Bottle();
    }

    @Override
    public abstract float price();
}

步骤 4

创建扩展了 Burger 和 ColdDrink 的实体类。

VegBurger.java

public class VegBurger extends Burger {

   @Override
   public float price() {
      return 25.0f;
   }

   @Override
   public String name() {
      return "Veg Burger";
   }
}

ChickenBurger.java

public class ChickenBurger extends Burger {

   @Override
   public float price() {
      return 50.5f;
   }

   @Override
   public String name() {
      return "Chicken Burger";
   }
}

Coke.java

public class Coke extends ColdDrink {

   @Override
   public float price() {
      return 30.0f;
   }

   @Override
   public String name() {
      return "Coke";
   }
}

Pepsi.java

public class Pepsi extends ColdDrink {

   @Override
   public float price() {
      return 35.0f;
   }

   @Override
   public String name() {
      return "Pepsi";
   }
}

步骤 5

创建一个 Meal 类，带有上面定义的 Item 对象。

Meal.java

import java.util.ArrayList;
import java.util.List;

public class Meal {
   private List<Item> items = new ArrayList<Item>();    

   public void addItem(Item item){
      items.add(item);
   }

   public float getCost(){
      float cost = 0.0f;
      for (Item item : items) {
         cost += item.price();
      }        
      return cost;
   }

   public void showItems(){
      for (Item item : items) {
         System.out.print("Item : "+item.name());
         System.out.print(", Packing : "+item.packing().pack());
         System.out.println(", Price : "+item.price());
      }        
   }    
}

步骤 6

创建一个 MealBuilder 类，实际的 builder 类负责创建 Meal 对象。

MealBuilder.java

public class MealBuilder {

   public Meal prepareVegMeal (){
      Meal meal = new Meal();
      meal.addItem(new VegBurger());
      meal.addItem(new Coke());
      return meal;
   }   

   public Meal prepareNonVegMeal (){
      Meal meal = new Meal();
      meal.addItem(new ChickenBurger());
      meal.addItem(new Pepsi());
      return meal;
   }
}

步骤 7

BuiderPatternDemo 使用 MealBuider 来演示建造者模式（Builder Pattern）。

BuilderPatternDemo.java

public class BuilderPatternDemo {
   public static void main(String[] args) {
      MealBuilder mealBuilder = new MealBuilder();

      Meal vegMeal = mealBuilder.prepareVegMeal();
      System.out.println("Veg Meal");
      vegMeal.showItems();
      System.out.println("Total Cost: " +vegMeal.getCost());

      Meal nonVegMeal = mealBuilder.prepareNonVegMeal();
      System.out.println("

Non-Veg Meal");
      nonVegMeal.showItems();
      System.out.println("Total Cost: " +nonVegMeal.getCost());
   }
}

步骤 8

验证输出。

Veg Meal
Item : Veg Burger, Packing : Wrapper, Price : 25.0
Item : Coke, Packing : Bottle, Price : 30.0
Total Cost: 55.0


Non-Veg Meal
Item : Chicken Burger, Packing : Wrapper, Price : 50.5
Item : Pepsi, Packing : Bottle, Price : 35.0
Total Cost: 85.5