Head First 设计模式 Design Pattern 9-10 Iterator and Composite, State

最新推荐文章于 2026-04-05 09:37:25 发布
原创 最新推荐文章于 2026-04-05 09:37:25 发布 · 1k 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

Section 9 迭代器与组合模式 Iterator and Composite

对象超集合 super collection 聚合 aggregate

>注意remove()在多线程中的状况

 


迭代器模式 提供一种方法顺序访问一个聚合对象中的各个元素, 不暴露其内部的表示.

>内部迭代器, 外部迭代器, 迭代器的数据结构可以是有序的, 无序的, 重复的.

设计原则 一个类应该只有一个引起变化的原因. (单一责任)

>类的每个责任都有改变的潜在区域. 超过一个责任, 意味着超过一个改变的区域.  避免类内的改变, 控制类的维护复杂度.

>内聚 conhesion 度量一个类或模块紧密地达到单一目的或责任. 高内聚: 类设计成只支持一组相关的功能; 低内聚: 类被设计成支持一组不相关的功能.

>策略-封装可互换的行为, 使用委托决定使用哪个; 适配器-改变一个或多个类的接口; 迭代器-提供一个方式来遍历集合, 无须暴露集合的实现; 外观-简化一群类的接口; 

组合-客户可以将对象的集合以及个别的对象一视同仁.; 观察者-当某个状态改变时, 允许一群对象被通知到.

组合模式 Composite Pattern 允许将对象组合成树形结构来表现'整体/部分'层次结构. 组合能让客户以一致的方式处理个别对象以及对象组合.

组合模式用树形方式创建对象结构, 包含了组合和个别对象. 可以把相同的操作应用在组合和个别对象上.

>Menu是节点, MenuItem是叶节点;


>组合模式以单一责任设计原则换取透明性(transparency), 元素是组合还是叶节点对客户是透明的.

>Java for/in语句遍历: for (Object obj : collection) 递归

Summary

>要点 迭代器允许访问聚合的元素, 不需要暴露内部结构; 迭代器将遍历聚合的工作封装进一个对象中; 依赖聚合提供遍历; 迭代器提供一个公用的接口来遍历聚合项, 编码使用

聚合的项时, 可以使用多态机制; 尽量一个类只分配一个责任; 组合模式提供一个结构, 可同时包容个别和组合对象, 一视同仁; 组合结构内的任意对象称为组件, 可以是组合, 也

可以是节点; 根据需要平衡透明性和安全性来选择不同的方式设计组合模式.

Composite/Components, Iteration/Implementation, Recursion, FactoryMethod, Leaf, SingleResponseibility, HashTable, Dessert

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
//***********Iterator & Composite**********
class MenuItem;
class MenuComponent;
                                      
class IIterator
{
public:
    virtual bool hasNext()= 0;
    virtual MenuComponent* next() = 0; 
    virtual void remove() = 0;
};
                                      
class NullIterator : public IIterator
{
public:
    NullIterator() {};  
    virtual bool hasNext() {return false;}
    virtual MenuComponent* next() {return NULL;} 
    virtual void remove() {cout << "Unsupported" << endl;}
};
                                      
class MenuComponent
{
public:
    MenuComponent() {};
    virtual void add(MenuComponent* menuComponent) {cout << "Unsupported" << endl;}
    virtual void remove(MenuComponent* menuComponent) {cout << "Unsupported" << endl;}
    virtual MenuComponent* getChild(int i) {cout << "Unsupported" << endl;}
    virtual string getName() {cout << "Unsupported" << endl;}
    virtual double getPrice() {cout << "Unsupported" << endl;}
    virtual void print() {cout << "Unsupported" << endl;}
    virtual IIterator* createIterator() = 0;
};
                                      
class MenuItem : public MenuComponent
{
public:
    MenuItem(string name, double price) : msName(name), mdPrice(price) {}
    string getName() {return msName;}
    double getPrice() {return mdPrice;}
    void print();
    virtual IIterator* createIterator() {return new NullIterator();}
private:
    string msName;
    double mdPrice;
};
                                      
typedef vector<MenuComponent*> MENUCOMPONENTVEC;
class Menu : public MenuComponent
{
public:
    Menu(string name) : msName(name) {};
    virtual IIterator* createIterator();
    void add(MenuComponent* menuCom) {menuComVec.push_back(menuCom);}
    void remove(MenuComponent* menuCom);
    MenuComponent* getChild(int i) { menuComVec.at(i); }
    virtual string getName() {return msName;}
    void print();      
private:
    MENUCOMPONENTVEC menuComVec;
    string msName;
};
                                      
typedef vector<MenuItem*> MENUITEMVEC;
class PancakeHouseMenu : public Menu
{
public:
    PancakeHouseMenu();
    MENUITEMVEC getMenuItems(){ return menuIVec; }
    virtual IIterator* createIterator();
private:
    void addItem(string name, double price);
    MENUITEMVEC menuIVec;
};
                                      
class DinerMenu : public Menu
{
public:
    DinerMenu();
    ~DinerMenu();
    MenuItem** getMenuItems() { return menuItems; }
    int getSize() { return miNumOfItems;}
    virtual IIterator* createIterator();
private:
    void addItem(string name, double price);
    MenuItem** menuItems;
    int miNumOfItems;
};
                                      
typedef map<string, MenuItem*> MENUMAP;
class CafeMenu : public Menu
{
public:
    CafeMenu();
    MENUITEMVEC getMenuItems() { return menuVec;}
    virtual IIterator* createIterator();
private:
    void addItem(string name, double price);
    MENUMAP menuMap;
    MENUITEMVEC menuVec;
};
                                      
class DinerMenuIterator : public IIterator
{
public:
    DinerMenuIterator(MenuItem** items, int size) : miPosition(0)
    {
        menuItems = items;
        miSize = size;
    }
    virtual bool hasNext();
    virtual MenuItem* next();
    virtual void remove();
private:
    MenuItem** menuItems;
    int miPosition;
    int miSize;
};
                                      
class PancakeHouseMenuIterator : public IIterator
{
public:
    PancakeHouseMenuIterator(MENUITEMVEC vec)
    {
        menuIVec = vec;
        mIter = menuIVec.begin();
    }
    virtual bool hasNext();
    virtual MenuItem* next();
    virtual void remove();
private:
    MENUITEMVEC menuIVec;
    MENUITEMVEC::iterator mIter;
};
                                      
class CafeMenuIterator : public IIterator
{
public:
    CafeMenuIterator(MENUITEMVEC vec)
    {
        menuVec = vec;
        mIter = menuVec.begin();
    }
    virtual bool hasNext();
    virtual MenuItem* next();
    virtual void remove();
private:
    MENUITEMVEC menuVec;
    MENUITEMVEC::iterator mIter;
};
                                      
typedef vector<Menu*> MENUSVEC;
class Waitness
{
public:
    Waitness();
    void setMenuComponent(MenuComponent* menuCom)
    {menuComponent = menuCom;}
    void setPCMenu(Menu* menu);
    void setDinerMenu(Menu* menu);
    void setCafeMenu(Menu* menu);
    void addMenus(Menu* menu);
    void printMenu();
    void printMenu(IIterator* iter);
    void printMenus();
    void printMenuComponent();
    void removeMenuComponent();
private:
    Menu* mpPancakeMenu;
    Menu* mpDinerMenu;
    Menu* mpCafeMenu;
    MENUSVEC menusVec;
    MenuComponent* menuComponent;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
//***********Iterator & Composite**********
void MenuItem::print()
{
    cout<<"------MenuItem------"<< endl;
    cout << "Name:"<<getName() << endl;
    cout << "Price:"<<getPrice() << endl;
}
                                      
IIterator* Menu::createIterator()
{
    return new NullIterator();
}
                                      
void Menu::remove(MenuComponent* menuCom)
{
    MENUCOMPONENTVEC::iterator iter = menuComVec.begin();
    for (; iter != menuComVec.end(); iter++)
    {
        MenuComponent* menuComToCompare = *iter;
        if (menuComToCompare == menuCom)
        {
            iter = menuComVec.erase(iter);
            return;
        }
    }
}
                                      
void Menu::print()
{
    cout<<"------Menu------"<< endl;
    cout << "Name:"<<getName() << endl;
    MENUCOMPONENTVEC::iterator iter = menuComVec.begin();
    for (; iter != menuComVec.end(); iter++)
    {
        MenuComponent* menuCom = *iter;
        menuCom->print();
    }    
}
                                      
const int MAX_ITEMS = 6;
PancakeHouseMenu::PancakeHouseMenu()
: Menu("PancakeHouse")
{
    addItem("Regular Pancake Breakfast", 15.90);
    addItem("BlueBerry Pancake", 18.90);
}
                                      
void PancakeHouseMenu::addItem(string name, double price)
{
    MenuItem *item = new MenuItem(name, price);
    menuIVec.push_back(item);
}
                                      
IIterator*  PancakeHouseMenu::createIterator()
{
    return new PancakeHouseMenuIterator(menuIVec);
}
                                      
DinerMenu::DinerMenu()
: Menu("Diner"),
  miNumOfItems(0)
{
    //*menuItems = new MenuItem[MAX_ITEMS; //wrong: runtime creating, terminate error, only for assign the value, not new
    menuItems = new MenuItem*[MAX_ITEMS];
    addItem("Soup of the day", 5.00);
    addItem("Hotdog", 8.00);
}
                                      
DinerMenu::~DinerMenu()
{
    delete[] menuItems;
}
                                      
void DinerMenu::addItem(string name, double price)
{
    MenuItem* item = new MenuItem(name, price);
    if (MAX_ITEMS > miNumOfItems)
    {
        menuItems[miNumOfItems] = item;
        miNumOfItems++;
    }
    else
        cout << "Menu is full, can't add more." << endl;
}
                                      
IIterator* DinerMenu::createIterator()
{
    return new DinerMenuIterator(menuItems, miNumOfItems);
}
                                      
CafeMenu::CafeMenu()
: Menu("Cafe")
{
    addItem("Soup of the day", 3.59);
    addItem("Cappuccino ", 1.99);
}
                                      
void CafeMenu::addItem(string name, double price)
{
    MenuItem* item = new MenuItem(name, price);
    menuMap.insert(pair<string,MenuItem*>(name,item));
    menuVec.push_back(item);
}
                                      
IIterator* CafeMenu::createIterator()
{
    return new CafeMenuIterator(menuVec);
}
                                      
bool DinerMenuIterator::hasNext()
{
    if(miPosition >= miSize ||
      menuItems[miPosition] == NULL)
        return false;
    else
        return true;           
}
                                      
MenuItem* DinerMenuIterator::next()
{
    MenuItem* item = menuItems[miPosition];
    miPosition++;
    return item;
}
                                      
void DinerMenuIterator::remove()
{
    if(miPosition <= 0)
    {
        cout << "Can't remove the item" << endl;
        return;
    }
    if(menuItems[miPosition - 1] != NULL)
    {
        for(int i = miPosition - 1 ; i < miSize - 1; i++)
        {
            menuItems[miPosition] = menuItems[miPosition + 1];
        }
        menuItems[miSize - 1] = NULL;
        miSize--;
    }
}
                                      
bool PancakeHouseMenuIterator::hasNext()
{
    if(mIter == menuIVec.end())
        return false;
    else
        return true;        
}
                                      
MenuItem* PancakeHouseMenuIterator::next()
{
    MenuItem* item = *mIter;
    mIter++;
    return item;
}
                                      
void PancakeHouseMenuIterator::remove()
{
    if(mIter == menuIVec.end())
    {
        cout << "Can't remove the item" << endl;
        return;
    }
    if (NULL != *mIter)
        mIter = menuIVec.erase(mIter);
}
                                      
bool CafeMenuIterator::hasNext()
{
    if(mIter == menuVec.end())
        return false;
    else
        return true; 
}
                                      
MenuItem* CafeMenuIterator::next()
{
    MenuItem* item = *mIter;
    mIter++;
    return item;
}
                                      
void CafeMenuIterator::remove()
{
    if (mIter == menuVec.end())
    {
        cout << "Can't remove the item" << endl;
        return;
    }
    if (NULL != *mIter)
       mIter = menuVec.erase(mIter);
}
                                      
void Waitness::printMenu()
{
    if (mpPancakeMenu != NULL)
    {
        MENUITEMVEC menuVec = dynamic_cast<PancakeHouseMenu*>(mpPancakeMenu)->getMenuItems();
        MENUITEMVEC::iterator menuIter = menuVec.begin();
        cout << "----MenuItem for PancakeHouse----" << endl;
        for (; menuIter != menuVec.end(); menuIter++)
        {
            MenuItem *item = *menuIter;
            cout << "name:" << item->getName();
            cout << " price:" << item->getPrice() << endl;
        }
        IIterator* iterPcake = mpPancakeMenu->createIterator();
        cout << "----MenuItem Iterator for PancakeHouse----" << endl;
        printMenu(iterPcake);  
    }
    if (mpPancakeMenu != NULL)
    {
        DinerMenu* dinerMenu = dynamic_cast<DinerMenu*>(mpDinerMenu);
        MenuItem** menuItems = dinerMenu->getMenuItems();
        cout << "----MenuItem  for Diner:----" << endl;
        for (int i = 0; i < dinerMenu->getSize(); i++)
        {
            MenuItem* item = menuItems[i];
            cout << "name:" << item->getName();
            cout << " price:" << item->getPrice() << endl;
        }
        IIterator* iterDiner = mpDinerMenu->createIterator();
        cout << "----MenuItem Iterator for Diner:----" << endl;
        printMenu(iterDiner);
    }
    if (mpCafeMenu != NULL)
    {
        MENUITEMVEC menuVec = dynamic_cast<CafeMenu*>(mpCafeMenu)->getMenuItems();
        MENUITEMVEC::iterator menuIter = menuVec.begin();
        cout << "----MenuItem for Cafe----" << endl;
        for (; menuIter != menuVec.end(); menuIter++)
        {
            MenuItem *item = *menuIter;
            cout << "name:" << item->getName();
            cout << " price:" << item->getPrice() << endl;
        }
        IIterator* iterCafe = mpCafeMenu->createIterator();
        cout << "----MenuItem Iterator for Cafe----" << endl;
        printMenu(iterCafe);  
    }
}
                                      
Waitness::Waitness()
: mpPancakeMenu(NULL), mpDinerMenu(NULL), mpCafeMenu(NULL)
{
}
                                      
void Waitness::setPCMenu(Menu* menu)
{
    mpPancakeMenu = menu;
}
                                      
void Waitness::setDinerMenu(Menu* menu)
{
    mpDinerMenu = menu;
}
                                      
void Waitness::setCafeMenu(Menu* menu)
{
    mpCafeMenu = menu;
}
                                      
void Waitness::printMenu(IIterator* iter)
{
    while(iter->hasNext())
    {
        iter->remove();//test for remove
        MenuComponent* item = iter->next();
        iter->remove();
        cout << "name:" << item->getName();
        cout << " price:" << item->getPrice() << endl;
    }
}
                                      
void Waitness::addMenus(Menu* menu)
{
    menusVec.push_back(menu);
}
                                      
void Waitness::printMenus()
{
    MENUSVEC::iterator menusIter = menusVec.begin();
    cout << "----Print all menus----" << endl;
    int count = 1;
    for (; menusIter != menusVec.end(); menusIter++)
    {
        Menu *menu = *menusIter;
        IIterator* iter = menu->createIterator();
        cout << "----MenuItem "<<count<<"----" << endl;
        printMenu(iter);  
        count++;
    }
}
                                      
void Waitness::printMenuComponent()
{
    cout << "----Print menu component----" << endl;
    menuComponent->print();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
//Iterator & Composite
cout<<"******exapmle1 GET******"<<endl;
PancakeHouseMenu* pancakeMenu = new PancakeHouseMenu();
DinerMenu* dinerMenu = new DinerMenu();
CafeMenu* cafeMenu = new CafeMenu();
Waitness* waitness = new Waitness();
waitness->setPCMenu(pancakeMenu);
waitness->setDinerMenu(dinerMenu);
waitness->setCafeMenu(cafeMenu);
waitness->printMenu();
cout<<"******example2 Iterator******"<<endl;
waitness->addMenus(dinerMenu);
waitness->addMenus(cafeMenu);
waitness->printMenus();
cout<<"******example3 Component******"<<endl;
MenuComponent* pancakeMenu3 = new Menu("PancakeHouse");
MenuComponent* cafeMenu3 = new Menu("Cafe");
MenuComponent* allMenus = new Menu("All Menus");
allMenus->add(pancakeMenu3);
allMenus->add(cafeMenu3);
pancakeMenu3->add(new MenuItem("Pasta", 3.98));
pancakeMenu3->add(cafeMenu3);
cafeMenu3->add(new MenuItem("chocolate", 1.98));
waitness->setMenuComponent(allMenus);
waitness->printMenuComponent();

---Section 9 End---

Section 10 状态模式 State

策略模式-状态模式

>Common Skill 对对象内的状态建模, 创建一个实例对象来持有状态值, 在方法内实现条件代码处理不同状态. 

>将每个状态的行为局部化到自己的类中; 避免难以维护的If语句; 每个状态对修改关闭, Context对扩展开放; 创建容易理解的类结构

状态模式 允许对象在内部状态改变时改变它的行为, 对象看起来好像修改了它的类


>客户不了解状态的内部变化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
//***********State**********
class GumballMachine;
             
class IState
{
public:
    virtual void insertQuarter() = 0;
    virtual void ejectQuarter() = 0;
    virtual void turnCrank() = 0;
    virtual void dispense() = 0;
};
         
class SoldState : public IState
{
public:
    SoldState(GumballMachine* gumballM) { mpGumballM = gumballM; }
    virtual void insertQuarter() {cout << "Already giving a ball" << endl;};
    virtual void ejectQuarter() {cout << "Already turned the crank" << endl;};
    virtual void turnCrank() {cout << "Turn twice doesn't get another ball" << endl;};
    virtual void dispense();
private:
    GumballMachine* mpGumballM;
};
         
class SoldOutState : public IState
{
public:
    SoldOutState(GumballMachine* gumballM) { mpGumballM = gumballM; }
    virtual void insertQuarter() {cout << "Out of balls" << endl;};
    virtual void ejectQuarter() {cout << "No quarter" << endl;};
    virtual void turnCrank() {cout << "Out of balls" << endl;};
    virtual void dispense() {cout << "Out of balls" << endl;};
private:
    GumballMachine* mpGumballM;
};
         
class NoQuarterState : public IState
{
public:
    NoQuarterState(GumballMachine* gumballM) { mpGumballM = gumballM; }
    virtual void insertQuarter();
    virtual void ejectQuarter() {cout << "Have not inserted a quarter" << endl;}
    virtual void turnCrank() {cout << "No quarter" << endl;}
    virtual void dispense() {cout << "Pay first" << endl;}
private:
    GumballMachine* mpGumballM;
};
         
class HasQuarterState : public IState
{
public:
    HasQuarterState(GumballMachine* gumballM);
    virtual void insertQuarter() {cout << "Can not insert another quarter" << endl;}
    virtual void ejectQuarter();
    virtual void turnCrank();
    virtual void dispense() {cout << "No gamball dispensed" << endl;};
private:
    GumballMachine* mpGumballM;
    int miRan;
};
         
class WinnerState : public IState
{
public:
    WinnerState(GumballMachine* gumballM) { mpGumballM = gumballM; }
    virtual void insertQuarter() {cout << "Already giving a ball" << endl;};
    virtual void ejectQuarter() {cout << "Already turned the crank" << endl;};
    virtual void turnCrank() {cout << "Turn twice doesn't get another ball" << endl;};
    virtual void dispense();
private:
    GumballMachine* mpGumballM;
};
         
class GumballMachine
{
public:
    GumballMachine(int iCount);
    void insertQuarter();
    void ejectQuarter();
    void turnCrank();
    void dispense();
    void releaseBall();
    int getCount() const;
    void setState(IState* state) { mpState = state; }
    IState* getSoldOutState() { return mpSoldOutState;}
    IState* getNoQuarterState() {return mpNoQuarterState;}
    IState* getHasQuarterState() { return mpHasQuarterState;}
    IState* getSoldState() { return mpSoldState;}
    IState* getWinnerState() { return mpWinnerState;}
private:
    IState* mpState;
    IState* mpSoldOutState;
    IState* mpNoQuarterState;
    IState* mpHasQuarterState;
    IState* mpSoldState;
    IState* mpWinnerState;
    int miCount;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
//***********State**********
void NoQuarterState::insertQuarter()
{
    cout << "Inserted a quarter" << endl;
    mpGumballM->setState(mpGumballM->getHasQuarterState());
}
         
HasQuarterState::HasQuarterState(GumballMachine* gumballM)
{
    mpGumballM = gumballM;
    srand((int)time(0));
    miRan = rand()%MAX;
    cout << "random number" << miRan << endl;
}
                 
void HasQuarterState::ejectQuarter()
{
    cout << "Quarter returned" << endl;
    mpGumballM->setState(mpGumballM->getNoQuarterState());
}
         
void HasQuarterState::turnCrank()
{
    cout << "You turned..." << endl;
    if ( (miRan - 10) == 0 && mpGumballM->getCount() > 1)
        mpGumballM->setState(mpGumballM->getWinnerState());
    else
        mpGumballM->setState(mpGumballM->getSoldState());
}
         
void SoldState::dispense()
{
    mpGumballM->releaseBall();
    if (mpGumballM->getCount() == 0)
    {
        cout << "Out of balls" << endl;
        mpGumballM->setState(mpGumballM->getSoldOutState());
    }
    else
        mpGumballM->setState(mpGumballM->getNoQuarterState());
}
         
void WinnerState::dispense()
{
    cout << "Winner" << endl;
    mpGumballM->releaseBall();
    if (mpGumballM->getCount() == 0)
        mpGumballM->setState(mpGumballM->getSoldOutState());
    else
    {
        mpGumballM->releaseBall();
        if (mpGumballM->getCount() > 0)          
            mpGumballM->setState(mpGumballM->getNoQuarterState());
        else
        {
            cout<<"out of balls" << endl;
            mpGumballM->setState(mpGumballM->getSoldOutState());
        }
    }
}
         
GumballMachine::GumballMachine(int iCount)
{
    mpSoldOutState = new SoldOutState(this);
    mpNoQuarterState = new NoQuarterState(this);
    mpHasQuarterState = new HasQuarterState(this);
    mpSoldState = new SoldState(this);
    mpWinnerState = new WinnerState(this);
    if (iCount>0)
        mpState = mpNoQuarterState;
    miCount = iCount;
}
         
void GumballMachine::insertQuarter()
{
    mpState->insertQuarter();
}
         
void GumballMachine::ejectQuarter()
{
    mpState->ejectQuarter();
}
         
void GumballMachine::turnCrank()
{
    mpState->turnCrank();
    mpState->dispense();
}
         
void GumballMachine::dispense()
{   
}
         
void GumballMachine::releaseBall()
{
    cout<< "A gumball comes..." <<endl;
    if (miCount != 0)
        miCount--;
}
         
int GumballMachine::getCount() const
{
    cout<< "Left gamball number: " << miCount <<endl;
    return miCount;
}
1
2
3
4
5
6
7
//State
GumballMachine* gumballM = new GumballMachine(5);
gumballM->insertQuarter(); gumballM->turnCrank();
gumballM->insertQuarter(); gumballM->ejectQuarter(); gumballM->turnCrank();
gumballM->insertQuarter(); gumballM->turnCrank(); gumballM->ejectQuarter();
gumballM->insertQuarter(); gumballM->insertQuarter(); gumballM->turnCrank();
gumballM->turnCrank(); gumballM->ejectQuarter();

状态模式 - 封装基于状态的行为, 将行为委托到当前状态

策略模式 - 将可以互换的行为封装起来, 使用委托的方法决定使用哪一个行为

模板方法 - 由子类决定如何实现算法中的某些步骤

Summary

>要点 允许一个对象基于内部状态拥有不同的行为; 和程序状态机PSM不同, 状态模式用类代表状态; Context会将行为委托给当前状态对象; 将每个状态封装进一个类,

把以后需要做的改变局部化; 状态和策略模式的意图不同, 策略模式用行为(算法)来配置Context, 状态模式允许Context随着状态改变而改变行为; 状态转换可以由State

类或Context类控制; 使用状态模式会导致类的数目增加; 状态类可以被多个Context实例共享.

---Section 10 End---

基于matlab的模糊控制器仿真,通过matlab编程实现模糊规则,控制过程等
fpga/matlab/simulink算法仿真工程
01-03 5536
模糊控制将人的经验知识转化为控制策略，不要求精确的数学模型，只需现场操作人员的经验知识，使模型难以确定的系统得以有效的控制，因此在对象参数发生变化的时候，模糊控制仍能达到较为满意的控制效果。考虑到控制规则的灵活与细致性兼顾其简单与易行的要求，这里选取七个语言等级作为本文所设计的模糊控制器的语言等级，从负的最大到正的最大依次为：负大(NB)、负中(NM)、负小(NS)、零(ZO)、正小(PS)、正中(PM)、正大(PB)。而当误差较小时，选取控制量要注意防止超调，以系统的稳定性为主要出发点。
模糊pid算法实现(Java)
热门推荐
HUXINY的博客
09-09 1万+
参考文章： https://blog.csdn.net/shuoyueqishilove/article/details/78236541 简介 模糊pid属于智能算法的一种，智能算法也可以叫非模型算法，也就是说，当我们无法确定系统模型时智能算法常常能够起到不小的作用。在现实世界中，大多数系统系统都是非线性的，不可预测的。 智能算法包括专家系统，模糊算法，遗传算法，神经网络算法等。其中任何一种算法......
19、模糊规则系统的多目标进化设计
stone的博客
11-01 66
本文综述了多目标进化模糊系统（MOEFSs）在回归与分类问题中的设计与应用。MOEFSs结合模糊规则系统的可解释性与多目标进化算法的优化能力，能够在准确性与可解释性之间实现良好权衡。文章详细介绍了模糊规则系统结构、多目标进化优化机制、染色体编码策略、交配算子及适应度函数设计，并通过PAES系列算法展示了MOEFS的实现流程与性能评估方法。实验结果表明，基于规则和条件选择（RCS）等新策略能有效提升收敛速度与泛化能力。同时，文章分析了当前面临的计算成本高、高维数据处理难和多目标优化局限等挑战，提出了并行计算、
27、模糊规则的生成与优化：从理论到实践
oil88的博客
06-07 132
本文详细探讨了模糊规则的生成与优化方法，涵盖了从理论到实践的多个方面。文章介绍了基于数据驱动和知识驱动的模糊规则生成技术，分析了规则精简与增强的策略，并结合具体应用场景如模式识别、控制系统和决策支持系统展示了模糊规则的实际应用价值。此外，文章还讨论了相关算法和数学模型，并展望了未来的研究方向和发展趋势。
改进模糊神经网络提高数据分类精度(附DeepSeek行业解决方案100+)
梵心白莲的博客
05-10 687
在当今信息爆炸的时代，数据分类是数据处理和分析中的关键任务之一。从金融领域的风险评估到医疗领域的疾病诊断，准确的数据分类能够为决策提供重要依据。模糊神经网络（Fuzzy Neural Network，FNN）作为一种融合了模糊逻辑和神经网络优势的智能模型，在数据分类中展现出了巨大的潜力。然而，传统的模糊神经网络在处理复杂数据时，分类精度仍有待提高。本文将详细探讨如何改进模糊神经网络以提升数据分类的精度。
32、模式识别中的模糊系统与提升算法
potato的博客
10-07 22
本文深入探讨了模式识别中的两种重要方法：模糊系统与提升算法。模糊系统基于模糊逻辑，能够有效处理不精确、不确定的信息，适用于图像处理、特征提取等复杂场景；提升算法通过组合多个弱分类器显著提高分类性能，典型代表如AdaBoost在手写数字识别中表现优异。文章详细介绍了两者的原理、设计方法及实际应用，并对比分析其特点，探讨了二者结合的可能性与未来发展趋势，包括与深度学习、强化学习的融合方向，为模式识别领域的研究与实践提供了有价值的参考。
22、分布式知识发现与模糊规则分类器设计
beta5的博客
09-07 21
本文提出了一种基于分类的分布式知识发现方法（DKDD_C），结合全局与局部KDD概念及元知识建模，有效减少关联规则数量并提升执行效率。同时，设计了一种基于生物相关算法合作（COBRA）的模糊规则分类器（FRBC），利用COBRA-b与BBO迁移算子优化规则库选择和隶属函数参数，在威斯康星乳腺癌和皮马印第安人糖尿病数据集上实现了较高的分类准确率，验证了方法的有效性与实用性。研究展示了在大规模分布式环境下的知识发现潜力以及模糊逻辑在医学诊断中的应用前景。
13、模糊规则集的信息量：理论与实践
oil88的博客
05-24 73
本文深入探讨了模糊规则集的信息量，涵盖信息量的定义、衡量方法、规则的重要性以及冗余与简约的处理方式。文章结合理论和实际案例，如股票价格预测和交通流量预测，展示了如何通过信息量度量来优化模糊规则集，提高系统的推理能力和效率。通过去除冗余规则、合并相似规则以及调整参数等手段，模糊逻辑系统在多个领域中的性能得到了显著提升。
模糊规则生成避坑指南：为什么你的ANFIS模型效果不如预期？
weixin_30329623的博客
03-23 399
本文深入分析了ANFIS模型效果不佳的常见原因，包括数据预处理不足、隶属函数配置不当、规则冗余等问题，并提供了实用的解决方案。通过模糊推理和规则生成技术，帮助开发者优化模型性能，提升工业控制和智能决策系统的准确性与效率。
模糊神经网络系统1
qq_18343569的博客
02-25 8722
模糊系统    模糊逻辑控制系统，简称模糊控制系统或模糊系统，是一种基于模糊数学理论的新型控制方法。   模糊控制由于模仿人对复杂事物的抽象思维方式，利用模糊信息处理对被控对象执行控制。所以，它不需要知道系统的精确数学模型。对不确定的非线性的系统来说是一种有效的控制途径。但是，模糊控制对信息的简单模糊化导致系统的控制精度下降。为了提高精度，往往要在模糊化时增加模糊量的个数，或者，增大控制规则集
模糊规则激活方法详解（python实例对比）
搏博的专栏
03-24 1270
前文我们已经了解了多种隶属函数，如三角形、梯形、高斯型、S型和Z型，并且讨论了模糊推理的基本过程，包括模糊化、规则评估、聚合和解模糊化。总结：最小-蕴含法（Mamdani方法）是取前件隶属度的最小值作为规则的激活强度，然后用这个值去裁剪后件的隶属函数。（1）规则：“如果温度高（μT =0.8）且湿度高（μH =0.6），则阀门开度Y=0.8×0.6×100%=48%”。（1）规则：“如果温度高（μT=0.8）且湿度高（μH=0.6），则阀门全开”。（2）红色曲线：最小-蕴含法结果（隶属度在0.6处截断）。
15、模糊积分器设计：提升模块化颗粒神经网络性能的关键
svm4gardener的博客
07-03 68
本文详细介绍了模糊积分器的设计与优化方法，重点探讨其在模块化颗粒神经网络（MGNNs）响应集成中的应用，以提升人类识别系统的性能。文章涵盖了模糊积分器的作用、隶属函数和模糊规则的优化方法，并引入分层遗传算法（HGA）进行参数优化。通过实验验证，优化后的模糊积分器在多模态生物特征识别任务中显著提高了识别精度和系统鲁棒性。此外，文章还探讨了模糊积分器在医疗诊断和环境监测等领域的应用潜力，总结了关键技术点并展望了未来发展方向。
PI和模糊控制器的simulink仿真
FPGA/MATLAB学习教程/源码/项目合作开发
06-04 5207
1.问题描述： 2.部分程序： 3.仿真结论： A
模糊规则生成避坑指南：如何根据项目需求选择正确方法？
lll78的博客
03-03 936
本文为模糊规则生成提供了实用的避坑指南，重点解析如何根据项目需求选择正确方法。文章从数据量、实时性、可解释性和资源约束四个核心维度出发，对比分析了专家经验法、聚类分析、决策树、遗传算法和ANFIS等主流方法的适用场景与典型陷阱，并提出了高效的混合策略与选型决策流程，帮助工程师在智能家居、工业自动化等复杂系统设计中做出明智的技术选型。
基于Simulink的自适应模糊PID控制模型设计与仿真
weixin_42605397的博客
11-06 1117
论域划分是指将实际物理量（如温度、转速）映射到标准化模糊论域（如[-6, 6]）的过程。这一步骤至关重要，因为模糊规则的设计往往基于归一化后的尺度。若原始信号波动剧烈而未做缩放，可能导致某些模糊集从未被激活，造成规则失效。一般流程如下：1. 确定原始输入的最大最小值（如误差范围 [-10°C, 10°C]）2. 设计量化因子 $ K_e = \frac{\text{模糊论域上限}}{\text{实际最大值}} $3. 实时采样值乘以 $ K_e $ 得到归一化输入。
Matlab实现电阻炉温度模糊控制系统设计与仿真
weixin_33814090的博客
05-19 959
模糊控制系统是一种基于模糊逻辑的控制系统，其核心思想是模仿人类的决策过程，在不完全精确或不确定的情况下进行控制。相比于传统的二值逻辑控制系统，模糊控制系统在处理具有模糊性或不确定性问题时，表现出更强的鲁棒性和适应性。温度控制在工业生产过程中是一个非常关键的环节，尤其是在材料加工、化工制造、食品烘焙等领域。对于电阻炉来说，温度控制的精确度直接决定了产品的质量和生产的效率。温度过高可能导致材料的烧损或性能劣化，而温度过低则可能造成产品不满足质量标准或需要重新加工。
模糊控制在运动控制中应用——模糊控制算法原理、公式推导、参数说明、调参方式
小墨迹的博客
02-20 5791
模糊控制是一种强大的控制方法，适用于复杂、非线性和不确定性系统的控制。其核心在于模糊化、模糊规则库设计和解模糊化。通过合理调整隶属函数参数和模糊规则库，可以实现高性能的控制系统。
模糊控制在运动控制中的实践指南——从算法原理到参数优化
最新发布
weixin_42521856的博客
04-05 308
本文深入探讨模糊控制在运动控制领域的实践应用，从算法原理到参数优化提供全面指南。通过机械臂抓取、注塑机改造等案例，详解模糊控制算法如何模仿人类决策，有效处理系统不确定性。重点介绍隶属函数设置、规则库设计等关键步骤，并分享伺服电机、机械臂等典型场景的调参技巧与避坑经验。
9、参数优化在动态系统中的应用与挑战
weixin_42593130的博客
06-07 388
本文深入探讨了参数优化在动态系统中的应用与挑战，涵盖不确定、随机和模糊控制器的具体应用场景，并分析了描述性和规定性方法的区别与联系。同时，文章还介绍了基于专家知识的决策质量评估方法，以及在实际应用中可能遇到的技术挑战和未来的研究方向。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值