标签：String 迭代 state plane 应用 new 设计模式 行为 public
一、实现过程及步骤
- 某软件公司欲开发一款飞机模拟系统，该系统主要模拟不同种类飞机的飞行特征与起飞特征，需要模拟的飞机种类及其特征如下表所示：为将来能够模拟更多种类的飞机，试采用策略模式设计并模拟实现该飞机模拟系统。
| 飞机种类 | 起飞特征 | 飞行特征 |
|---|---|---|
| 直升机(Helicopter) | 垂直起飞(VerticalTakeOff) | 亚音速飞行(SubSonicFly) |
| 客机(AirPlane) | 长距离起飞(LongDistanceTakeOff) | 亚音速飞行(SubSonicFly |
| 歼击机(Fighter) | 长距离起飞(LongDistanceTakeOff) | 超音速飞行(SuperSonicFly) |
| 鹞式战斗机(Harrier) | 垂直起飞(VerticalTakeOff) | 超音速飞行(SuperSonicFly) |
（1）策略模式设计：
策略模式是定义一系列算法，将每一个算法封装起来，并让它们可以相互替。首先设计一个环境类plane，用来设置所有的飞机类型，然后设计抽象策略类state,state类里面设计起飞特征和飞行特征的抽象方法，最后设计四个具体策略类，包括Helicopter、AirPlane、Fighter、Harrier，四个类中分别设置具体的起飞特征以及飞行特征，最后通过客户类Client去创建对象，调用对应的方法即可。
（2）UML类图如下：
（3）运行结果如下：
（4）主要代码如下：
环境类plane
package strategypattern;
public class plane {
private state state;
public void settakeoffFeatures(state tFeatures) {
this.state = tFeatures;
}
public void setplanetype(String type) {
if(type == "直升机")
state = new Helicopter();
else if(type == "客机") {
state = new AirPlane();
}
else if(type == "歼击机") {
state = new Fighter();
}
else if(type == "鹞式战斗机") {
state = new Harrier();
}
else {
state = null;
}
}
public void takeoff() {
state.takeOff();
}
public void fly() {
state.fly();
}
}
抽象策略类state
package strategypattern;
public interface state {
public String takeOff();//起飞特征
public String fly();//飞行特征
}
具体策略类Helicopter、AirPlane、Fighter、Harrier（此处只列举Helicopter）
package strategypattern;
public class Helicopter implements state{
public String takeOff() {
System.out.println("直升机垂直起飞");
return "直升机垂直起飞";
}
public String fly() {
System.out.println("直升机亚音速飞行");
return "直升机亚音速飞行";
}
}
客户类Client
package strategypattern;
public class Client {
public static void main(String[] args) {
plane helicopter = new plane();
helicopter.setplanetype("直升机");
helicopter.takeoff();
helicopter.fly();
plane airplane = new plane();
airplane.setplanetype("客机");
airplane.takeoff();
airplane.fly();
plane fighter = new plane();
fighter.setplanetype("歼击机");
fighter.takeoff();
fighter.fly();
plane harrier = new plane();
harrier.setplanetype("鹞式战斗机");
harrier.takeoff();
harrier.fly();
}
}
- 某商品管理系统的商品名称存储在一个字符串数组中，现需要自定义一个双向迭代器(MyIterator)实现对该商品名称数组的双向（前向和后向）遍历。绘制类图并编程实现。
（1）迭代器模式设计：
首先设计一个抽象迭代器Iterator类，里面包含聚合的抽象迭代方法，然后设计两个具体迭代器类MyIterator和MyIterator2，这两个迭代器分别实现向后遍历和向前遍历的方法，然后再设计一个抽象聚合类 GoodsStore,里面设计一个获取迭代器的方法，然后再设计一个具体聚合类MyGoodsStore类，用来初始化聚合中的元素，以及获取不同的迭代器，最后通过客户类创建对象并选择相应的迭代器进行聚合的遍历。
（2）UML类图如下：
（3）运行结果如下：
（4）主要代码如下：
抽象迭代器Iterator类
package iteratorpattern;
public interface Iterator {
public boolean hasNext();
public Object Next();
};
具体迭代器类MyIterator和MyIterator2（此处只列举MyIterator）
public class MyIterator implements Iterator{
int index;
public boolean hasNext(){
if(index < names.length){
return true;
}
return false;
}
public Object Next(){
if(this.hasNext()){
return names[index++];
}
return null;
}
}
抽象聚合类 GoodsStore
package iteratorpattern;
public interface GoodsStore {
public Iterator getMyIterator();
}
具体聚合类MyGoodsStore类
public class MyGoodsStore implements GoodsStore{
public String names[]={"铅笔","钢笔","圆珠笔","水彩笔","毛笔","圆规","橡皮"};
public Iterator getMyIterator(){
return new MyIterator();
}
public Iterator getMyIterator2(){
return new MyIterator2();
}
客户类Client
package iteratorpattern;
public class Client {
public static void main(String[] args) {
MyGoodsStore mygoodsstore = new MyGoodsStore();
System.out.println("向后遍历：");
for(Iterator ite = mygoodsstore.getMyIterator();ite.hasNext();){
String name = (String)ite.Next();
System.out.println(""+name);
}
System.out.println("*******");
System.out.println("向前遍历：");
for(Iterator ite = mygoodsstore.getMyIterator2();ite.hasNext();){
String name = (String)ite.Next();
System.out.println(""+name);
}
}
}
标签：String,迭代,state,plane,应用,new,设计模式,行为,public 来源： https://blog.csdn.net/weixin_44057997/article/details/112883822
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。