java设计模式

Java 中有 23 种设计模式，问的比较多的几种设计模式就那几种，下面列出了所有的设计模式，需要掌握的设计模式我单独列出来了。总体来说设计模式分为三大类：
创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

问的比较多的

单例设计模式

单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。这些应用都或多或少具有资源管理器的功能。每台计算机可以有若干个打印机，但只能有一个Printer Spooler(什么是Printer Spooler)，以避免两个打印作业同时输出到打印机中。每台计算机可以有若干通信端口，系统应当集中管理这些通信端口，以避免一个通信端口同时被两个请求同时调用。总之，选择单例模式就是为了避免不一致状态，避免政出多头。

单例模式特点：
1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例。

单例模式保证了全局对象的唯一性，比如系统启动读取配置文件就需要单例保证配置的一致性。

实现单例模式的方式：

class MySingle1{
	private static MySingle1 single = new MySingle1();
	private MySingle1() {}
	public static MySingle1 getInstance() {
		 return single;
	 }		
}

class MySingle2{
	private static MySingle2 single;
	private MySingle2() {}
	public static MySingle2 getInstance() {
		 if (single==null) {
			 single=new MySingle2();
		}
		 return single;
	 }
}

1.饿汉式单例（立即加载方式）

// 饿汉式单例
public class Singleton1 { 
	// 私有构造 
	private Singleton1() {} 
	private static Singleton1 single = new Singleton1(); 
	// 静态工厂方法 
	public static Singleton1 getInstance() { return single; }}

2.懒汉式单例（延迟加载方式）

// 懒汉式单例
public class Singleton2 {   
	// 私有构造 
	private Singleton2() {}   
	private static Singleton2 single = null;   
	public static Singleton2 getInstance() {
	 	if(single == null){
	 		single = new Singleton2(); 
		 } 
		 return single; 
	 }
}

该示例虽然用延迟加载方式实现了懒汉式单例，但在多线程环境下会产生多个single对象，如何改造请看以下方式:

使用synchronized同步锁

public class Singleton3 { 
	// 私有构造 
	private Singleton3() {} 
	private static Singleton3 single = null; 
	public static Singleton3 getInstance() { 
	// 等同于 synchronized public static Singleton3 getInstance() 
		synchronized(Singleton3.class){
			// 注意：里面的判断是一定要加的，否则出现线程安全问题 
			if(single == null){ 
				single = new Singleton3(); 
			}
		}
		return single; 													       
	

工厂设计模式

常用的工厂模式是静态工厂，利用static方法，作为一种类似于常见的工具类Utils等辅助效果，一般情况下工厂类不需要实例化。

interface food{}
class A implements food{}
class B implements food{}
class C implements food{}
public class StaticFactory {   
	private StaticFactory(){} 
	public static food getA(){ return new A(); } 
	public static food getB(){ return new B(); } 
	public static food getC(){ return new C(); }
}
class Client{ 
//客户端代码只需要将相应的参数传入即可得到对象 
//用户不需要了解工厂类内部的逻辑。 
	public void get(String name){ 
		food x = null ; 
		if ( name.equals("A")) { 
			x = StaticFactory.getA(); 
		}else if ( 
			name.equals("B")){
			x = StaticFactory.getB(); 
		}else { x = StaticFactory.getC(); }
	}
 }


//get方法处违背了开闭原则
//对外新增的代码持开放状态，对内修改的代码持关闭状态
//更好更灵活的 工厂加反射+配置文件

抽象工厂模式（Abstract Factory）
一个基础接口定义了功能，每个实现接口的子类就是产品，然后定义一个工厂接口，实现了工厂接口的就是工厂，这时候，接口编程的优点就出现了，我们可以新增产品类（只需要实现产品接口），只需要同时新增一个工厂类，客户端就可以轻松调用新产品的代码。　　抽象工厂的灵活性就体现在这里，无需改动原有的代码，毕竟对于客户端来说，静态工厂模式在不改动StaticFactory类的代码时无法新增产品，如果采用了抽象工厂模式，就可以轻松的新增拓展类。

interface food{}
class A implements food{}
class B implements food{}
interface produce{ food get();}
class FactoryForA 
	implements produce{ 
	@Override 
		public food get() { return new A(); }
}
class FactoryForB implements produce{ 
	@Override public food get() { return new B(); }
}
public class AbstractFactory { 
	public void ClientCode(String name){ 
		food x= new FactoryForA().get(); 
		x = new FactoryForB().get(); 
	}
}

装饰器模式

给一类对象增加新的功能，装饰方法与具体的内部逻辑无关。动态地给一个对象添加一些额外地职责，可以达到增强一个对象功能的作用。也就是装饰来包裹一个真实的对象。看定义可能有点难理解，直接上代码。首先定义一个程序员接口

// 定义一个Programmer接口 只有一个敲代码的方法

public interface Programmer {
    void code();
}
//定义个java程序员类 实现接口
public class JavaProgrammer implements Programmer {
    @Override
    public void code() {
        System.out.println("使用java敲代码");
    }
}

现在由于这位java程序员敲代码年数已久，头发已经变得稀少，然而这位程序员是个爱面子的java程序员，所以现在需要增强一下这个java程序员的敲代码方法，在敲代码之前戴他上刚买的假发。最简单粗暴的方法肯定是想到通过修改code方法，但是设计模式有个开发封闭原则，就是类可以增强，但不能修改，所以现在就用到了我们的装饰模式。我们先定义一个继承了Programmer类的ProgrammerDecorator类并且在构造方法中传入一个Programmer对象，然后在这个重写原来的code方法，具体看代码

 //定义一个java程序员装饰类 增强了之前的敲代码方法

public class ProgrammerDecorator implements Programmer {
    private Programmer programmer;
    public ProgrammerDecorator(Programmer programmer){
        this.programmer = programmer;
    }
    @Override
    public void code() {
        System.out.println("戴上新买的假发");//戴假发的方法
        programmer.code();
    }
   
}
//现在看下使用了装饰模式的效果运行代码：
public static void main(String[] args) {
    //新建一个java程序员对象
    Programmer javaProgrammer = new JavaProgrammer();
    //通过装饰类去增强一下程序员对象
    Programmer descProgrammer = new ProgrammerDecorator(javaProgrammer);
    //程序员执行敲代码动作
    descProgrammer.code();
}

运行结果：

代理设计模式

代理模式就是为其他对象提供一种代理以控制对这个对象的访问。用代码继续讲解这个模式还是上面的程序员接口和java程序员实现类，现在由于java程序员已经戴上了假发，工作效率激增，并且可以写出一个很牛逼的软件。现在问题来了，你怎么去把这个软件给推销出去？再厉害的软件没人知道也是个不成功的软件。一般程序员只会写代码不会推销产品，所以现在需要一个销售代理程序员完成推销软件这个工作，而程序员只用关心自己需要做的，继续写好自己代码就行。具体看代码。定义一个销售类

public class Sales implements Programmer {
    private JavaProgrammer programmer;
    public Sales(){
        this.programmer = new JavaProgrammer();
    }
    @Override
    public void code() {
        programmer.code();
        //写完代码后推销软件
        sale();
    }
    public void sale(){
        System.out.println("推销软件.......");
    }
}
//运行代码：
public static void main(String[] args) {
    //创建一个销售代理对象
    Programmer programmer = new Sales();
    programmer.code();
}

运行结果：

装饰者与代理模式总结：
现在代理模式和装饰模式的具体效果以及实现已经出来了。看到这里代码理解还是很简单的，但是会发现装饰模式和代理模式是非常相似的。

但两者都是对类的方法进行增强，但装饰器模式强调的是增强自身，在被装饰之后你能够够在被增强的类上使用增强后的方法。增强过后还是你，只不过能力变强了。而代理模式则强调要别人帮你去做一些本身与你业务没有太多关系的职责。代理模式是为了实现对象的控制，因为被代理的对象往往难以直接获得或者是其内部不想暴露出来。

设计模式的六大原则

1、开闭原则（Open Close Principle）开闭原则就是说对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。所以一句话概括就是：为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点。

2、里氏代换原则（Liskov Substitution Principle）里氏代换原则(Liskov Substitution Principle LSP)面向对象设计的基本原则之一。 里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。 LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。

3、依赖倒转原则（Dependence Inversion Principle）这个是开闭原则的基础，具体内容：真对接口编程，依赖于抽象而不依赖于具体。

4、接口隔离原则（Interface Segregation Principle）这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。还是一个降低类之间的耦合度的意思，从这儿我们看出，其实设计模式就是一个软件的设计思想，从大型软件架构出发，为了升级和维护方便。所以上文中多次出现：降低依赖，降低耦合。

5、迪米特法则（最少知道原则）（Demeter Principle）为什么叫最少知道原则，就是说：一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。

6、合成复用原则（Composite Reuse Principle）原则是尽量使用合成/聚合的方式，而不是使用继承。

相关链接：
java23种设计模式
装饰者和代理模式