大话设计模式总结

实习时给公司写代码，完全从零开始写，一开始写的很爽，因为可以随心所欲，不用先看别人的代码，完全按照自己的想法来实现。

写到后来发现当有需求变化时，不得不更改一些代码，结果由于一开始没有考虑的周全，结果在需求发生变化，没有一个好的设计模式，改的我心力憔悴。

虽然自己也明白写代码遵循抽象，重构的一些东西，但是毕竟没有受过良好训练，对设计模式的规范化没有清晰的认识。

于是最近一段时间读了下《大话设计模式》，受益匪浅，有些常用的设计模式还是很有必要记下来的。

1.单例(Singleton)模式:

这应该是最简单的一个模式了。

单例模式旨在确保某个类只有一个实例，并且为之提供一个全局访问点。

就是这个类自始至终只能有一个实例，并且这个实例可以作为全局变量。

简单的实现方法：

public class Singleton
{
	//静态实例属性
	private static Singleton instance = new Singleton();

<span style="white-space:pre">	</span>//构造方法设为私有的
	private Singleton(){};

<span style="white-space:pre">	</span>//设置一个静态方法来获得这个类的唯一实例
	public static Singleton getInstance()
	{
		return instance;
	}
	
}

2.工厂(Factory)模式：将类的实例化方法一个工厂类里去实现。

工厂模式主要是代替new 关键字来实例化我们的类，但是如果我们只是实例化一个类，我们完全不必使用工厂模式。但是如果我们需要在实例化类的同时做一下别的工作，如果把这些代码写在类的构造方法里，这样不仅看起来很丑，后期维护也会很费事。

如果我们把这些工作用一个工厂来干，这样后来再改需求的时候就能避免不必要的麻烦。

简单的实现方法：

 

public interface people{
      public void say();
}
 
 
public class chinese implements people{
      public void say(){
           System.out.println("说中国话");
     }
}
 
 
public class american implements people{
      public void say(){
           System.out.println("speak english");
     }
}
 
public class peopleFactory{
      public static people create(int type){
           if(type==1){
                  return new chinese();
           }else if(type==2){
                 return new american();
           }
     }
 }

//代码来源网络

3.代理模式

代理是基本的设计模式之一，它是你为了提供额外的或不同的操作，而插入的用来代替“实际”的对象的对象。这些操作通常涉及与“实际”对象的通信，因此代理模式通常充当中间人的角色。

class SimpleProxyDemo
{
	public static void consumer(Interface iface)
	{
		iface.doSometing();
		iface.somethinfElse("hehehe");
	}
	
	public static void main(String[] args)
	{
		consumer(new RealObject());
		consumer(new SimpleProxy(new RealObject()));
	}
}

interface Interface
{
	void doSometing();
	void somethinfElse(String arg);
}

class RealObject implements Interface{
	public void doSometing()
	{
		System.out.println("doSometing");
	}
	public void somethinfElse(String arg)
	{
		System.out.println("somethinfElse " + arg);
	}
}

class SimpleProxy implements Interface
{
	private Interface proxied;
	public SimpleProxy(Interface proxied)
	{
		this.proxied = proxied;
	}
	
	public void doSometing()
	{
		System.out.println("SimpleProxy doSometing");
		proxied.doSometing();
	}
	
	public void somethinfElse(String arg)
	{
		System.out.println("SimpleProxy somethinfElse " + arg);
		proxied.somethinfElse(arg);
	}
}

从代码看出

SimpleProxy 充当了代理角色，我们执行SimpleProxy 的方法，实际上会被转移到RealObject的身上。此时，我们若想提供额外的操作，我们不用对RealObject进行修改，而是使用更改SimpleProxy 这个代理角色的代码就可以了