设计模式一-CSDN博客

本文链接：https://blog.csdn.net/qq_39318681/article/details/124230032

1.相关概念

设计模式(Design Pattern)是前人对代码开发经验的总结，是解决特定问题的一系列方法，非语法规定，而是一套用来提高代码复用性、可维护性、可读性的解决方案。

1.1 设计模式六大原则

总原则：开闭原则(open closed principle)

一个软件实体、如类、模板和函数一个对扩展开放，对修改关闭。即当程序需要扩展时，不去修改原有的代码，而是扩展原有代码，打到热插拔的效果。

1. 单一职责原则(single responsibility principle)

每个类只实现单一的职责，否则就应该把类拆开。

2.里氏替换原则(liskov substitution principle)

子类对父类的方法尽量不用重写和重载。

3.依赖倒置原则(dependence inversion princinple)

面向接口编程中，抽象不应该依赖于具体，具体应该依赖于抽象。

4.接口隔离原则(interface segregation principle)

每个接口中不存在子类用不到却必须实现的方法，不然要将接口拆分。

5.最少知道原则(law of demeter)

类之间只要有耦合关系，就是朋友关系。只与直接的朋友通信，一个类对自己依赖的知道的越少越好，这样当依赖的类发生变化时，才能最小的影响该类。

6.合成复用原则(composite resus princciple)

尽量使用对象组合，而不是继承关系达到软件复用的目的。

1.2 设计模式的三大类

创建型模式(creational pattern)：

工厂模式、抽象工厂模式、单例模式、原型模式、建造者模式

结构型模式(structural pattern)：

适配器模式、装饰者模式、代理模式、外观模式、桥接模式、组合模式、享元模式

行为型模式(behavioral pattern)：

策略模式、模板方法模式、观察者模式、迭代器模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式

2.设计模式

这里总结自己较为熟悉的几种设计模式，之后还会不断更新。

2.1 创建型模式

单例模式(singleton pattern)：

最简单的设计模式之一，该模式涉及一个单一的类，同时确保只有单个对象被创建。

应用实例：一个学校只能由一个校长(正校长)

package main

import "sync"

type Singleton struct {
	name string
	age int64
}

var (
	lazySingleton *Singleton
	once          = &sync.Once{}
)

// GetLazyInstance 懒汉式
func GetLazyInstance() *Singleton {
	if lazySingleton == nil {
		once.Do(func() {
			lazySingleton = &Singleton{}
		})
	}
	return lazySingleton
}

// 测试
func main()  {
	GetLazyInstance()
}

工厂模式(factory pattern)：

Java常用的设计模式之一，该模式中在创建对象时，不会对用户暴露创建逻辑，而是通过一个接口去创建指定的对象。

应用实例：客户去购买一辆车，直接去工厂提货就ok，而不需要知道这辆车的具体制造过程。需要哪个牌子的车，就到哪个牌子的工厂去提车就行。

interface Car {
    void drive();
}

//奥迪类 实现car接口因为奥迪车也是车 肯定可以开的嘛

class Audi implements Car {
    public Audi(){
        System.out.println("生产出一辆奥迪");
    }
    @Override
    public void drive() {
        System.out.println("开奥迪");
    }
}

//宝马类 实现car接口因为宝马车也是车 肯定也可以开

class Bmw implements Car{
    public Bmw(){
        System.out.println("生产出一辆宝马");
    }
    @Override
    public void drive() {
        System.out.println("开宝马");
    }

}

//生产车的工厂 该工厂接收一个车名 你只需要告诉他你要生产什么车 就可以生产出对应的车出来

class CarFactory {
    public static Car getCar(String caename){
        if(caename.equals("audi")){
            return new Audi();
        }else if(caename.equals("bmw")){
            return new Bmw();
        }return null;
    }
}

//测试
class Test {
    public static void main(String[] args) {
//告诉工厂类 你需要生产出一辆奥迪车 那么给昂他传一个参数audi进去
    Car audi = CarFactory.getCar("audi");
//就可以生产出奥迪的车 调用开车的方法就可以开车啦
    audi.drive();
//宝马类似
    Car bmw = CarFactory.getCar("bmw");
    bmw.drive();
    }
}

2.2 结构型模式

装饰器模式(decorator pattern)：

允许向一个现有的对象添加新的功能，同时又不改变其结构。

应用实例：python中的装饰器就是很好的应用，装饰器常用于记录日志，性能测试等。

def clock(func):
    func_doc = func.__doc__

    def clocked(*args):
        start = time.time()
        result = func(*args)
        end = time.time()
        print("{}执行完成，耗时{}秒".format(func_doc,end-start))
        return result
    return clocked

@clock
def test():
    """测试函数"""
    print('running...')
    time.sleep(3)

桥接模式(bridge pattern)：

又称为接口模式，将抽象化与具体化实现解耦，使两者独立变化。

应用实例：go语言的设计中大量使用了接口编程思想，可谓是面向接口编程。

package main

import "fmt"

// usb接口
type USB interface {
	run()
}

// 鼠标结构体
type Mouse struct {
}

// 实现usb的run方法，不同结构体实现的run方法会不同
func (this	Mouse) run()  {
	fmt.Println("mouse is running,please click it...")
}

// 测试
func main(){
	mouse := Mouse{}
	mouse.run()
}

2.3 行为型模式

策略模式(strategy pattern)：

一个类的行为可以在运行时改变。在策略模式中，创建各种策略对象和一个行为随着策略对象改变而改变的context对象。策略对象改变context对象的执行方法。

应用实例：诸葛亮的锦囊妙计，每个锦囊就是一个策略。

package main

import "fmt"

//现在有一个王子，要让他有攻击的技能，王子可以选择剑、斧头、枪等武器进行攻击,
//并根据不同的现有工具去选择不同的攻击策略

type strategy interface{
	attack()
}

type prince struct {
	name string
	wp strategy
}

func (pr *prince)beginAttack() {
	pr.wp.attack()
}

type sword struct {
}

func (sw *sword)attack() {
	fmt.Println("attack with a sword")
}

type axe struct {
}

func (ax *axe)attack() {
	fmt.Println("attack with a axe")
}

func main() {
	me := prince{"dashi", &sword{}}
	me.beginAttack()
	me.wp = &axe{}
	me.beginAttack()
}

迭代器模式(iteraot pattern)：

迭代器模式时Java中非常常用的设计模式，这种模式用于顺序访问对象的元素，其不需要知道集合对象的底层表示。

应用实例：Java中的iterator

// 接口
interface Iterator {
    boolean hasNext(); //判断是否是最后一个元素
    Object next();//返回下一个元素
}

// 迭代器
class NameRepository  {
    private Object names[];

    public NameRepository(Object[] names) {
        this.names = names;
    }

    public Iterator getIterator() {
        return new NameIterator();
    }

    private class NameIterator implements Iterator {
        private int index;
        @Override
        public boolean hasNext() {
            if(this.index < NameRepository.this.names.length){
                return true;
            }
            return false;
        }
        @Override
        public Object next() {
            if(this.hasNext()){
                return NameRepository.this.names[this.index++];
            }
            return null;
        }
    }
}

// 测试
class IteratorPatternDemo {
    public static void main(String[] args) {
        Object[] OBJ={"Robert" , "John" ,"Julie" , "Lora"};
        NameRepository namesRepository = new NameRepository(OBJ);

        Iterator iter = namesRepository.getIterator();
        while (iter.hasNext()){
            String name = (String)iter.next();
            System.out.println("Name : " + name);
        }
    }
}

文末至此，希望对大家有所帮助，我也在之后不断更新。