总结设计模式—(大话设计模式下篇)
1、迭代器模式 通过此模式我们可以遍历数组和集合
interface Iterator {
public boolean hasNext();
public Object next();
}
class ConcreteIterator implements Iterator {
private List list = null;
private int index;
public ConcreteIterator(List list) {
super();
this.list = list;
}
public boolean hasNext() {
if (index >= list.getSize()) {
return false;
} else {
return true;
}
}
public Object next() {
Object object = list.get(index);
index++;
return object;
}
}
interface List {
public void add(Object obj);
public Object get(int index);
public Iterator iterator();
public int getSize();
}
class ConcreteAggregate implements List{
private Object[] list;
private int size=0;
private int index=0;
public ConcreteAggregate(){
index=0;
size=0;
list=new Object[100];
}
public void add(Object obj) {
list[index++]=obj;
size++;
}
public Iterator iterator() {
return new ConcreteIterator(this);
}
public Object get(int index) {
return list[index];
}
public int getSize() {
return size;
}
}
public class IteratorTest {
public static void main(String[] args) {
List list=new ConcreteAggregate();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
Iterator it=list.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
像Java中的集合list、set、map都有继承Iterable(迭代)接口。
2、单例模式 频繁的进行创建和销毁的对象会造成内存的浪费
推荐代码示例1
public class Singleton { //属性需要不公开 private static volatile Singleton singleton; //构造器需要private private Singleton() {} public static Singleton getInstance() { if (singleton == null) {
//同步 synchronized (Singleton.class) { if (singleton == null) { singleton = new Singleton(); } } } return singleton; } }
推荐代码示例2
public class Singleton { private Singleton() {} //静态内部类 private static class SingletonInstance { private static final Singleton INSTANCE = new Singleton(); } //只有调用getInstance 才装载SingletonInstance类
public static Singleton getInstance() { return SingletonInstance.INSTANCE; } }
3、桥接模式 显示类的合成和聚合关系：合成指的是类拥有的关系，相当于拥有某个属性，聚合就是类继承。我的理解就是策略模式的延伸。
手写代码，未测过，呵呵呵
class Extends{ Bridge bridge； Extends(Bridge bridge){ this.bridge = bridge; } void method(){ bridge.method(); } } class ExtendsA extends Extends{ void method(){ bridge.method(); } } class ExtendsB extends Extends{ void method(){ bridge.method(); } } interface Bridge{ void method(); } class BridgeA implements Bridge{ void method(){ System.out.println("添加桥A"); } } class BridgeB implements Bridge{ void method(){ System.out.println("添加桥B"); } } public static void main(String[] args){ Extends extends; extends = new ExtendsA(new BridgeA) extends.method(); extends = new ExtendsA(new BridgeB) extends.method(); }
4、命令模式 此模式感觉就像是桥接模式+桥接模式，命令模式趋向于做多个命令
策略模式 -> 桥接模式 -> 命令模式 由少到多到更多。呵呵呵。。。
5、职责链模式 上面模式的添加方法，添加类属性，如果添加的是自己类作为一个属性放入类中嵌套就是 职责链。
abstract class DutyChain{ protected DutyChain duty; public void setDuty(DutyChain dutyChain) { this.duty = dutyChain ; } abstract void method(); }
6、中介者模式 我觉得中介者模式就是策略模式延伸过来，类可以嵌套多个其他类属性，在中介者中调节
public class MediatorPattern {
public static void main(String[] args) {
UnitedNationsSecurityCouncil UNSC = new UnitedNationsSecurityCouncil();
USA c1 = new USA(UNSC);
Iraq c2 = new Iraq(UNSC);
UNSC.setColleague1(c1);
UNSC.setColleague2(c2);
c1.declare("不准研发核武器，否则发动战争");
c2.declare("我们没有核武器，也不怕侵略。");
}
}
abstract class UnitedNations{
public abstract void declare(String message,Country colleague);
}
abstract class Country{
protected UnitedNations mediator;
public Country(UnitedNations mediator) {
this.mediator = mediator;
}
}
class USA extends Country{
public USA(UnitedNations mediator) {
//这个不能丢
super(mediator);
}
// 声明
public void declare(String message){
mediator.declare(message,this);
}
// 获得消息
public void GetMessage(String message){
System.out.println( "美国获得对方信息： " + message );
}
}
class Iraq extends Country{
public Iraq(UnitedNations mediator) {
super(mediator);
}
public void declare(String message) {
mediator.declare(message, this);
}
public void GetMessage(String message){
System.out.println( "伊拉克获得对方信息： " + message );
}
}
class UnitedNationsSecurityCouncil extends UnitedNations{
//嵌套两个类属性
private USA colleague1;
private Iraq colleague2;
public USA getColleague1() {
return colleague1;
}
public void setColleague1(USA colleague1) {
this.colleague1 = colleague1;
}
public Iraq getColleague2() {
return colleague2;
}
public void setColleague2(Iraq colleague2) {
this.colleague2 = colleague2;
}
//类中调节
public void declare(String message, Country colleague) {
if (colleague == colleague1){
colleague2.GetMessage(message);
}else{
colleague1.GetMessage(message);
}
}
}
运行结果
伊拉克获得对方信息： 不准研发核武器，否则发动战争
美国获得对方信息： 我们没有核武器，也不怕侵略。
* 优点：
简化了对象之间的交互：它用中介者和同事的一对多交互代替了原来同事之间的多对多交互，一对多关系更容易理解、维护和扩展，
将原本难以理解的网状结构转换成相对简单的星型结构。
各同事对象之间解耦：中介者有利于各同事之间的松耦合，我们可以独立的改变和复用每一个同事和中介者，增加新的中介者和新的
同事类都比较方便，更好地符合“开闭原则”。
减少子类生成：中介者将原本分布于多个对象间的行为集中在一起，改变这些行为只需生成新的中介者子类即可，这使各个同事类可
被重用，无须对同事类进行扩展。
缺点：
中介者会庞大，变得复杂难以维护。
7、 享元模式 将对象放入集合中，通过对对象的集合操作，减少大量对象的存储开销。
class Water{ private String name; public Water(String name) { this.name = name; } public String getName() { return name; } } interface Clouds{ public void method( Water water); } class WhiteClouds implements Clouds{ private String name; public WhiteClouds(String name) { this.name = name; } @Override public void method( Water water) { System.out.println(" 白云飘飘 : " + this.name+",云撑："+water.getName()); } } class BlackClouds implements Clouds{ @Override public void method( Water water) { System.out.println(" 黑云滚滚 : " + water.getName()); } } public class EnjoyClouds { private static final Map<String,Clouds> map = new HashMap<String, Clouds>(); public Clouds getClouds(String key){ if(!map.containsKey(key)){ map.put(key,new WhiteClouds(key)); } // Clouds clouds = map.get(key); // if (clouds == null){ // map.put(key,new WhiteClouds(key)); // } return map.get(key); } public int getCount(){ return map.size(); } public static void main(String[] args) { EnjoyClouds enjoyClouds = new EnjoyClouds(); String key = "小白"; Water water = new Water("大鱼"); Clouds clouds = enjoyClouds.getClouds( key ); clouds.method(water); clouds = map.get( key ); clouds.method(new Water("小虾")); System.out.println( enjoyClouds.getCount() ); } }
8、解释者模式 需要解释执行并且可以将该语言中的语句表示为一个可执行语句
/**解释模式 * 用解释器模式来实现 加减乘除四则运算 * Created by nicknailo on 2018/8/30. */ public class InterpretPattern { public static void main(String[] args) { Calculator calculator = new Calculator("123 + 124 + 125 - 126"); System.out.println(calculator.calculate()); } } abstract class ArithmeticExpression { public abstract int interptet(); } class NumExpression extends ArithmeticExpression { private int num; public NumExpression(int _num) { num = _num; } @Override public int interptet() { return num; } } abstract class OperatorExpression extends ArithmeticExpression { protected ArithmeticExpression mArithmeticExpression1,mArithmeticExpression2; public OperatorExpression(ArithmeticExpression _arithmeticExpression1, ArithmeticExpression _arithmeticExpression2) { mArithmeticExpression1 = _arithmeticExpression1; mArithmeticExpression2 = _arithmeticExpression2; } } class AdditionExpression extends OperatorExpression { public AdditionExpression(ArithmeticExpression _arithmeticExpression1, ArithmeticExpression _arithmeticExpression2) { super(_arithmeticExpression1, _arithmeticExpression2); } @Override public int interptet() { return mArithmeticExpression1.interptet() + mArithmeticExpression2.interptet(); } } class PlusExpression extends OperatorExpression { public PlusExpression(ArithmeticExpression _arithmeticExpression1, ArithmeticExpression _arithmeticExpression2) { super(_arithmeticExpression1, _arithmeticExpression2); } @Override public int interptet() { return mArithmeticExpression1.interptet() - mArithmeticExpression2.interptet(); } } class Calculator { protected Stack<ArithmeticExpression> mArithmeticExpressionStack = new Stack<ArithmeticExpression>(); public Calculator(String expression) { ArithmeticExpression arithmeticExpression1, arithmeticExpression2; String[] elements = expression.split(" "); for (int i = 0; i < elements.length; ++i) { System.out.println("elements: " + Arrays.toString(elements)); System.out.println("elements[i]: " + elements[i].charAt(0)); switch (elements[i].charAt(0)) { case '+': arithmeticExpression1 = mArithmeticExpressionStack.pop(); System.out.println("stack.pop : = "+ arithmeticExpression1.interptet()); arithmeticExpression2 = new NumExpression(Integer.valueOf(elements[++i])); mArithmeticExpressionStack.push( new AdditionExpression(arithmeticExpression1, arithmeticExpression2)); break; case '-': arithmeticExpression1 = mArithmeticExpressionStack.pop(); System.out.println("stack.pop : = "+ arithmeticExpression1.interptet()); arithmeticExpression2 = new NumExpression(Integer.valueOf(elements[++i])); mArithmeticExpressionStack.push( new PlusExpression(arithmeticExpression1, arithmeticExpression2)); break; default: mArithmeticExpressionStack.push(new NumExpression(Integer.valueOf(elements[i]))); break; } } } public int calculate() { return mArithmeticExpressionStack.pop().interptet(); } }
9、访问者模式 点击查看
