项⽬开发中常见的设计模式(23种)1995 年,GoF(Gang of Four,四⼈组/四⼈帮)合作出版了《设计模式:可复⽤⾯向对象软件的基础》⼀书,共收录了 23 种设计模式,从此树⽴了软件设计模式领域的⾥程碑,⼈称「GoF设计模式」。这 23 种设计模式的本质是⾯向对象设计原则的实际运⽤,是对类的封装性、继承性和多态性,以及类的关联关系和组合关系的充分理解。
设计模式分三⼤类(共23种):
创建型模式:1.单例模式、2.⼯⼚⽅法模式、3.抽象⼯⼚模式、4.建造者模式、5.原型模式。共5种
结构型模式:6.适配器模式、7.装饰器模式、8.代理模式、9.桥接模式、10.外观模式、11.组合模式、12.享元模式。共7种
⾏为型模式:13.观察者模式、14.访问者模式、15.中介者模式、16.解释器模式、17.策略模式、18.模板⽅法模式、19.迭代⼦模式、20.责任链模式、21.命令模式、22.备忘录模式、23状态模式。共11种
⼀.创建型模式
创建具体产品⼯⼚
/**
* ClassName:FactoryMethodPattern
* Description:⼯⼚⽅法模式
* Author:YMJ
* Date:2020-07-19 22:33
* Version:V1.0
*/
public class FactoryMethodPattern {
public interface Product{
public void show();
}
public interface MyFactory{
public Product creatProduct();
}
public static class Product_A implements Product{
@Override
public void show() {
System.out.println("⽣产了⼀件A产品");
}
}
public static class MyFactory_A implements MyFactory{
@Override
public Product creatProduct() {
return new Product_A();
}
}
public static class Product_B implements Product{
@Override
public void show() {
System.out.println("⽣产了⼀件B产品");
}
}
public static class MyFactory_B implements MyFactory{
@Override
public Product creatProduct() {
return new Product_B();
}
}
public static void main(String[] args) {
MyFactory myFactory;
myFactory = new MyFactory_A();
myFactory = new MyFactory_B();
}
// 输出结果缺点:只能创建⼀类产品,本例中只能创建Product类产品
// ⽣产了⼀件A产品
// ⽣产了⼀件B产品
}
缺点:只能⽣产⼀类产品,且⼀类产品中每增加⼀个产品都要增加相应⼯⼚类
3.抽象⼯⼚模式
抽象⼯⼚(AbstractFactory)模式:是⼀种为访问类提供⼀个创建⼀组相关或相互依赖对象的接⼝,且访问类⽆须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。
具体类就能得到同族的不同等级的产品的模式结构。
创建多种类抽象产品
创建抽象⼯⼚
创建具体种类产品
创建具体⼯⼚
/**
* ClassName:AbstractFactoryPattern
* Description:抽象⼯⼚模式
* Author:YMJ
* Date:2020-07-19 23:17
* Version:V1.0
*/
public class AbstractFactoryPattern {
/
/创建多种抽象产品
public interface AbstractProductTypeA{
public void show();
}
public interface AbstractProductTypeB{
public void call();
}
//创建抽象⼯⼚
public interface AbstractFactory{
public AbstractProductTypeA creatProductTypeA();
public AbstractProductTypeB creatProductTypeB();
}
//创建具体产品
public static class ProductTypeA implements AbstractProductTypeA{
@Override
public void show() {
System.out.println("创建了A类产品⼀件");
}
}
public static class ProductTypeB implements AbstractProductTypeB{
@Override
public void call() {
System.out.println("创建了B类产品⼀件");
}
}
public static class MyFacory implements AbstractFactory{
@Override
public AbstractProductTypeA creatProductTypeA() {
return new ProductTypeA();
}
@Override
public AbstractProductTypeB creatProductTypeB() {
return new ProductTypeB();
}
}
public static void main(String[] args) {
AbstractFactory factory = new MyFacory();
}
//输出结果:
//创建了A类产品⼀件
//创建了B类产品⼀件
}
优点:能⽣产各类产品,且只⽤⼀个⼯⼚类管理
4.建造者模式
建造者(Builder)模式:指将⼀个复杂对象的构造与它的表⽰分离,使同样的构建过程可以创建不同的表⽰,这样的被称为建造者模式。它是将⼀个复杂的对象分解为多个简单的对象,然后⼀步⼀步构建⽽成。它将变与不变相分离,即产品的组成部分是不变的,但每⼀部分是可以灵活选择的。
创建产品类:包含产品各个组件属性以及产品展⽰⽅法
创建抽象建造者:包含建造产品各个组件的抽象⽅法
创建实际建造者:通过继承抽象建造者实现各个组件的建造过程
创建指挥者:通过指挥实际建造者建造产品各个部分并组装成完整产品
/**
* ClassName:BuilderPattern
* Description:建造者模式
* Author:YMJ
* Date:2020-07-20 20:06
* Version:V1.0
*/
public class BuilderPattern {
//产品类:包含各个组成部分的复杂对象
public static class Product{
private String partA;
private String partB;
private String partC;
public void setPartA(String partA) {
this.partA = partA;
}
public void setPartB(String partB) {
this.partB = partB;
}
public void setPartC(String partC) {
this.partC = partC;
}
public void show(){
System.out.println("产品建造完毕,各部件分别是:" + partA + ";" + partB + ";" + partC);
}
}
//抽象建造者:包含创建产品的各个⼦部件的抽象⽅法
public static abstract class AbstractBuilder{
private Product product = new Product();
//定义建造部件A的抽象⽅法
public abstract void buildPartA();
//定义建造部件B的抽象⽅法
public abstract void buildPartB();
//定义建造部件C的抽象⽅法
public abstract void buildPartC();
//返回产品对象
单例模式的几种实现方式public Product getProduct(){
return product;
}
}
}
//具体建造者:继承抽象建造者,实现每个部件具体建造过程
public static class RealBuilder extends AbstractBuilder{
@Override
public void buildPartA() {
getProduct().setPartA("A部件");
}
@Override
public void buildPartB() {
getProduct().setPartB("B部件");
}
@Override
public void buildPartC() {
getProduct().setPartC("C部件");
}
}
//指挥者:调⽤建造者中的⽅法完成复杂对象的创建
public static class Director{
private AbstractBuilder abstractBuilder;
public Director(AbstractBuilder abstractBuilder){
this.abstractBuilder = abstractBuilder;
}
//提供产品的构建与组装⽅法
public Product build(){
abstractBuilder.buildPartA();
abstractBuilder.buildPartB();
abstractBuilder.buildPartC();
Product();
}
}
//客户端
public static void main(String[] args) {
AbstractBuilder builder = new RealBuilder();
Director director = new Director(builder);
Product product = director.build();
product.show();
}
}
建造者模式相⽐⼯⼚模式更注重于产品的组装过程;⼯⼚模式更注重于产品部件的创建过程
5.原型模式
原型(Prototype)模式:⽤⼀个已经创建的实例作为原型,通过复制该原型对象来创建⼀个和原型相同或相似的新对象,这就是克隆clone。在这⾥,原型实例指定了要创建的对象的种类。⽤这种⽅式创建对象⾮常⾼效,根本⽆须知道对象创建的细节。clone⽅法是native⽅法,⽐new⼀个快得多。clone分为浅克隆与深克隆。
浅克隆:创建⼀个新对象,新对象的属性和原来对象完全相同,对于⾮基本类型属性,仍指向原有属性所指向的对象的内存地址。
深克隆:创建⼀个新对象,属性中引⽤的其他对象也会被克隆,不再指向原有对象地址。
/**
* ClassName:PrototypePattern
* Description:原型模式,模板模式
* Author:YMJ
* Date:2020-07-20 20:57
* Version:V1.0
*/
public class PrototypePattern {
public static class MyObject implements Cloneable{
public String objectName;
版权声明:本站内容均来自互联网,仅供演示用,请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198,我们将在24小时内删除。
发表评论