在模板模式中，一个抽象类公开定义了执行它的方法的方式模板。它的子类可以按需重写方法实现，但调用将以抽象类中定义的方式进行；
以做饭举例
模板类
package com.vleus.design.behavioral.template;
/**
* @author vleus
* @date 2021年06月06日 15:49
*/
public abstract class CookieTemplate {
/**
* 定义算法：定义好的模板，关键性步骤留给子类实现
*/
public void cook() {
//定义算法步骤
heating();
addFood();
addSalt();
stirfry();
end();
}
//加热方法
public void heating() {
System.out.println("准备开火。。。");
}
//添加食物
public abstract void addFood();
//加盐
public abstract void addSalt();
//翻炒
public void stirfry() {
System.out.println("翻炒中。。。");
}
//出锅
public void end() {
System.out.println("出锅。。。。");
}
}
子类实现模板类
package com.vleus.design.behavioral.template;
/**
* @author vleus
* @date 2021年06月06日 15:53
*/
public class AutoCookMachine extends CookieTemplate{
@Override
public void addFood() {
System.out.println("放了三根娃娃菜。。。");
}
@Override
public void addSalt() {
System.out.println("放了一勺盐。。。");
}
}
测试类
package com.vleus.design.behavioral.template;
/**
* @author vleus
* @date 2021年06月06日 15:54
*/
public class MainTest {
public static void main(String[] args) {
AutoCookMachine autoCookMachine = new AutoCookMachine();
autoCookMachine.cook();
}
}
运行结果
概念：策略（Strategy）模式定义了一系列算法，并将每个算法封装起来，使得它们可以相互替换，且算法的变化不会影响使用算法的客户。属于对象行为模式
以RNG的打游戏的策略为例
环境类，持有策略引用
package com.vleus.design.behavioral.strategy;
/**
* @author vleus
* @date 2021年06月06日 16:04
*/
public class TeamRNG {
//抽取游戏策略算法，并进行引用
private GameStrategy gameStrategy;
public void setGameStrategy(GameStrategy gameStrategy) {
this.gameStrategy = gameStrategy;
}
public void startGame() {
System.out.println("全军出击。。。");
//使用游戏套路
gameStrategy.warStrategy();
System.out.println("Victory。。。。。");
}
}
抽象策略类，定义相关策略方法
package com.vleus.design.behavioral.strategy;
public interface GameStrategy {
//游戏策略方法
void warStrategy();
}
抽象策略类的实现1
package com.vleus.design.behavioral.strategy;
/**
* @author vleus
* @date 2021年06月06日 16:07
*/
public class UziStrategy implements GameStrategy{
@Override
public void warStrategy() {
System.out.println("uzi莽夫式打法获取胜利。。。。");
}
}
抽象策略类的实现2
package com.vleus.design.behavioral.strategy;
/**
* @author vleus
* @date 2021年06月06日 16:07
*/
public class SteadyGameStrategy implements GameStrategy{
@Override
public void warStrategy() {
System.out.println("稳健运营,蚕食对手获取胜利。。。");
}
}
测试类
package com.vleus.design.behavioral.strategy;
/**
* @author vleus
* @date 2021年06月06日 16:08
*/
public class MainTest {
public static void main(String[] args) {
TeamRNG teamRNG = new TeamRNG();
teamRNG.setGameStrategy(new UziStrategy());
teamRNG.startGame();
System.out.println("----------------------");
teamRNG.setGameStrategy(new SteadyGameStrategy());
teamRNG.startGame();
}
}
概念：状态模式，对有状态的对象，把负责的"判断逻辑"提取到不同的状态对象中，允许状态对象在其内部状态发生改变的时候改变其行为；
抽象状态类
package com.vleus.design.behavioral.state;
public interface TeamState {
//玩游戏的状态
void playGame();
//切换到下一个状态
TeamState next();
}
状态实现类1
package com.vleus.design.behavioral.state;
/**
* @author vleus
* @date 2021年06月06日 16:19
*/
public class VocationState implements TeamState{
@Override
public void playGame() {
System.out.println("在三亚度假，真舒服，不想打游戏。。。");
}
//切换到下一个状态
@Override
public TeamState next() {
return new EatBeefNoodlesState();
}
}
状态实现类2
package com.vleus.design.behavioral.state;
/**
* @author vleus
* @date 2021年06月06日 16:20
*/
public class EatBeefNoodlesState implements TeamState{
@Override
public void playGame() {
System.out.println("恰牛肉面恰饱饱。。。。");
}
@Override
public TeamState next() {
return new MatchState();
}
}
状态实现类3
package com.vleus.design.behavioral.state;
/**
* @author vleus
* @date 2021年06月06日 16:18
*/
public class MatchState implements TeamState{
@Override
public void playGame() {
System.out.println("全力以赴打比赛...");
}
@Override
public TeamState next() {
return new VocationState();
}
}
环境类调用
package com.vleus.design.behavioral.state;
/**
* @author vleus
* @date 2021年06月06日 16:17
* @desc 环境类
*/
public class SktTeam {
private TeamState teamState;
public void setTeamState(TeamState teamState) {
this.teamState = teamState;
}
void startGame() {
//状态不同可能会导致不同的游戏结果
teamState.playGame();
}
//下一个状态
void nextState() {
teamState = teamState.next();
}
}
测试类
package com.vleus.design.behavioral.state;
/**
* @author vleus
* @date 2021年06月06日 16:20
*/
public class MainTest {
public static void main(String[] args) {
SktTeam sktTeam = new SktTeam();
VocationState state = new VocationState();
sktTeam.setTeamState(state);
sktTeam.startGame();
sktTeam.nextState();
sktTeam.startGame();
sktTeam.nextState();
sktTeam.startGame();
}
}
网状变星状
概念：用一个中介对象来封装一系列的对象交互，中介者使得各个对象之间不需要显式地互相调用，减少对象间混乱的依赖关系，从而使其耦合松散，而且可以独立地改变他们之间的交互。属于对象行为模式。
概念：定义对象间的一种一对多依赖关系，使得当一个对象状态发生改变时，其相关依赖对象皆得到通知并被自动更新。观察者模式又被成为发布-订阅模式。
核心：被观察对象维护观察对象的引用集合，发生变化的时候通知每一个观察对象即可，就拿tiktok的关注主播为例
抽象主播类：
package com.vleus.design.behavioral.observer;
/**
* @author vleus
* @date 2021年06月06日 17:50
*/
public abstract class AbstractTikToker {
//添加粉丝
abstract void addFans(AbstractFans abstractFans);
//通知粉丝
abstract void notifyFans(String msg);
}
美女主播实现类
package com.vleus.design.behavioral.observer;
import com.vleus.design.structural.flyweight.AbstractWaitressFlyweight;
import java.util.ArrayList;
import java.util.List;
/**
* @author vleus
* @date 2021年06月06日 17:52
*/
public class MMTikToker extends AbstractTikToker {
List<AbstractFans> fansList = new ArrayList<>();
void startSell() {
System.out.println("主播开始卖货了。。。");
notifyFans("我开始卖货了，卖茅台。。。");
}
void enbSell() {
System.out.println("主播货卖完了。。。");
notifyFans("茅台已经卖完了");
}
@Override
void addFans(AbstractFans abstractFans) {
fansList.add(abstractFans);
}
/**
* 通知粉丝
*/
@Override
void notifyFans(String msg) {
//遍历粉丝
for (AbstractFans abstractFans : fansList) {
abstractFans.acceptMsg(msg);
}
}
}
抽象粉丝类
package com.vleus.design.behavioral.observer;
/**
* @author vleus
* @date 2021年06月06日 17:52
*/
public abstract class AbstractFans {
abstract void acceptMsg(String msg);
void follow(AbstractTikToker tikToker) {
//主播增加粉丝
tikToker.addFans(this);
}
}
粉丝实现类
package com.vleus.design.behavioral.observer;
/**
* @author vleus
* @date 2021年06月06日 17:57
*/
public class HumanFans extends AbstractFans{
@Override
void acceptMsg(String msg) {
System.out.println("粉丝说主播说：" +msg);
}
}
测试类
package com.vleus.design.behavioral.observer;
/**
* @author vleus
* @date 2021年06月06日 17:56
*/
public class MainTest {
public static void main(String[] args) {
MMTikToker mmTikToker = new MMTikToker();
mmTikToker.startSell();
HumanFans humanFans1 = new HumanFans();
HumanFans humanFans2 = new HumanFans();
HumanFans humanFans3 = new HumanFans();
humanFans1.follow(mmTikToker);
humanFans2.follow(mmTikToker);
humanFans3.follow(mmTikToker);
System.out.println("---------------------------");
mmTikToker.enbSell();
}
}
