2024年Go最全使用Go实现23种设计模式——创建型模式_go 23种实现 csdn，6年老Golang面经总结

最新推荐文章于 2024-08-07 19:20:23 发布

BlackCATdog

最新推荐文章于 2024-08-07 19:20:23 发布

阅读量673

点赞数 21

分类专栏：程序员文章标签： go 学习面试

本文链接：https://blog.csdn.net/BlackCATdog/article/details/138693102

版权

程序员专栏收录该内容

54 篇文章 0 订阅

订阅专栏

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Go语言开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以戳这里获取

type FactoryInterface interface {
	CreateAnimal() ProductInterface
}

type ProductInterface interface {
	Init()
}

type DogFactory struct {
}

type AnimalDog struct {
}

func (a *AnimalDog) Init() {
	fmt.Printf("Dog ...\n")
}

func (f *DogFactory) CreateAnimal() ProductInterface {
	return &AnimalDog{}
}

func main() {
	var f FactoryInterface
	f = new(DogFactory)
	a := f.CreateAnimal()
	a.Init()
}

抽象工厂模式优点

隔离了具体类的生产，客户并不知道什么将被创建
当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象
新增具体工厂和产品族方便

抽象工厂模式缺点

增加新的产品等级结构复杂，需要修改抽象工厂及所有的具体工厂类

建造者模式

将一个复杂对象分解成多个相对简单的部分，然后根据不同需要分别创建它们，最后构建成该复杂对象（对复杂对象进行分模块创建）

适用场景

对象可以分模块初始化

Go语言实现

type Person struct {
	name, sex, address string
	age                int
}

func (p *Person) PrintInfo() {
	fmt.Printf("姓名: %s, 年龄: %d, 性别: %s, 住址: %s\n", p.name, p.age, p.sex, p.address)
}

type PersonBuilder struct {
	person *Person
}

func NewPersonBuilder() *PersonBuilder {
	return &PersonBuilder{person: &Person{}}
}

func (p *PersonBuilder) Name(name string) *PersonBuilder {
	p.person.name = name
	return p
}

func (p *PersonBuilder) Sex(sex string) *PersonBuilder {
	p.person.sex = sex
	return p
}

func (p *PersonBuilder) Address(address string) *PersonBuilder {
	p.person.address = address
	return p
}

func (p *PersonBuilder) Age(age int) *PersonBuilder {
	p.person.age = age
	return p
}

func (p *PersonBuilder) Build() *Person {
	return p.person
}

func main() {
	p := NewPersonBuilder().
		Name("张三").
		Age(18).
		Sex("男").
		Address("上海").
		Build()
	p.PrintInfo()
}

建造者模式优点

封装性好
扩展性好

建造者模式缺点

增加类数量，产生多余的Builder对象
如果产品内部发生变化，则建造者也要同步修改，后期维护成本较大

原型模式

用原型实例指定创建对象的种类，并且通过拷贝这个原型来创建新的对象

适用场景

不同对象之间相似度高
创建对象比较麻烦，但复制比较简单

Go语言实现

type Student struct {
	name string
	age  int
	sex  string
}

func (s *Student) SetStudentInfo(name string, age int, sex string) {
	s.name = name
	s.age = age
	s.sex = sex
}

func (s *Student) SetName(name string) {
	s.name = name
}

func (s *Student) PrintInfo() {
	fmt.Printf("学生姓名: %s, 年龄: %d, 性别: %s\n", s.name, s.age, s.sex)
}

func (s *Student) Clone() *Student {
	return &Student{
		name: s.name,
		age:  s.age,
		sex:  s.sex,
	}
}

func main() {
	s1 := &Student{}
	s1.SetStudentInfo("张三", 18, "男")
	s1.PrintInfo()
	s2 := s1.Clone()
	s2.SetName("李四")
	s2.PrintInfo()
}