文章目录
- 一、设计模式分类
- 二、创建型设计模式
- 三、结构性设计模式
- 四、行为型设计模式
- 五、杂题
- 六、设计模式意图及适用性(表格版)
- 七、设计模式意图及适用性(文字版)
一、设计模式分类
- 创建型对象:抽生原单 4
- 结构型对象:适桥组装外享代 7
- 行为型对象:责命迭终备观状策访 9
真题1
二、创建型设计模式
模式 | 意图 |
---|---|
工厂方法 | 定义一个用于创建对象的接口,让子类决定实例化哪一个类 |
抽象工厂 | 提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类 |
生成器模式 | 将一个复杂对象的构建与它的表示分类,使得同样的构建过程可以创建不同的表示 |
原型模式 | 用原型实例指定创建对象的种类,并且通过复制这些原型对象创建新的对象 |
单例模式 | 保证一个类仅有一个实例,并提供一个访问它的全局访问点 |
2.0、简单工厂模式
class Factory {
public void createProduct(Product product) {
product.info();
}
}
abstract class Product {
public abstract void info();
}
class ProductA extends Product {
@Override
public void info() {
System.out.println("产品信息:A");
}
}
class ProductB extends Product {
@Override
public void info() {
System.out.println("产品信息:B");
}
}
public class SimpleFactory {
public static void main(String[] args) {
Factory factory = new Factory();
Product productA = new ProductA();
Product productB = new ProductB();
factory.createProduct(productA);
factory.createProduct(productB);
}
}
// 产品信息:A
// 产品信息:B
2.1、工厂方法模式(Factory Method)
interface Product {
void info();
}
class ProductA implements Product {
@Override
public void info() {
System.out.println("产品信息:A");
}
}
class ProductB implements Product {
@Override
public void info() {
System.out.println("产品信息:B");
}
}
interface Factory {
Product createProduct();
}
class FactoryA implements Factory {
@Override
public Product createProduct() {
return new ProductA();
}
}
class FactoryB implements Factory {
@Override
public Product createProduct() {
return new ProductB();
}
}
public class SimpleFactory {
public static void main(String[] args) {
Factory factoryA = new FactoryA();
Product productA = factoryA.createProduct();
productA.info();
Factory factoryB = new FactoryB();
Product productB = factoryB.createProduct();
productB.info();
}
}
2.2、抽象工厂模式(Abstract Factory)
1、定义
interface Factory {
// 手机
ProductA createProductA();
// 平板
ProductB createProductB();
}
// 苹果工厂
class Factory1 implements Factory {
// 苹果手机
@Override
public ProductA createProductA() {
return new ProductA1();
}
// 苹果平板
@Override
public ProductB createProductB() {
return new ProductB1();
}
}
// 小米工厂
class Factory2 implements Factory {
// 小米手机
@Override
public ProductA createProductA() {
return new ProductA2();
}
// 小米平板
@Override
public ProductB createProductB() {
return new ProductB2();
}
}
// 手机
interface ProductA {
void info();
}
class ProductA1 implements ProductA {
@Override
public void info() {
System.out.println("产品信息:A1");
}
}
class ProductA2 implements ProductA {
@Override
public void info() {
System.out.println("产品信息:A2");
}
}
// 平板
interface ProductB {
void info();
}
class ProductB1 implements ProductB {
@Override
public void info() {
System.out.println("产品信息:B1");
}
}
class ProductB2 implements ProductB {
@Override
public void info() {
System.out.println("产品信息:B2");
}
}
public class SimpleFactory {
public static void main(String[] args) {
Factory factory1 = new Factory1();
Factory factory2 = new Factory2();
ProductA productA1 = factory1.createProductA();
ProductB productB1 = factory1.createProductB();
productA1.info();
productB1.info();
ProductA productA2 = factory2.createProductA();
ProductB productB2 = factory2.createProductB();
productA2.info();
productB2.info();
}
}
2、上午真题
真题1
真题2
2、下午真题
真题1
解析
2.3、生成器模式(Builder)
1、定义
2、上午真题
真题1
真题2
真题3
3、下午真题
真题1
2.4、原型模式(Prototype)
1、定义
interface Prototype {
Object clone();
}
class Product implements Prototype {
private int id;
private String name;
public Product() {
}
public Product(int id, String name) {
this.id = id;
this.name = name;
}
@Override
public String toString() {
return id + " " + name;
}
@Override
public Object clone() {
Product obj = new Product();
obj.id = this.id;
obj.name = this.name;
return obj;
}
}
public class Test01 {
public static void main(String[] args) {
Product a = new Product(1, "A");
Product clone = (Product) a.clone();
System.out.println(a);
System.out.println(clone);
}
}
2、下午真题
真题1
解析
2.5、单例模式(Singleton)
真题1
真题2
真题3
三、结构性设计模式
模式 | 意图 |
---|---|
适配器模式 | 将一个类的接口转换成客户希望的另一个接口 |
桥接模式 | 将抽象与其实现部分分类,使他们都可以独立的变化 |
组合模式 | 将对象组合成树形模式以表示 部分与整体 |
装饰模式 | 动态地给一个对象添加额外的职责 |
外观模式 | 为子系统中的一组接口提供一个一致的接口,Facade模式定义了一个高层接口,这个接口使得这一子系统更加容易使用 |
享元模式 | 运用共享技术有效地支持大量细粒度的对象 |
代理模式 | 为其他对象提供一种代理以控制对这个对象的访问 |
3.1、适配器模式(Adapter)
1、定义
客户使用Lighting接口的手机,适配器继承该手机的充电方式并将其转为TypeC
// 客户使用的手机
class Lighting {
public void Request() {
System.out.println("Lighting数据线");
}
}
// 适配器
class Adapter extends Lighting {
private TypeC typeC = new TypeC();
@Override
public void Request() {
typeC.SpecificRequest();
}
}
// 数据线
class TypeC {
public void SpecificRequest() {
System.out.println("TypeC数据线");
}
}
public class Test01 {
public static void main(String[] args) {
Lighting lighting = new Adapter();
lighting.Request();
}
}
2、上午真题
真题
3、下午真题
解析
3.2、桥接模式(Bridge)
1、定义
抽象部分调用实现部分
public class Test01 {
public static void main(String[] args) {
Product productA = new ProductA();
Product productB = new ProductA();
Color red = new Red();
Color blue = new Blue();
productA.setName("裙子");
productA.setColor(red);
productA.Operation();
productB.setName("裤子");
productB.setColor(blue);
productB.Operation();
}
}
// 抽象
abstract class Product {
private String name;
protected Color color;
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setColor(Color color) {
this.color = color;
}
public abstract void Operation();
}
// 抽象部分
class ProductA extends Product {
@Override
public void Operation() {
color.OperationImp(this.getName());
}
}
// 接口
interface Color {
public void OperationImp(String name);
}
// 实现部分
class Red implements Color {
@Override
public void OperationImp(String name) {
System.out.println(name + ":红色");
}
}
// 实现部分
class Blue implements Color {
@Override
public void OperationImp(String name) {
System.out.println(name + ":蓝色");
}
}
裙子:红色
裤子:蓝色
2、上午真题
真题1
真题2
真题3
3、下午真题
真题1
解析
真题2
解析
3.3、组合模式(Composite)
1、定义
abstract class AbstractFile {
protected String name;
public void printName() {
System.out.println(name);
}
public abstract boolean add(AbstractFile abstractFile);
public abstract boolean remove(AbstractFile abstractFile);
public abstract List<AbstractFile> getChildren();
}
class Folder extends AbstractFile {
private List<AbstractFile> childrenList = new ArrayList<>();
public Folder(String name) {
this.name = name;
}
@Override
public boolean add(AbstractFile abstractFile) {
return childrenList.add(abstractFile);
}
@Override
public boolean remove(AbstractFile abstractFile) {
return childrenList.remove(abstractFile);
}
@Override
public List<AbstractFile> getChildren() {
return childrenList;
}
}
class File extends AbstractFile {
public File(String name) {
this.name = name;
}
@Override
public boolean add(AbstractFile abstractFile) {
return false;
}
@Override
public boolean remove(AbstractFile abstractFile) {
return false;
}
@Override
public List<AbstractFile> getChildren() {
return null;
}
}
public class Test01 {
public static void main(String[] args) {
AbstractFile root = new Folder("root");
AbstractFile foldA = new Folder("FoldA");
AbstractFile fileA1 = new File("fileA1");
AbstractFile fileB = new File("fileB1");
root.add(fileB);
root.add(foldA);
foldA.add(fileA1);
print(root);
}
static void print(AbstractFile abstractFile) {
// 打印当前文件夹/文件
abstractFile.printName();
// 获取子文件夹/文件
List<AbstractFile> children = abstractFile.getChildren();
if (children == null) return;
for (AbstractFile file : children) {
print(file);
}
}
}
2、上午真题
真题1
真题2
真题3
3、下午真题
真题1
解析
真题2
解析
真题3
解析
真题4
3.4、装饰模式(Decorator)
1、定义
abstract class Decorator extends Person {
protected Person person;
}
// 装饰器A
class DecoratorA extends Decorator {
public DecoratorA(Person person) {
this.person = person;
}
@Override
public void operation() {
person.operation(); // 原本的职责
System.out.println("装饰器A新职责:写作业");
}
}
class DecoratorB extends Decorator {
public DecoratorB(Person person) {
this.person = person;
}
@Override
public void operation() {
person.operation(); // 原本的职责
System.out.println("装饰器B新职责:做家务");
}
}
abstract class Person {
protected String name;
public abstract void operation(); // 职责
}
class Student extends Person {
public Student(String name) {
this.name = name;
}
@Override
public void operation() {
System.out.println(name + "的职责:学习");
}
}
public class Test01 {
public static void main(String[] args) {
Person zs = new Student("zs");
zs.operation();
System.out.println("================");
zs = new DecoratorB(new DecoratorA(zs));
zs.operation();
}
}
zs的职责:学习
================
zs的职责:学习
装饰器B新职责:做家务
装饰器A新职责:写作业
2、上午真题
真题
3、下午真题
2012上
解析
2016下
解析
3.5、外观模式(Facade)
真题1
真题2
3.6、享元模式(Flyweight)
1、定义
abstract class Piece {
protected String color;
public abstract void draw(int x, int y);
}
class PieceFactory {
private Piece[] pieces = {
new WhitePiece(), new BlackPiece()};
public Piece getPiece(int key) {
if (key == 0) return pieces[0];
else return pieces[1];
}
}
class WhitePiece extends Piece {
public WhitePiece() {
this.color = "while";
}
@Override
public void draw(int x, int y) {
System.out.println("draw a color:" + color + "piece x:" + x + "y" + y);
}
}
class BlackPiece extends Piece {
public BlackPiece() {
this.color = "black";
}
@Override
public void draw(int x, int y) {
System.out.println("draw a color:" + color + "piece x:" + x + "y" + y);
}
}
public class Test01 {
public static void main(String[] args) {
PieceFactory factory = new PieceFactory();
Piece white = factory.getPiece(0);
System.out.println(white);
Piece black = factory.getPiece(1);
System.out.println(black);
}
}
com.laptoy.structure.flyweight.WhitePiece@1b6d3586
com.laptoy.structure.flyweight.BlackPiece@4554617c
1、上午真题
真题1
2、下午真题
2021下
解析
3.7、代理模式(Proxy)
真题1
四、行为型设计模式
4.1、责任链模式(Chain of Responsibility)
4.2、命令模式(Command)
1、定义
class Invoke {
// 请求者
private Command command;
public void setCommand(Command command) {
this.command = command;
}
public void call() {
command.execute();
}
}
interface Command {
void execute();
}
class OnCommand implements Command {
private Tv tv;
private Computer computer;
public OnCommand(Tv tv, Computer computer) {
this.tv = tv;
this.computer = computer;
}
@Override
public void execute() {
tv.OnAction();
computer.OnAction();
}
}
class OffCommand implements Command {
private Tv tv;
private Computer computer;
public OffCommand(Tv tv, Computer computer) {
this.tv = tv;
this.computer = computer;
}
@Override
public void execute() {
tv.OffAction();
computer.OffAction();
}
}
class Tv {
public void OnAction() {
System.out.println("电视机开机了...");
}
public void OffAction() {
System.out.println("电视机关机了...");
}
}
class Computer {
public void OnAction() {
System.out.println("电脑开机了...");
}
public void OffAction() {
System.out.println("电脑关机了...");
}
}
public class Test01 {
public static void main(String[] args) {
Tv tv = new Tv();
Computer computer = new Computer();
Command onCommand = new OnCommand(tv, computer);
Command offCommand = new OffCommand(tv, computer);
Invoke invoke = new Invoke();
invoke.setCommand(onCommand);
invoke.call();
invoke.setCommand(offCommand);
invoke.call();
}
}
电视机开机了...
电脑开机了...
电视机关机了...
电脑关机了...
2、上午真题
真题1
真题2
3、下午真题
2014下
解析
4.3、解释器模式(Interpreter)
4.4、迭代器模式(Iterator)
4.5、中介模式(Mediator)
1、定义
abstract class Colleague {
protected Mediator mediator;
}
class Colleague1 extends Colleague {
public Colleague1(Mediator mediator) {
this.mediator = mediator;
}
public void sendMessage(String message) {
mediator.sendMessage(message, this);
}
public void notify(String message) {
System.out.println("同事1收到消息" + message);
}
}
class Colleague2 extends Colleague {
public Colleague2(Mediator mediator) {
this.mediator = mediator;
}
public void sendMessage(String message) {
mediator.sendMessage(message, this);
}
public void notify(String message) {
System.out.println("同事2收到消息" + message);
}
}
abstract class Mediator {
public abstract void sendMessage(String message, Colleague colleague);
}
class ConcreteMediator extends Mediator {
private Colleague1 colleague1;
private Colleague2 colleague2;
public void setColleague1(Colleague1 colleague1) {
this.colleague1 = colleague1;
}
public void setColleague2(Colleague2 colleague2) {
this.colleague2 = colleague2;
}
@Override
public void sendMessage(String message, Colleague colleague) {
if (colleague == colleague1) {
// 让2接 收消息
colleague2.notify(message);
} else {
// 让1接收消息
colleague1.notify(message);
}
}
}
public class Test01 {
public static void main(String[] args) {
ConcreteMediator mediator = new ConcreteMediator();
Colleague1 colleague1 = new Colleague1(mediator);
Colleague2 colleague2 = new Colleague2(mediator);
mediator.setColleague1(colleague1);
mediator.setColleague2(colleague2);
colleague1.sendMessage("Hello C2 I am C1");
colleague2.sendMessage("Hello C1 I am C2");
}
}
同事2收到消息Hello C2 I am C1
同事1收到消息Hello C1 I am C2
2、上午真题
真题
3、下午真题
4.6、备忘录模式(Memento)
4.7、观察者模式(Observer)
1、定义
interface Subject {
void Attach(Observer observer);
void Detach(Observer observer);
void Notify();
String getState();
void setState(String state);
}
class ConcreteSubject implements Subject {
private String state;
private List<Observer> observerList;
public ConcreteSubject() {
state = "订阅成功"; // 初始状态
observerList = new ArrayList<>();
}
@Override
public void Attach(Observer observer) {
observerList.add(observer);
}
@Override
public void Detach(Observer observer) {
observerList.remove(observer);
}
@Override
public void Notify() {
for (Observer observer : observerList) {
observer.update();
}
}
@Override
public String getState() {
return state;
}
@Override
public void setState(String state) {
this.state = state;
Notify(); // 通知所有观察者更新信息
}
}
interface Observer {
void update();
void getState();
}
class ConcreteObserver implements Observer {
private String state;
private Subject subject;
// 目标绑定观察者
public ConcreteObserver(Subject subject) {
this.subject = subject;
subject.Attach(this);
state = subject.getState();
}
public void getState() {
System.out.println(state);
}
@Override
public void update() {
state = subject.getState(); // 保持状态一致
System.out.println("您订阅的频道更新啦:" + state);
}
}
public class Test01 {
public static void main(String[] args) {
Subject subject = new ConcreteSubject();
Observer observer = new ConcreteObserver(subject); // 创建观察者并订阅目标
observer.getState();
subject.setState("设计模式入门到精通");
}
}
订阅成功
您订阅的频道更新啦:设计模式入门到精通
2、上午真题
真题1
真题4
真题5
3、下午真题
真题1
解析
真题2
解析
4.8、状态模式(State)
1、定义
public class Test01 {
public static void main(String[] args) {
Context context = new Context();
context.Request();
context.Request();
context.Request();
context.Request();
}
}
class Context {
private int count;
private State state;
public Context() {
count = 3;
state = new StateA();
}
public void Request() {
// 购买一个饮料
state.Handle(this);
}
public int getCount() {
return count;
}
public void setCount(int count) {
this.count = count;
}
public State getState() {
return state;
}
public void setState(State state) {
this.state = state;
}
}
interface State {
public void Handle(Context context);
}
class StateA implements State {
// 有货
@Override
public void Handle(Context context) {
int count = context.getCount();
if (count >= 1) {
System.out.println("购买成功!");
context.setCount(count - 1);
}
if (context.getCount() == 0) {
System.out.println("售货机状态改变:缺货状态");
context.setState(new StateB());
}
}
}
class StateB implements State {
// 无货
@Override
public void Handle(Context context) {
int count = context.getCount();
if (count == 0) {
System.out.println("购买失败!等待补货");
context.setCount(5);
System.out.println("售货机状态改变:有货状态,请重新购买");
context.setState(new StateA());
}
}
}
2、上午真题
真题1
真题2
3、下午真题
真题1
解析
真题2
解析
4.9、策略模式(Strategy)
1、定义
class OperationContext {
private Strategy strategy;
public OperationContext(Strategy strategy) {
this.strategy = strategy;
}
// 两数相加
public void operation(int a, int b) {
strategy.TwoNumberOperation(a, b);
}
}
// 算法策略接口
interface Strategy {
void TwoNumberOperation(int a, int b);
}
// 加法策略
class AddStrategy implements Strategy {
@Override
public void TwoNumberOperation(int a, int b) {
System.out.println("加法策略:" + (a + b));
}
}
// 减法策略
class SubStrategy implements Strategy {
@Override
public void TwoNumberOperation(int a, int b) {
System.out.println("减法策略:" + (a - b));
}
}
public class Test01 {
public static void main(String[] args) {
Strategy add = new AddStrategy();
Strategy sub = new SubStrategy();
OperationContext context1 = new OperationContext(add);
OperationContext context2 = new OperationContext(sub);
context1.operation(1, 2);
context2.operation(1, 2);
}
}
加法策略:3
减法策略:-1
2、上午真题
真题1
真题2
真题3
3、下午真题
真题1
解析
真题2
解析
真题3
解析
4.10、模板方法模式(Template Method)
4.11、访问者模式(Visitor)
1、定义
interface Visitor {
void visitStudent(Student student);
void visitTeacher(Teacher teacher);
}
class Visitor1 implements Visitor {
@Override
public void visitStudent(Student student) {
System.out.println("访问者1访问学生" + student.name);
}
@Override
public void visitTeacher(Teacher teacher) {
System.out.println("访问者1访问老师" + teacher.name);
}
}
class Visitor2 implements Visitor {
@Override
public void visitStudent(Student student) {
System.out.println("访问者2访问学生" + student.name);
}
@Override
public void visitTeacher(Teacher teacher) {
System.out.println("访问者2访问老师" + teacher.name);
}
}
// 对象结构
class PersonStructure {
private List<Person> personList = new ArrayList<>();
public PersonStructure() {
personList.add(new Student("A"));
personList.add(new Student("B"));
personList.add(new Teacher("AA"));
personList.add(new Teacher("BB"));
}
public void Accept(Visitor visitor) {
for (Person person : personList) {
person.Accept(visitor);
}
}
}
abstract class Person {
public String name;
public abstract void Accept(Visitor visitor);
}
class Student extends Person {
public Student(String name) {
this.name = name;
}
@Override
public void Accept(Visitor visitor) {
visitor.visitStudent(this);
}
}
class Teacher extends Person {
public Teacher(String name) {
this.name = name;
}
@Override
public void Accept(Visitor visitor) {
visitor.visitTeacher(this);
}
}
public class Test01 {
public static void main(String[] args) {
PersonStructure structure = new PersonStructure();
Visitor1 visitor1 = new Visitor1();
structure.Accept(visitor1);
System.out.println("===========");
Visitor2 visitor2 = new Visitor2();
structure.Accept(visitor2);
}
}
访问者1访问学生A
访问者1访问学生B
访问者1访问老师AA
访问者1访问老师BB
===========
访问者2访问学生A
访问者2访问学生B
访问者2访问老师AA
访问者2访问老师BB
public class Test01 {
public static void main(String[] args) {
PersonStructure structure = new PersonStructure();
Visitor1 visitor1 = new Visitor1();
structure.Accept(visitor1);
System.out.println("学生年龄的总和:" + visitor1.getStudentAgeSum());
System.out.println("老师年龄的总和:" + visitor1.getTeacherAgeSum());
System.out.println("=============================");
Visitor2 visitor2 = new Visitor2();
structure.Accept(visitor2);
System.out.println("学生分数最高:" + visitor2.getMaxScore());
System.out.println("老师工龄最高:" + visitor2.getMaxWorkYear());
}
}
interface Visitor {
void visitStudent(Student student);
void visitTeacher(Teacher teacher);
}
class Visitor1 implements Visitor {
// 访问者1 分别统计学生和老师的年龄总和
private int studentAgeSum = 0;
private int teacherAgeSum = 0;
public int getStudentAgeSum() {
return studentAgeSum;
}
public int getTeacherAgeSum() {
return teacherAgeSum;
}
@Override
public void visitStudent(Student student) {
System.out.println("访问者1访问学生" + student.getName() + "年龄:" + student.getAge());
studentAgeSum += student.getAge();
}
@Override
public void visitTeacher(Teacher teacher) {
System.out.println("访问者1访问老师" + teacher.getName() + "年龄:" + teacher.getAge());
teacherAgeSum += teacher.getAge();
}
}
class Visitor2 implements Visitor {
// 访问者2 分别求出学生的最高成绩和老师的最高工龄
private int maxScore = -1;
private int maxWorkYear = -1;
public int getMaxScore() {
return maxScore;
}
public int getMaxWorkYear() {
return maxWorkYear;
}
@Override
public void visitStudent(Student student) {
System.out.println("访问者2访问学生" + student.getName() + "成绩:" + student.getScore());
maxScore = Math.max(maxScore, student.getScore());
}
@Override
public void visitTeacher(Teacher teacher) {
System.out.println("访问者2访问老师" + teacher.getName() + "工龄:" + teacher.getWorkYear());
maxWorkYear = Math.max(maxWorkYear, teacher.getWorkYear());
}
}
// 对象结构
class PersonStructure {
private List<Person> personList = new ArrayList<>();
public PersonStructure() {
personList.add(new Student("小明", 10, 70));
personList.add(new Student("小红", 11, 90));
personList.add(new Teacher("王老师", 27, 3));
personList.add(new Teacher("李老师", 29, 4));
}
public void Accept(Visitor visitor) {
for (Person person : personList) {
person.Accept(visitor);
}
}
}
abstract class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public abstract void Accept(Visitor visitor);
}
class Student extends Person {
private int score;
public Student(String name, int age, int score) {
super(name, age);
this.score = score;
}
public int getScore() {
return score;
}
@Override
public void Accept(Visitor visitor) {
visitor.visitStudent(this);
}
}
class Teacher extends Person {
private int workYear;
public Teacher(String name, int age, int workYear) {
super(name, age);
this.workYear = workYear;
}
public int getWorkYear() {
return workYear;
}
@Override
public void Accept(Visitor visitor) {
visitor.visitTeacher(this);
}
}
2、上午真题
真题1
真题2
3、下午真题
解析
五、杂题
真题1
真题2
真题3(适桥组装外享代)
真题4
真题5
真题6
真题7
真题8
六、设计模式意图及适用性(表格版)
七、设计模式意图及适用性(文字版)
1、创建型
2、结构型
3、行为型