В поведенческих паттернах проектирования паттерн «Состояние» и паттерн «Стратегия» — близкие братья; они очень похожи. Давайте сначала посмотрим на их общую диаграмму классов и сравним их бок о бок, как показано на рисунке:

Они выглядят очень похоже, не правда ли? Глядя только на эту UML-диаграмму, мы не можем определить разницу. Далее давайте объединим примеры, чтобы сравнить различия между ними. Пример ниже взят из «Head First Design Patterns».
Паттерн «Стратегия»
Паттерн «Стратегия» определяет семейство алгоритмов, инкапсулирует каждый из них и делает их взаимозаменяемыми. Этот паттерн позволяет алгоритму изменяться независимо от клиентов, которые его используют.
Компания разработала игру про уток, в которой есть разные виды уток: кряквы, красноголовые нырки, резиновые утки... Как реализовать этих уток в программе? Глядя на этот сценарий, легко подумать о том, чтобы сначала определить суперкласс Duck для всех уток и инкапсулировать в нём общие методы и свойства. Например, все утки умеют плавать, и у всех уток есть свой внешний вид:
Пример
public void swim(){
System.out.println("All duck can swim!");
}
public abstract void display();
public void fly(){
System.out.println("Fly~~~");
}
public void quack(){
System.out.println("Quack quack quack~");
}
}
Но вскоре мы обнаруживаем проблему с этим определением суперкласса. Не все утки умеют летать, и не все утки крякают (предположим, резиновые утки пищат). Пока они наследуют этот суперкласс, все утки будут летать, и все утки будут крякать.
Что делать?
Решение 1
Первое решение, которое приходит в голову, — переопределение методов в подклассах. Просто: нужно лишь переопределить метод fly в подклассах, которые не умеют летать.
Но недостаток очевиден: разве всем нелетающим подклассам не придётся переопределять его? Предположим, 50 видов уток не умеют летать; насколько огромным будет объём переписывания и сопровождения?
Решение 2
Хорошо, значит, рассмотрим второй способ: продолжить проектирование абстрактных подклассов, например абстрактный подкласс FlyNoQuackDuck, который умеет летать, но не крякать, абстрактный подкласс QuackNoFlyDuck, который умеет крякать, но не летать, абстрактный подкласс NoQuackNoFlyDuck, который не умеет ни крякать, ни летать, абстрактный подкласс FlyAndQuackDuck, который умеет и летать, и крякать...
По мере написания мы обнаруживаем, что и этот способ не работает: он слишком негибкий, и чем больше частей изменяется, тем больше таких абстрактных подклассов нам нужно определять.
Решение 3
Тогда какой способ хорош? Мы размышляем, что вышеописанная проблема возникает потому, что мы по привычке пытаемся реализовать изменяющиеся части с помощью наследования. На самом деле мы можем выделить изменяющиеся части и реализовать их с помощью композиции.
Здесь используются три принципа проектирования:
- Выявите аспекты вашего приложения, которые могут изменяться, и отделите их.
- Программируйте под интерфейс, а не под реализацию.
- Предпочитайте композицию наследованию.
Применяя первый принцип проектирования, мы отделяем изменяющиеся методы fly() и quack() и инкапсулируем их в два интерфейса поведения. Затем, исходя из разных потребностей, мы проектируем разные классы поведения, реализующие эти интерфейсы.

Применяя второй и третий принципы проектирования, мы включаем в класс Duck два интерфейса в качестве переменных-членов и динамически назначаем их в подклассах.

Общая "диаграмма классов" выглядит следующим образом:

Итог
Это решение идеально решает нашу проблему. Используя идею "паттерна Стратегия", мы выделяем изменяющиеся части и компонуем их в класс. В зависимости от разных подклассов мы можем "устанавливать" различные подклассы поведения, чтобы динамически изменять поведение.
Реализация кода
Два класса интерфейсов поведения
Пример
public void fly();
}
public interface QuackBehavior {
public void quack();
}
Различные классы поведения, реализующие интерфейс полета
Пример
public void fly(){
System.out.println("Я не могу летать...");
}
}
public class FlyWithWings implements FlyBehavior{
public void fly(){
System.out.println("Fly~~~");
}
}
public class FlyWithRocket implements FlyBehavior{
public void fly(){
System.out.println("С ракетной установкой, летим~~~");
}
}
Различные классы поведения, реализующие кряканье
Пример
public void quack(){
System.out.println("Quack quack quack~");
}
}
public class Squeak implements QuackBehavior{
public void quack(){
System.out.println("Писк писк писк~");
}
}
public class MuteQuack implements QuackBehavior{
public void quack(){
System.out.println("Я не могу крякать...");
}
}
Суперкласс, скомпонованный с реализующими интерфейсами
Пример
protected FlyBehavior flyBehavior;
protected QuackBehavior quackBehavior;
public void swim(){
System.out.println("All duck can swim!");
}
public abstract void display();
/**
* Динамически изменять поведение полёта
*/
public void setFlyBehavior(FlyBehavior flyBehavior) {
this.flyBehavior = flyBehavior;
}
/**
* Динамически изменять поведение кряканья
*/
public void setQuackBehavior(QuackBehavior quackBehavior) {
this.quackBehavior = quackBehavior;
}
public void performFly(){
flyBehavior.fly();
}
public void performQuack(){
quackBehavior.quack();
}
}
Различные классы уток
Пример
* Утка-кряква
*/
public class MallarDuck extends Duck{
public MallarDuck() {
//Может летать
flyBehavior = new FlyWithWings();
//Крякает
quackBehavior = new Quack();
}
@Override
public void display() {
System.out.println("Похоже на крякву");
}
}
/**
* Красноголовая утка
*/
public class RedHeadDuck extends Duck{
public RedHeadDuck() {
//Может летать
flyBehavior = new FlyWithWings();
//Крякает
quackBehavior = new Quack();
}
@Override
public void display() {
System.out.println("Похоже на красноголовую утку");
}
}
/**
* Резиновая утка
*/
public class RubberDuck extends Duck{
public RubberDuck() {
//Не умеет летать
flyBehavior = new FlyNoWay();
//Пищит
quackBehavior = new Squeak();
}
@Override
public void display() {
System.out.println("Похоже на резиновую утку");
}
}
Паттерн «Состояние»
Паттерн Состояние позволяет объекту изменять своё поведение при изменении его внутреннего состояния. Может показаться, что объект меняет свой класс.
Паттерн Состояние очень похож на паттерн Стратегия. Он также инкапсулирует «состояние» класса и автоматически переключает его при выполнении действий, так что одно и то же действие класса в разных состояниях даёт разные результаты. Отличие от паттерна Стратегия в том, что этот переход является «автоматическим» и «неосознанным».
Диаграмма классов паттерна Состояние выглядит следующим образом

Диаграмма классов паттерна Состояние точно такая же, как у паттерна Стратегия; различие заключается в их назначении. Паттерн Стратегия управляет тем, какую стратегию использует объект, а паттерн Состояние автоматически изменяет состояние. Вам должно стать ясно после прочтения приведённого ниже примера.
Теперь у вас есть требование к автомату по продаже конфет, и его нужно реализовать на Java.
Давайте проанализируем его. Функциональность автомата по продаже конфет можно разделить на четыре действия и четыре состояния, как показано на рисунке ниже:

В разных состояниях одно и то же действие даёт разные результаты. Например, в состоянии «вставлено 25 центов» поворот рукоятки выдаст конфету; но в состоянии «нет 25 центов» поворот рукоятки предложит сначала вставить монету.
Немного подумав, мы пишем следующий код реализации автомата по продаже конфет
Пример
/*
* Четыре состояния
*/
/**Состояние без монеты*/
private final static int NO_QUARTER = 0;
/**Состояние вставленной монеты*/
private final static int HAS_QUARTER = 1;
/**Состояние «продано»*/
private final static int SOLD = 2;
/**Состояние «распродано»*/
private final static int SOLD_OUT = 3;
private int state = SOLD_OUT;
private int candyCount = 0;
public NoPatternGumballMachine(int count) {
this.candyCount = count;
if(candyCount > 0)
state = NO_QUARTER;
}
/*
* Четыре действия
*/
/**
* Вставить монету
*/
public void insertQuarter() {
if(NO_QUARTER == state){
System.out.println("Вставьте монету");
state = HAS_QUARTER;
}
else if(HAS_QUARTER == state){
System.out.println("Пожалуйста, не вставляйте монету повторно!");
returnQuarter();
}
else if(SOLD == state){
System.out.println("Монета вставлена, пожалуйста, ожидайте конфету");
returnQuarter();
}else if(SOLD_OUT == state){
System.out.println("Конфеты закончились");
returnQuarter();
}
}
/**
* Вернуть монету
*/
public void ejectQuarter() {
if(NO_QUARTER == state){
System.out.println("Нет монеты, невозможно вернуть");
}
else if(HAS_QUARTER == state){
returnQuarter();
state = NO_QUARTER;
}
else if(SOLD == state){
System.out.println("Невозможно вернуть монету, идёт выдача конфеты, пожалуйста, подождите");
}else if(SOLD_OUT == state){
System.out.println("Монета не вставлена, невозможно вернуть монету");
}
}
/**
* Повернуть ручку, чтобы выдать конфету
*/
public void turnCrank() {
if(NO_QUARTER == state){
System.out.println("Пожалуйста, сначала вставьте монету");
}
else if(HAS_QUARTER == state){
System.out.println("Поверните рукоятку, готово к выдаче конфеты");
state = SOLD;
}
else if(SOLD == state){
System.out.println("Рукоятка уже повёрнута, пожалуйста, подождите");
}else if(SOLD_OUT == state){
System.out.println("Конфеты закончились");
}
}
/**
* Выдача конфеты
*/
public void dispense() {
if(NO_QUARTER == state){
System.out.println("Монета не вставлена, невозможно выдать конфету");
}
else if(HAS_QUARTER == state){
System.out.println("этот метод не поддерживается");
}
else if(SOLD == state){
if(candyCount > 0){
System.out.println("Выдача конфеты");
candyCount --;
state = NO_QUARTER;
}
else{
System.out.println("Извините, конфеты закончились");
state = SOLD_OUT;
}
}else if(SOLD_OUT == state){
System.out.println("Извините, конфеты закончились");
}
}
/**
* Возврат монеты
*/
protected void returnQuarter() {
System.out.println("Возврат монеты...");
}
}
Как видно из кода, автомат по продаже конфет выдает разные результаты для соответствующих действий в зависимости от своего текущего состояния. Этот код уже может соответствовать нашим базовым требованиям, но если немного подумать, вы почувствуете, что этот код реализации кажется слишком сложным, обладает плохой расширяемостью и лишен объектно-ориентированного стиля.
Предположим, новое требование заставляет нас добавить состояние; тогда нам нужно изменить каждый метод действия и каждый раз добавлять еще один оператор else. А если требования изменятся и действие в некотором состоянии нужно будет изменить, нам также придется одновременно менять четыре метода. Такая работа была бы утомительной и вызывала бы головную боль.
Что делать? Один из шести принципов проектирования
Выявите аспекты вашего приложения, которые могут изменяться, и отделите их.
В автомате по продаже конфет состояние — это та часть, которая постоянно меняется; разные состояния имеют разные действия. Мы вполне можем его выделить.

Новая идея проектирования такова:
Сначала мы определяем интерфейс State. В этом интерфейсе для каждого действия автомата по продаже конфет есть соответствующий метод.
Затем реализуем класс состояния для каждого состояния автомата. Эти классы будут отвечать за поведение автомата в соответствующем состоянии.
Наконец, нам нужно избавиться от старого условного кода и заменить его делегированием действий классам состояний.
Определить интерфейс State
Пример
/**
* Вставить монету
*/
public abstract void insertQuarter();
/**
* Вернуть монету
*/
public abstract void ejectQuarter();
/**
* Повернуть ручку, чтобы выдать конфету
*/
public abstract void turnCrank();
/**
* Выдача конфеты
*/
public abstract void dispense();
/**
* Возврат монеты
*/
protected void returnQuarter() {
System.out.println("Возврат монеты...");
}
}
Реализуйте классы состояний для каждого состояния автомата
Пример
* Состояние «Нет монеты»
*/
public class NoQuarterState extends State{
GumballMachine gumballMachine;
public NoQuarterState(GumballMachine gumballMachine) {
this.gumballMachine = gumballMachine;
}
@Override
public void insertQuarter() {
System.out.println("Вы вставили монету");
//Переход в состояние «монета вставлена»
gumballMachine.setState(gumballMachine.hasQuarterState);
}
@Override
public void ejectQuarter() {
System.out.println("Нет монеты, невозможно вернуть");
}
@Override
public void turnCrank() {
System.out.println("Пожалуйста, сначала вставьте монету");
}
@Override
public void dispense() {
System.out.println("Монета не вставлена, невозможно выдать конфету");
}
}
/**
* Состояние вставленной монеты
*/
public class HasQuarterState extends State{
GumballMachine gumballMachine;
public HasQuarterState(GumballMachine gumballMachine) {
this.gumballMachine = gumballMachine;
}
@Override
public void insertQuarter() {
System.out.println("Пожалуйста, не вставляйте монету повторно!");
returnQuarter();
}
@Override
public void ejectQuarter() {
returnQuarter();
gumballMachine.setState(gumballMachine.noQuarterState);
}
@Override
public void turnCrank() {
System.out.println("Поверните рукоятку, готово к выдаче конфеты");
gumballMachine.setState(gumballMachine.soldState);
}
@Override
public void dispense() {
System.out.println("этот метод не поддерживается");
}
}
/**
* Состояние продажи
*/
public class SoldState extends State{
GumballMachine gumballMachine;
public SoldState(GumballMachine gumballMachine) {
this.gumballMachine = gumballMachine;
}
@Override
public void insertQuarter() {
System.out.println("Монета вставлена, пожалуйста, ожидайте конфету");
returnQuarter();
}
@Override
public void ejectQuarter() {
System.out.println("Невозможно вернуть монету, идёт выдача конфеты, пожалуйста, подождите");
}
@Override
public void turnCrank() {
System.out.println("Рычаг уже повёрнут, пожалуйста, подождите");
}
@Override
public void dispense() {
int candyCount = gumballMachine.getCandyCount();
if(candyCount > 0){
System.out.println("Выдача одной конфеты");
candyCount--;
gumballMachine.setCandyCount(candyCount);
if(candyCount > 0){
gumballMachine.setState(gumballMachine.noQuarterState);
return;
}
}
System.out.println("Извините, конфеты закончились");
gumballMachine.setState(gumballMachine.soldOutState);
}
}
/**
* Состояние «распродано»
*/
public class SoldOutState extends State{
GumballMachine gumballMachine;
public SoldOutState(GumballMachine gumballMachine) {
this.gumballMachine = gumballMachine;
}
@Override
public void insertQuarter() {
System.out.println("Конфеты закончились");
returnQuarter();
}
@Override
public void ejectQuarter() {
System.out.println("Монета не вставлена, невозможно вернуть монету");
}
@Override
public void turnCrank() {
System.out.println("Конфеты закончились");
}
@Override
public void dispense() {
System.out.println("Конфеты закончились");
}
}
Делегировать действия автомата с конфетами классу состояния
Пример
public State noQuarterState = new NoQuarterState(this);
public State hasQuarterState = new HasQuarterState(this);
public State soldState = new SoldState(this);
public State soldOutState = new SoldOutState(this);
private State state = soldOutState;
private int candyCount = 0;
public GumballMachine(int count) {
this.candyCount = count;
if(count > 0)
setState(noQuarterState);
}
@Override
public void insertQuarter() {
state.insertQuarter();
}
@Override
public void ejectQuarter() {
state.ejectQuarter();
}
@Override
public void turnCrank() {
state.turnCrank();
}
@Override
public void dispense() {
state.dispense();
}
public void setState(State state) {
this.state = state;
}
public State getState() {
return state;
}
public void setCandyCount(int candyCount) {
this.candyCount = candyCount;
}
public int getCandyCount() {
return candyCount;
}
}
Видно, что при таком дизайне автомату по продаже конфет совсем не нужно знать об изменениях состояния; ему нужно только вызывать методы состояния. Изменения состояния происходят внутри состояния. Это «Паттерн Состояние».
Если на этом этапе добавить ещё одно состояние, конфетному автомату не нужно вносить никаких изменений; нам нужно только добавить ещё один класс состояния, а затем добавить процесс перехода в методы соответствующего класса состояния.
Не поняли? Есть также статья о паттерне «Состояние»:https://dzone.com/articles/state-pattern-simplified
Оригинальная ссылка: https://blog.csdn.net/z55887/article/details/73198039
Оригинальная ссылка: https://blog.csdn.net/z55887/article/details/60608898