1、简单工厂模式、工厂模式与抽象工厂模式

public interface Human { public void say()}

class Man implements Human { public void say() { System.out.println("男人") }}

class Woman implements Human { public void say() { System.out.println("女人") }}

　　　　　简单工厂模式：简单来说 ，在工厂类中添加判断方法返回对应的类；　

　　　　　　　　　　　　　缺点 违背开放封闭原则，需要经常修改工厂类

class SampleFactory {　　public static Human makeHuman(String type){　　　　　if(type.equals("man")){　　　　　　return new Man()　　　　　}else if(type.equals("womman")){　　　　　　return new Woman()　　　　　} 　　} }

　　   　　工厂模式： 将逻辑判断拿到客户端执行

interface Factory { public Human crateMan() }

class ManFactory implements Factory{ public Human crateMan() { return new Man() }}

class WomanFactory implements Factory{ public Human crateMan() { return new Woman() }}

class NormalFatory{　　 public static void main(String[] args) { Factory factory=new ManFactory()　　　　　Human man2=factory.crateMan()

man2.say() }}

 　　　　　　抽象工厂模式：因为实际业务中，通过客户端添加逻辑代码非常长，而且不容易修改。现在可以用子类抽象工厂来组装分离不同的业务。　　　　

interface Car { void gotowork()}

class Bus implements Car { public void gotowork() { System.out.println("坐公交车去上班！") }}

class Train implements Car { public void gotowork() { System.out.println("坐火车去上班！") }}

interface AbstractFactory {

　　Human getHuman()

　　Car getCar()

}

class ManFactory implements IAbstractFactory { public Car getCar() { return new Bus() } public Human getHuman() { return new Man() }}class WomanFactory implements IAbstractFactory {

public Car getCar() { return new Train() } public Human getHuman() { return new Woman() }}class AbstractFactoryTest{

　　public static void main(String[] args) {

　　　　IAbstractFactory factory = new ManFactory() 　　　　Car car = factory.getCar() 　　　　Human human = factory.getHuman()　　　　human.say() 　　　　car.gotowork()

　　　　IAbstractFactory factory2 = new ManFactory() 　　　　car = factory2.getCar() 　　　　human = factory.getHuman()　　　　human.say() 　　　　car.gotowork()

}

}

 2 、策略模式: 上面 1所述的模式我们发现 工厂中主要嵌套方法，如果嵌套的是属性，就是策略模式。

class Strategy{ 　　Human human　　Strategy(Human human){　　　　this.human = human　　}  public void doExec1(){ 　　human.say()

　　/*一般这里都是和工厂模式一样添加逻辑判断*/  }}

3、代理模式 ：我的理解代理就是对象的引用访问控制；相当于是策略模式的延伸。通过Proxy访问对象

class Proxy{ 　　Woman woman 　　Proxy(Woman woman){　　　　this.woman = woman　　} 　　public void doExec1(){ 　　　　woman.say() 　　}}

4、原型模式 ：这里涉及一个深拷贝和浅拷贝的概念。

　　⑴浅克隆 浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。 Object类提供的方法clone只是拷贝本对象，其对象内部的数组、引用对象等都不拷贝，还是指向原生对象的内部元素地址

　　⑵深克隆 深复制把要复制的对象所引用的对象都复制了一遍，在jvm中新建个对象。

　　浅克隆，部分对象未实现Cloneable接口 　　深克隆，所有对象都实现Cloneable接口重写clone()或者通过流序列化如下所示

在所有涉及的类都实现Serializable接口 Object deepClone() throws IOException ClassNotFoundException{ //将对象写到流里 ByteArrayOutputStream bos = new ByteArrayOutputStream() ObjectOutputStream oos = new ObjectOutputStream(bos) oos.writeObject(this) //从流里读回来 ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray()) ObjectInputStream ois = new ObjectInputStream(bis) return ois.readObject() }

　　简单来说，Man man =new Man()  就是创建一个原型， Man man1 = man.clone()这里就是浅客隆

5、模版模式 定义一套模版，子类在模版的结构中添加不同的逻辑。 我们对工厂模式的案例重写下

abstract class Human{ public void say() public void action() template(){ this.say() this.action() } } class Man implements Human { public void say() { System.out.println("男人") } public void action(){ System.out.println("玩游戏") }}class Woman implements Human { public void say() { System.out.println("女人") } public void action(){ System.out.println("贴面膜") }}

　客户端

public static void main(String[] args) { Human human human = new Man() human.template() human = new Woman() human.template() }

6、外观模式 我的理解就是对 类方法的不同组合

class Facade{ Man man Woman woman// A组合 public methodA(){ man.say() woman.action() }//B组合 public methodB(){ man.say() woman.say() } }

7、建造者模式  这个模式 与外观模式好像，这不过外观模式 多用于不同对象的方法组合。建造者模式是一种 类由多个方法组合

class Director{ //这个方法内部是固定的，就像做好菜的秘方一样 public void group(Human human){ human.say() huamn.action() ...//say方法建造过程中可以放前，也可以放action后。 } }

时间有限，篇幅有点长了，下篇再写。以上只是一个识别设计模式的简单案例，实际代码中可能会有三四种模式的复合或者更多复合。 可能因为个人的理解和角度不同，如果觉得有问题，请留言。