设计模式-创建型

简介

设计模式：软件开发人员开发过程中汇总出来的最佳实践，也可以理解为最佳Coding解决方案。
掌握设计模式，能有效提高Coding效率，减少代码量。

遵循的原则

1、开闭原则

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

2、里氏代换原则

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

3、依赖倒转原则

依赖倒转原则：面向接口编程，依赖于抽象而不依赖于具体。

4、接口隔离原则

接口隔离原则：降低依赖，降低耦合。

5、迪米特法则

迪米特法则：一个实体应当尽量少地与其他实体之间发生相互作用，使得系统功能模块相对独立。

6、合成复用原则

合成复用原则：尽量使用合成/聚合的方式，而不是使用继承。

分类

Create创建型模式，共五种：工厂模式、抽象工厂模式、单例模式、建造者模式、原型模式。
Structure结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
Behavior行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

创建型

工厂模式

package com.plxc.pattern;
/**
 * 创建型-工厂模式
 * 提供了一种创建对象的最佳方式
 * 
 * @author vander
 *
 */
public class CFactory {
	
	public static void main(String[] args) {
		AnimalFactory animalFactory = new AnimalFactory();
		Animal animal = animalFactory.opt("dog");
		if(animal!=null) {
			animal.eat();
		}
	}

}

class AnimalFactory{
	
	public Animal opt(String animalName) {
		Animal animal = null;
		switch (animalName) {
			case "cat":
				animal = new Cat();
				break;
			case "dog":
				animal = new Dog();
				break;	
			default:
				break;
		}
		return animal;
	}
}

interface Animal{
	public void eat();
}

class Cat implements Animal{

	public void eat() {
		System.err.println("猫吃鱼...");
	}
	
}
class Dog implements Animal{

	public void eat() {
		System.err.println("狗吃骨头...");
	}
	
}

抽象工厂模式

package com.plxc.pattern;

/**
 * 创建型-抽象工厂模式
 * 提供了一种创建工厂对象的最佳方式
 * 
 * @author vander
 *
 */
public class CAbstractFactory {
	public static void main(String[] args) {
		AbstractFactory factory = FactoryProducer.getFactory();
		Animal cat = factory.activity("cat");
		cat.eat();
	}
}

class FactoryProducer{
	public static AbstractFactory getFactory() {
	    return new LandAnimalFactory();
	}
}

abstract class AbstractFactory {
	 public abstract Animal activity(String animalName);
	 //可以定义多个抽象对象
}

class LandAnimalFactory extends AbstractFactory {
	@Override
	public Animal activity(String animalName) {
		Animal animal = null;
		switch (animalName) {
			case "cat":
				animal = new Cat();
				break;
			case "dog":
				animal = new Dog();
				break;	
			default:
				break;
		}
		return animal;
	}
}

单例模式

package com.plxc.pattern;

/**
 * 创建型-单例模式
 * 只能有一个实例
 * 
 * @author vander
 *
 */
public class CSingleton {
	public static void main(String[] args) {
		for(int i = 0;i<10;i++) {
			System.err.println(Singleton.getSingleton());
		}
	}
}

class Singleton {  
    private volatile static Singleton singleton;  
    private Singleton (){}  
    public static Singleton getSingleton() {  
	    if (singleton == null) {  
	        synchronized (Singleton.class) {  
		        if (singleton == null) {  
		            singleton = new Singleton();  
		        }  
	        }  
	    }  
	    return singleton;  
    }
}

建造者模式

package com.plxc.pattern;

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

/**
 * 创建型-建造者模式
 * 
 * 
 * @author vander
 *
 */
public class CBuilder {
	public static void main(String[] args) {
		DellInfo dellInfo = new DellInfo();
		List<Company> items = new ArrayList<Company>();
		items.add(dellInfo);
		Builder builder = new Builder(items);
		builder.builder();
	}
}

class Builder{
	private List<Company> items = new ArrayList<Company>();

	public Builder(List<Company> items) {
		this.items = items;
	} 
	public void builder() {
		for (Company company : items) {
			System.err.println(company.name());
			System.err.println(company.price());
			company.wrapper().opt();
		}
	}
	
}

interface Company{
	String name();
	float price();
	Wrapper wrapper();
}

class DellInfo extends CompanyInfo{

	@Override
	public String name() {
		return "戴尔电脑";
	}
	@Override
	public float price() {
		return 6000;
	}
	
}

abstract class CompanyInfo implements Company{
	@Override
	public Wrapper wrapper() {
		return new Mainboard();
	}
	
}

interface Wrapper{
	void opt();
}

class Mainboard implements Wrapper{
	@Override
	public void opt() {
		System.err.println("主板组装完成...");
	}
}

原型模式

package com.plxc.pattern;

/**
 * 创建型-原型模式
 * 创建重复的对象
 * 
 * @author vander
 *
 */
public class CPrototype {
	public static void main(String[] args) {
		Phone phone = new Phone();
		phone.setName("小米");
		Phone clone = (Phone) phone.clone();
		System.err.println(clone.getName());
		phone.setName("华为");
		System.err.println(clone.getName());
	}
}

class Phone implements Cloneable{
	private String name;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@Override
	protected Object clone() {
		  Object clone = null;
	      try {
	         clone = super.clone();
	      } catch (CloneNotSupportedException e) {
	         e.printStackTrace();
	      }
	      return clone;
	}
}