设计模式

最新推荐文章于 2019-03-18 16:50:21 发布

406密码

最新推荐文章于 2019-03-18 16:50:21 发布

阅读量197

点赞数

本文链接：https://blog.csdn.net/qq_40611605/article/details/84240739

版权

一、设计模式的分类

总的来说设计模式分为三大类：

创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、终结者模式、解释器模式。

还有两类：并发性模式和线程池模式、

二、设计模式的六大原则

总原则：开闭模式（Open Close Principe）OCP

开闭原则就是对扩展开放，对修改关闭。在程序需要扩展的时候，不能去修改原有的代码，而是要扩展原有的代码，实现一个热插拔的效果。所以一句话概括就是：为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类等。

1、单一职责原则

不要存在多于一个导致类变更的原因，也就是说每个类应该实现单一的职责，如若不然，就应该把类拆分。

2、里氏替换原则（Liskov Substitution Principle）

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

历史替换原则中，子类对父类的方法尽量不要重写和重载。因为父类代表了定义好的结构，通过这个规范的接口与外界交互，子类不应该随便破坏它。

3、依赖倒转原则（Dependence Inversion Principle）

这个是开闭原则的基础，具体内容：面向接口编程，依赖于抽象而不依赖于具体。写代码时用到具体类时，不与具体类交互，而与具体类的上层接口交互。

4、接口隔离原则（Interface Segregation Principle）

这个原则的意思是：每个接口中不存在子类用不到却必须实现的方法，如果不然，就要将接口拆分。使用多个隔离的接口，比使用单个接口（多个接口方法集合到一个的接口）要好。

5、迪米特法则（最少知道原则）（Demeter Principle）

就是说：一个类对自己依赖的类知道的越少越好。也就是说无论被依赖的类多么复杂，都应该将逻辑封装在方法的内部，通过public方法提供给外部。这样当被依赖的类变化时，才能最小的影响该类。

最少知道原则的另一个表达方式是：只与直接的朋友通信。类之间只要有耦合关系，就叫朋友关系。耦合分为依赖、关联、聚合、组合等。我们称出现为成员变量、方法参数、方法返回值中的类为直接朋友。局部变量、临时变量则不是直接的朋友。我们要求陌生的类不要作为局部变量出现在类中。

6、合成复用原则（Composite Reuse Principle）

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

三、设计模式

1.工厂模式

（1）简单工厂：顾名思义，这个模式本身很简单，而且使用在业务较简单的情况下。

关键点：工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑。在java中它往往由一个具体的类实现。

抽象产品角色：它一般由具体产品继承的父类或者接口实现。在java中有接口或者抽象类实现。

具体产品角色：工厂类创建的对象就是此角色的实例。在Java中由一个具体的类实现。

缺点：扩展性差

抽象产品类代码：

package com.factory.simple;
//抽象（汽车）
public interface Car {
//启动汽车
	public void run();
}

具体产品类代码：

package com.factory.simple;

public class AodiCar_s implements Car{

	@Override
	public void run() {
		System.out.println("奥迪车启动");
	}

}

package com.factory.simple;

public class BmwCar_s implements Car {

	@Override
	public void run() {
		System.out.println("宝马车启动");
		
	}

}

简单工厂核心代码：

package com.factory.simple;

//生产汽车的工厂类
public class CarFactory {
//生产宝马车，奥迪车
	public static Car produceCar(String message){
		if(message.equals("宝马")){
			return new BmwCar_s();
		}else if(message.equals("奥迪")){
			return new AodiCar_s();
		}else{
			throw new RuntimeException( "没有您要的车型");
		}
		
	}

	
}

客户端调用代码：

package com.factory.simple;

public class Customer_s {
public static void main(String[] args) {
	CarFactory.produceCar("宝马").run();
	CarFactory.produceCar("奥迪").run();
	CarFactory.produceCar("大众").run();
}
}

运行结果：

（2）.工厂模式：定义一个创建对象的工厂接口，让子类决定实例化哪一个类，将实际工作交给子类。

如果工厂的产品全部属于同一个等级结构，则属于工厂方法模式。

关键点：

抽象工厂角色：这是工厂方法模式的核心，是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或接口来实现。
具体工厂角色：它含有和具体业务逻辑有关的代码。创建对应的具体产品的对象。在Java中它由具体的类来实现。
抽象产品角色：他是具体产品继承的父类或者是实现的接口。在java中一般由抽象类或接口来实现。
具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中有具体的类来实现。

优点：更符合开闭原则：新增加一种产品时，只需要增加相应的具体的产品类和相应的工厂子类即可。符合单一职责原则：每个具体工厂类只负责创建对应的产品。

缺点：在增加一个新的产品的时候，需要增加一个产品类和一个具体的子工厂，给系统增加负担的同时，每个工厂生产一种产品，太过单一。

抽象工厂代码：

package com.factory.method;
//抽象工厂
public interface CarFactory {
//创建汽车（抽象）
	public Car_M produceCar();
}

具体工厂代码：

package com.factory.method;

public class AodiCarFactory implements CarFactory {

	@Override
	public Car_M produceCar() {
		
		return new AodiCar_M();
	}

}

package com.factory.method;

public class BmwCarFactory implements CarFactory {

	@Override
	public Car_M produceCar() {
		
		return new BmwCar_M();
	}

}

抽象产品代码：

package com.factory.method;
//抽象(车)
public interface Car_M {
	//启动车辆
public void run();
}

具体产品代码：

package com.factory.method;

public class AodiCar_M implements Car_M {

	@Override
	public void run() {
		System.out.println("奥迪车启动");

	}

}

package com.factory.method;

public class BmwCar_M implements Car_M {

	public void run() {
		System.out.println("宝马车启动");
	}

}

客户端代码：

package com.factory.method;


public class Customer_M {
public static void main(String[] args) {
	CarFactory bm=new BmwCarFactory();
	bm.produceCar().run();
	CarFactory aodi=new AodiCarFactory();
	aodi.produceCar().run();
}
}

运行结果：

增加一个产品的代码：

增加一个大众车

package com.factory.method;

public class DazCar_M implements Car_M {

	@Override
	public void run() {
		System.out.println("大众车启动");

	}

}

package com.factory.method;

public class DazCarFactory implements CarFactory {

	@Override
	public Car_M produceCar() {
		
		return new DazCar_M();
	}

}

package com.factory.method;


public class Customer_M {
public static void main(String[] args) {
	CarFactory bm=new BmwCarFactory();
	bm.produceCar().run();
	CarFactory aodi=new AodiCarFactory();
	aodi.produceCar().run();
	CarFactory Daz=new DazCarFactory();
	Daz.produceCar().run();
}
}

运行结果：

（3）、抽象工厂

建造者模式：将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。

关键点：

具体产品（Produce）：表示被构造的复杂对象。
抽象构建产品（Builder）：为创建一个产品对象的各个部件指定抽象接口。
抽象构建的具体实现（BuilderImpl）:实现Builder的接口以构造和装配该产品的各个部件，定义并明确它所创建的表示。
构建者（Director）：构建一个使用Builder接口的对象。

优点：

易于解耦：将产品本身与产品创建过程中进行解耦，可以使用相同的创建过程来得到不同的产品。
易于精准控制对象的创建：将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰。
易于拓展：增加新的具体创建者无需修改原有类库的代码，易于拓展，符合开闭原则

缺点：

建造者模式创建的产品一般具有较多的共同点，其组成部分相似：如果产品之间的差异性很大，则不适合使用建造者模型。
如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得庞大。

应用场景：需要生成的对象有复杂的内部结构，这些产品对象具备共性；

隔离复杂对象的创建和使用，并使用相同的创建过程可以创建不同的产品。

具体产品（Produce）代码：

package com.builder;

public class Computer {
private String mainBoard;
private String HardDisk;
private String cpu;
public String getMainBoard() {
	return mainBoard;
}
public void setMainBoard(String mainBoard) {
	this.mainBoard = mainBoard;
}
public String getHardDisk() {
	return HardDisk;
}
public void setHardDisk(String hardDisk) {
	HardDisk = hardDisk;
}
public String getCpu() {
	return cpu;
}
public void setCpu(String cpu) {
	this.cpu = cpu;
}
@Override
public String toString() {
	return "Computer [mainBoard=" + mainBoard + ", HardDisk=" + HardDisk + ", cpu=" + cpu + "]";
}
 
	
}

抽象构建产品（Builder）代码：

package com.builder;
//抽象生产
public interface Builder {
//构建主板
   public void buildMainBoard();
   //构硬盘
   public void buildHD();
   //构建CPU
   public void buildCPU();
   //最终生成的电脑
   public Computer buildComputer();
}

抽象构建的具体实现（BuilderImpl）代码：

package com.builder;

public class BuildComputer implements Builder {
private Computer c=new Computer();
	@Override
	public void buildMainBoard() {
		c.setMainBoard("华硕");

	}

	@Override
	public void buildHD() {
		c.setHardDisk("希捷");
	}

	@Override
	public void buildCPU() {
		c.setCpu("Intel i5");

	}

	@Override
	public Computer buildComputer() {
	
		return c;
	}

}

构建者（Director）代码：

package com.builder;
//建造者
public class Director {
public static Computer constructorCom(Builder b){
	b.buildMainBoard();
	b.buildHD();
	b.buildCPU();
	return  b.buildComputer();
	
}
}

测试代码：

package com.builder;

import javax.sound.midi.SysexMessage;

public class testbuilder {
public static void main(String[] args) {
	Computer com=Director.constructorCom(new  BuildComputer());
		System.out.println(com);
		

}
}

运行结果：

参考内容：http://blog.csdn.net/zhangerqing

406密码

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
设计模式

一、设计模式的分类总的来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、终结者模式、解释器模式。还有两类：...
复制链接

扫一扫