编程范式

A Go functional-options example for constructing an object with default values while allowing selected fields to be changed flexibly.

What an interface function is, why it is useful, and a Go implementation that allows either function values or structs to satisfy the same interface.

What event sourcing is, why it is needed, how it addresses some CRUD problems, its disadvantages, and design notes.

What the publish–subscribe pattern is, why it is needed, how it differs from producer–consumer and observer patterns, and a Go implementation.

What the producer/consumer pattern is, why it is needed, and Go implementations using channels, timeouts, object-oriented encapsulation, and error handling.

What the open–closed principle is, why it is needed, and how to implement it through abstractions, inheritance, composition, and aggregation.

What the Liskov substitution principle is, why it is needed, and how subclasses should preserve the meaning of parent-class behavior.

What the dependency inversion principle is, why it is needed, and implementation guidance centered on interfaces and abstract classes.

What the single responsibility principle is, why it is needed, and how to separate different responsibilities into different classes or modules.

What the interface segregation principle is, why it is needed, and how to keep interfaces small and tailored to their callers.

What the Law of Demeter is, why it is needed, and how to reduce coupling by limiting what objects depend on and expose.

What the composition reuse principle is, why it is needed, and how composition or aggregation can be preferred over inheritance for code reuse.

What object-oriented design principles are, why they are needed, and the main principles covered by these notes.

What design patterns are and the three main categories: creational, structural, and behavioral.

A class has one and only one instance, with Java and Go implementations including eager, lazy, DCL, static-inner-class, enum, mutex, and sync.Once approaches.

The proxy pattern adds functionality around an existing class or function without changing the original code, with static, dynamic, AOP, Go, and cache-proxy examples.

The template-method pattern applies when the overall algorithm steps are fixed while some parts vary, with Java and Go implementations and a combined template/factory/strategy example.

The factory-method pattern uses multiple factory classes and delays concrete product creation to subclasses.

The state pattern selects different processing logic according to the current state, with Java and Go examples.

The builder pattern constructs a complex object from many smaller parts; the builder creates the parts and the director assembles them.

The strategy pattern selects one of several algorithms for accomplishing the same task according to a type or context, with Java and Go examples.

The observer pattern broadcasts state changes from a subject to observers, with Java, Go, and application examples.

The decorator pattern adds new functionality to a class or function without changing the original code, with Java and Go examples.

The chain-of-responsibility pattern links handlers that can process the same type of request, with Java, Go, and filter-chain examples.

The adapter pattern is used to make an old-system interface compatible with a new interface, with Java and Go examples.

Reference links for Go pipeline fan-out and fan-in concurrency patterns.

Reference link for the Go pipeline concurrency model.

Prototype-pattern notes with UML, Java and Go clone examples, plus a generic DAO example that returns cloned data.

Abstract-factory notes showing related product families and a Go implementation with engines, wheels, factories, and a client.

Simple-factory notes in Java and Go, followed by a generic template-method + simple-factory + strategy example.

A short interview-style note on where singleton, prototype, factory, builder, facade, decorator, template method, state, strategy, and proxy patterns were used.

Flyweight-pattern notes with UML and a Java example using a chess-object pool.

Facade-pattern notes with UML plus Java and Go examples that wrap a complex process behind one interface.

Bridge-pattern notes for class hierarchies with multiple varying dimensions, with UML and a Java brand/device example.

Composite-pattern notes for tree-shaped whole/part structures, with Java and Go file-tree examples.

Mediator-pattern notes with UML, a Java department example, and a Go computer-component example.

Command-pattern notes with a Java Course example, command objects, and a command invoker.

Memento-pattern notes showing how to save an object's state and restore it later.

A minimal original note for the interpreter design pattern.

Visitor-pattern notes separating data structures from operations, with a Java course example.

Iterator-pattern notes showing Java and Go implementations for traversing aggregate objects.

A short index note linking object-oriented design principles and design patterns.

A short index of procedural, event-driven, object-oriented, and functional programming paradigms.