`

javase模式2

设计模式算法 
阅读更多

六：命令模式

适用的情况：一个调用者，可以调用好多不同类型的物件的命令，那么把这么多的物件的定义成一个统一的接口，这个接口有一个统一的执行方法。

public interface Command {
 public void execute();
}

 子类：

public class LightOnCommand implements Command {
 Light light;
  
 public LightOnCommand(Light light) {
  this.light = light;
 }
 
 public void execute() {
  light.on();
 }
}

 

public class LightOffCommand implements Command {
	Light light;
 
	public LightOffCommand(Light light) {
		this.light = light;
	}
 
	public void execute() {
		light.off();
	}
}

 

具体类：

public class Light {

	public Light() {
	}

	public void on() {
		System.out.println("Light is on");
	}

	public void off() {
		System.out.println("Light is off");
	}
}

 

控制类：

public class SimpleRemoteControl {
	Command slot;
 
	public SimpleRemoteControl() {}
 
	public void setCommand(Command command) {
		slot = command;
	}
 
	public void buttonWasPressed() {
		slot.execute();
	}
}

 

测试类：

public class RemoteControlTest {
	public static void main(String[] args) {
		SimpleRemoteControl remote = new SimpleRemoteControl();
		Light light = new Light();
				LightOnCommand lightOn = new LightOnCommand(light);
		
 
		remote.setCommand(lightOn);
		remote.buttonWasPressed();
		
    }
}

 

关键是每个动作都是以个动作类。(*^.^*)

七。适配器模式：

   当你的代码是旧的代码，而用户使用的是新的接口，你的代码提供的接口不符合用户的接口，可以使用适配器模式，

  适配器模式有两种，

一种是对象适配器，一种是类适配器（通过多重继承可以是实现，但java不允许多重继承）。

   对象适配器：

               用户接口  -------------》接口

                                  有一个        ^

                                                    |

                                                适配器-----》有一个  你的接口

 

这样在适配器种的方法就可以用你的具体类来实现了。

类适配器就是 适配器既实现用户的接口，又实现你的接口。这样用户就可以使用了。

        外观模式：

    把很多类变量放到一个接口中，当使用一个方法时，会调用很多的类变量，这样 就把复杂的业务封装到一个系统中只提供给用户已个使用方法。

public class prarent{
     var1;
     var2;
     var3;
 public void method()
{
     var1.domethod();
     var2.domethod();
    var3.domethod();
}

}

 这样把复杂的业务就封装到了方法中，外部的用户看不到。

     和适配器模式不一样，适配器要实现别的接口，要有被实现接口的实例，而外观则只是把复杂的子系统封装在，一个接口中，一个方法调用 实现中会有子的来实现。

八.  模板方法--封装算法。

  public  class parent{

             public final do()

           {

                  do1();

                 do2();

                do3();

                  do4();

             if(getAddDo5())//钩子
            {

                   do5();
            }



           }

     public do1(){  println("in do 1");}
       public do2(){  println("in do 2");}
      public  abstract do3();
      public do4(){println("in do 4");}
       
     public boolean getAddDo5()
    {
         return true;
     }

}

 子类：

public child extends parent{
      public void do3()
      {
          println("in do3 ");
        }
        public boolean getaddDo5()//覆盖父类的钩子方法
      {
             //根据获取用户输入来返回
            true 
                      false;
       }
}
Arrays的

 public static void sort(Object[] a) {//模板方法，虽然不是很正统 但是排序也是由传入的数组的compareTo实现的
        Object[] aux = (Object[])a.clone();
        mergeSort(aux, a, 0, a.length, 0);
    }

            

以及IFrame extends JFrame

{

 

   中的paint()方法

}

     八。迭代器：

     继承自一个iterator 接口，

     女招待，有个菜单接口，可以传入不同菜单实现，每个菜单有一个创建迭代器的接口，可以创建迭代器，最后菜单传入的时候最好是以个集合，这样可以执行中传入菜单。

 

 

                                              菜单接口< ------------ 女招待------------>  interface   Iterator

                                                                                                                                 ^

                                                                                                                                 |

                                                   ^ ^                                                                        |

                                                    |  \                                                                         |

                                                    |     \                                                                      |

                                                    |      \                                                                     |

                                                    菜单1 \                                                                    |

                                                             菜单2                                                             |

                                                          |                                                                       |

                                                          |

                                                           ————————> createIterator---------------  不同的Iterator 实现

 

 

当菜单中子菜单又有子菜单的时候这个时候这个就不适合了，要用树的概念来完成这个。整体是一个组合，包含组件，组件又分组合和叶子，这时候组件接口中有他们的功用方法

public abstract class MenuComponent {
   
	public void add(MenuComponent menuComponent) {
		throw new UnsupportedOperationException();
	}
	public void remove(MenuComponent menuComponent) {
		throw new UnsupportedOperationException();
	}
	public MenuComponent getChild(int i) {
		throw new UnsupportedOperationException();
	}
  
	public String getName() {
		throw new UnsupportedOperationException();
	}
	public String getDescription() {
		throw new UnsupportedOperationException();
	}
	public double getPrice() {
		throw new UnsupportedOperationException();
	}
	public boolean isVegetarian() {
		throw new UnsupportedOperationException();
	}

	public abstract Iterator createIterator();
 
	public void print() {
		throw new UnsupportedOperationException();
	}
}

 

菜单为：

import java.util.Iterator;
import java.util.ArrayList;

public class Menu extends MenuComponent {
 
	ArrayList menuComponents = new ArrayList();
	String name;
	String description;
  
	public Menu(String name, String description) {
		this.name = name;
		this.description = description;
	}
 
	public void add(MenuComponent menuComponent) {
		menuComponents.add(menuComponent);
	}
 
	public void remove(MenuComponent menuComponent) {
		menuComponents.remove(menuComponent);
	}
 
	public MenuComponent getChild(int i) {
		return (MenuComponent)menuComponents.get(i);
	}
 
	public String getName() {
		return name;
	}
 
	public String getDescription() {
		return description;
	}

  
	public Iterator createIterator() {
		return new CompositeIterator(menuComponents.iterator());
	}
 
 
	public void print() {
		System.out.print("\n" + getName());
		System.out.println(", " + getDescription());
		System.out.println("---------------------");
  
		Iterator iterator = menuComponents.iterator();
		while (iterator.hasNext()) {
			MenuComponent menuComponent = 
				(MenuComponent)iterator.next();
			menuComponent.print();
		}
	}
}

 叶子节点为：

import java.util.Iterator;
import java.util.ArrayList;

public class MenuItem extends MenuComponent {
 
	String name;
	String description;
	boolean vegetarian;
	double price;
    
	public MenuItem(String name, 
	                String description, 
	                boolean vegetarian, 
	                double price) 
	{ 
		this.name = name;
		this.description = description;
		this.vegetarian = vegetarian;
		this.price = price;
	}
  
	public String getName() {
		return name;
	}
  
	public String getDescription() {
		return description;
	}
  
	public double getPrice() {
		return price;
	}
  
	public boolean isVegetarian() {
		return vegetarian;
	}

	public Iterator createIterator() {
		return new NullIterator();
	}
 
	public void print() {
		System.out.print("  " + getName());
		if (isVegetarian()) {
			System.out.print("(v)");
		}
		System.out.println(", " + getPrice());
		System.out.println("     -- " + getDescription());
	}
//vv MenuItemCompositeV2Main
}

 

这样就实现了，获得一个总的菜单组合可以直接调用print()方法打印出来它所有的子菜单。

如果要想获得外部迭代的功能，如侍者打印所有的素食菜单。主要是在组件上加上createIterator()方法。

 九。状态模式：

 一个物件有很多种状态，对于每种状态的不同操作，会有不同的反应。这样把状态设计成类，都继承自已个状态接口，若想在状态类中操作物体的方法，则可以把物体传入，在物体类中分别有不同的状态，还有一个当前状态，这样对物体的操作变成对当前状态的操作，又委托给状态类来操作。

主部件：

public class GumballMachine {
 
	State soldOutState;
	State noQuarterState;
	State hasQuarterState;
	State soldState;
 
	State state = soldOutState;
	int count = 0;
 
	public GumballMachine(int numberGumballs) {
		soldOutState = new SoldOutState(this);
		noQuarterState = new NoQuarterState(this);
		hasQuarterState = new HasQuarterState(this);
		soldState = new SoldState(this);

		this.count = numberGumballs;
 		if (numberGumballs > 0) {
			state = noQuarterState;
		} 
	}
 
	public void insertQuarter() {
		state.insertQuarter();
	}
 
	public void ejectQuarter() {
		state.ejectQuarter();
	}
 
	public void turnCrank() {
		state.turnCrank();
		state.dispense();
	}

	void setState(State state) {
		this.state = state;
	}
 
	void releaseBall() {
		System.out.println("A gumball comes rolling out the slot...");
		if (count != 0) {
			count = count - 1;
		}
	}
 
	int getCount() {
		return count;
	}
 
	void refill(int count) {
		this.count = count;
		state = noQuarterState;
	}

    public State getState() {
        return state;
    }

    public State getSoldOutState() {
        return soldOutState;
    }

    public State getNoQuarterState() {
        return noQuarterState;
    }

    public State getHasQuarterState() {
        return hasQuarterState;
    }

    public State getSoldState() {
        return soldState;
    }
 
	public String toString() {
		StringBuffer result = new StringBuffer();
		result.append("\nMighty Gumball, Inc.");
		result.append("\nJava-enabled Standing Gumball Model #2004");
		result.append("\nInventory: " + count + " gumball");
		if (count != 1) {
			result.append("s");
		}
		result.append("\n");
		result.append("Machine is " + state + "\n");
		return result.toString();
	}
}

 状态接口：

public interface State {
 
	public void insertQuarter();
	public void ejectQuarter();
	public void turnCrank();
	public void dispense();
}

 

其中的有币状态：

import java.util.Random;

public class HasQuarterState implements State {
	Random randomWinner = new Random(System.currentTimeMillis());
	GumballMachine gumballMachine;
 
	public HasQuarterState(GumballMachine gumballMachine) {
		this.gumballMachine = gumballMachine;
	}
  
	public void insertQuarter() {
		System.out.println("You can't insert another quarter");
	}
 
	public void ejectQuarter() {
		System.out.println("Quarter returned");
		gumballMachine.setState(gumballMachine.getNoQuarterState());
	}
 
	public void turnCrank() {
		System.out.println("You turned...");
		int winner = randomWinner.nextInt(10);
		if ((winner == 0) && (gumballMachine.getCount() > 1)) {
			gumballMachine.setState(gumballMachine.getWinnerState());
		} else {
			gumballMachine.setState(gumballMachine.getSoldState());
		}
	}

    public void dispense() {
        System.out.println("No gumball dispensed");
    }
 
	public String toString() {
		return "waiting for turn of crank";
	}
}

 winer状态以及普通的只出来一个状态：

public class SoldState implements State {
    GumballMachine gumballMachine;
 
    public SoldState(GumballMachine gumballMachine) {
        this.gumballMachine = gumballMachine;
    }
       
	public void insertQuarter() {
		System.out.println("Please wait, we're already giving you a gumball");
	}
 
	public void ejectQuarter() {
		System.out.println("Sorry, you already turned the crank");
	}
 
	public void turnCrank() {
		System.out.println("Turning twice doesn't get you another gumball!");
	}
 
	public void dispense() {
		gumballMachine.releaseBall();
		if (gumballMachine.getCount() > 0) {
			gumballMachine.setState(gumballMachine.getNoQuarterState());
		} else {
			System.out.println("Oops, out of gumballs!");
			gumballMachine.setState(gumballMachine.getSoldOutState());
		}
	}
 
	public String toString() {
		return "dispensing a gumball";
	}
}
 


////////////////////////

public class WinnerState implements State {
    GumballMachine gumballMachine;
 
    public WinnerState(GumballMachine gumballMachine) {
        this.gumballMachine = gumballMachine;
    }
 
	public void insertQuarter() {
		System.out.println("Please wait, we're already giving you a Gumball");
	}
 
	public void ejectQuarter() {
		System.out.println("Please wait, we're already giving you a Gumball");
	}
 
	public void turnCrank() {
		System.out.println("Turning again doesn't get you another gumball!");
	}
 
	public void dispense() {
		System.out.println("YOU'RE A WINNER! You get two gumballs for your quarter");
		gumballMachine.releaseBall();
		if (gumballMachine.getCount() == 0) {
			gumballMachine.setState(gumballMachine.getSoldOutState());
		} else {
			gumballMachine.releaseBall();
			if (gumballMachine.getCount() > 0) {
				gumballMachine.setState(gumballMachine.getNoQuarterState());
			} else {
            	System.out.println("Oops, out of gumballs!");
				gumballMachine.setState(gumballMachine.getSoldOutState());
			}
		}
	}
 
	public String toString() {
		return "despensing two gumballs for your quarter, because YOU'RE A WINNER!";
	}
}

 其中的winer状态是后面添加的这样比if--else的修改省事多了。

分享到：
| spring事务
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    JavaSE_JavaSE学习资料_

    正则表达式则是文本处理中的强大工具，可用于数据验证和模式匹配。 总的来说，这个JavaSE学习资料包将引导开发者全面地学习Java语言的核心特性，掌握基本编程技巧，理解并运用集合框架、IO流等关键概念，从而具备...

    Javase 技术代码测试

    本项目针对JavaSE的多个核心知识点进行了综合性的测试，涵盖了线程、集合、内部类、设计模式、枚举、IO流以及自定义注解等多个关键领域。 1. **线程**：在Java中，线程是程序执行的最小单位，通过`Thread`类或者...

    javase阶段15个实战项目代码

    8. 设计模式：项目可能包含对单例、工厂、观察者等常见设计模式的应用，这些模式在解决特定编程问题时非常有用。 9. 异常处理：了解如何正确地捕获和处理异常，这是编写健壮代码的关键。 10. 注解与反射：通过使用...

    JavaSE常用知识代码实现

    2. **封装、继承与多态**：这是面向对象编程的三大特性。封装是隐藏对象的属性和实现细节，仅对外提供公共访问方式；继承允许子类继承父类的属性和方法，实现代码复用；多态则指同一种行为可以有不同的表现形式，...

    JavaSE单例模式各种写法.doc

    ### JavaSE单例模式的各种实现方法 #### 一、懒汉式（线程不安全） **定义：** 懒汉式单例模式是最简单的实现方式之一，它的特点是第一次被调用时才实例化对象。 **代码示例：** ```java public class ...

    javaSE项目

    6. **项目组织与管理**：一个完整的项目会包含良好的代码结构和模块化设计，遵循一定的设计模式，比如单例模式、工厂模式等。此外，版本控制系统如Git的使用，Maven或Gradle构建工具的集成，以及单元测试和集成测试...

    JavaSE25套习题（含答案）

    15. **设计模式**：单例、工厂、观察者、装饰者等设计模式是解决常见问题的标准方案，熟悉这些模式能够提高代码质量。 通过完成这25套习题，开发者不仅可以加深对JavaSE的理解，还能发现自己的薄弱环节，有针对性地...

    javase笔记.7z

    以上只是JavaSE部分核心知识点的概述，实际的“javase笔记.7z”文件可能包含更详细的讲解，如设计模式、JVM原理、并发编程进阶等内容。学习JavaSE不仅需要掌握这些基础知识，还要通过实践不断深化理解，才能成为一名...

    Javase项目

    同时，这也会涉及到一些设计模式，比如单例模式（`Singleton`）可能用于`Bank`类，工厂模式（`Factory`）可能用于创建不同类型的`Account`，等等。 总的来说，这个"Javase银行类源码"项目是一个很好的实践平台，...

    0-JavaSE课程介绍

    - **目标2：理解面向对象编程思想** - 对象、类、引用、虚地址的概念。 - 封装性的实践：通过`private`修饰属性，提供`public`方法对外部暴露功能。 - 继承性的运用：熟悉父类、抽象类、抽象方法和接口的作用。 ...

    JavaSE常见面试题-高级反射-JVM篇.pdf

    本文档涵盖了JavaSE中高级反射和JVM相关的知识点，包括Java中的反射机制、动态代理、设计模式、回收机制、JDK7和JDK8的区别、Jvm虚拟机原理等。 一、 Java中的反射机制 Java中的反射机制是指可以在运行时inspect和...

    javase 版的QQ源码

    2. **网络编程**： - **Socket通信**：JavaSE版QQ的核心在于客户端与服务器之间的Socket通信，实现数据的发送和接收。 - **多路复用**：可能会使用ServerSocketChannel和Selector进行IO多路复用，提高服务器并发...

    javaSE商品管理系统

    2. **MyEclipse10.7**： MyEclipse是一款强大的Java集成开发环境，它扩展了Eclipse的功能，尤其在Web和企业级Java应用开发方面。在这个项目中，MyEclipse被用作编写、调试和部署Java代码的平台，它的代码提示、自动...

    圣思园张龙老师讲的JAVASE的pdf文档，讲的非常详细

    2. **线程**：Java的并发编程是其强大的特性之一，张龙老师详细介绍了线程的创建、同步与通信。讲解了Thread类、Runnable接口、守护线程、线程池（ExecutorService）以及synchronized关键字、volatile变量和Lock接口...

    javaSE javaEE oracle 初学必备

    对于JavaEE，你需要了解其架构和生命周期，学习如何使用Servlet和JSP来处理HTTP请求和响应，理解MVC（模型-视图-控制器）设计模式。此外，EJB允许开发者创建可重用的业务组件，而JPA则是处理数据持久化的主要工具，...

    mysql+javaSE登录小作业

    【MySQL+JavaSE登录小作业】是一个面向初学者的编程实践项目，主要目的是让学生了解如何结合MySQL数据库和JavaSE（Java Standard Edition）技术实现一个简单的登录功能。这个小程序集成了主流的开发模式，使得初学者...

    javaSE课件

    11. **设计模式**: 学习如何在Java中应用常见的设计模式，如工厂模式、单例模式、观察者模式、装饰器模式等，可以提高代码的可维护性和复用性。 通过这个"javaSE课件"，你将能够系统地学习以上各个知识点，并深入...

    javase_day01

    2. 一个.java文件可以包含多个类，但最多只能有一个公共类。 3. 每个类都会生成一个对应的.class文件，即使这些类在同一个.java文件中。 总的来说，Java的基础涵盖了语言的起源、主要架构、运行环境、开发工具以及...

    非常详细javaSE学习笔记.rar

    这份“非常详细JavaSE学习笔记.rar”压缩包显然是一份全面的Java SE学习资源，包含了从基础知识到高级特性的全方位讲解。下面，我们将详细探讨这份笔记可能涵盖的关键知识点。 1. **Java起源与环境搭建**：笔记可能...

    JavaSE项目企业员工管理系统

    此外，这个类可能还实现了数据访问对象（DAO）模式，通过DAO接口与数据库进行通信。在设计上，`StaffManager`可能遵循单一职责原则，使得每个方法专注于一项特定任务，从而提高代码的可读性和可维护性。 为了实现...

Magicbox
Global site tag (gtag.js) - Google Analytics