结合实例的单例模式，装饰者模式，观察者模式学习

Design Pattern

单例模式

控制一个类只能创建一个实例：把构造函数定义成private类

public class Person {
	private String name;
	private static Person instance =null;
	private Person() {
		name="";//把构造函数写成private
	}
	public static Person getInstance() {
		if(instance==null) {
			instance= new Person();
		}
		return instance;
	}
}
public class Test {
	public static void main(String[] agrs) {
		Person p=Person.getInstance();
		System.out.println(p);
	}
}
//当不多不少刚好需要5个的时候 就像一下这样写
import java.util.Vector;
public class Person {
	private String name;
	private static final int Max_Num=5;
	private static Vector<Person> instances=new Vector<Person>();
	private Person() {
		name="";
	}
	public static Person getInstance() {
		Person px=null;
		if(instances.size()<Max_Num) {
			px= new Person();
			instances.add(px);
		}
		return px;
	}
}

策略模式

灰字的来源：菜鸟教程

意图:定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换。

主要解决:在有多种算法相似的情况下，使用 if…else 所带来的复杂和难以维护。

何时使用:一个系统有许多许多类，而区分它们的只是他们直接的行为。

如何解决:将这些算法封装成一个一个的类，任意地替换。

关键代码:实现同一个接口。

• 将父类的必要方法写出来 flyBehavior,quackBehavior 两个属性用接口

  • public abstract class Duck {
       QuackBehavior quackBehavior;//quackBehavior不是对象，可以当做一个能使用方法的属性
       FlyBehavior flyBehavior;
       public Duck() { }
       public void performQuack() {
          quackBehavior.quack();    }
       public void performFly() {
          flyBehavior.fly();    }
       public void swim() {
          System.out.println("All ducks float."); }
    }
    //以下是一个接口 及其子类（关于鸭子的“飞”）
    public interface FlyBehavior {	void fly();}
    public class FlyNoWay implements FlyBehavior {
    	public void fly() {   System.out.println("I can not fly."); }
    }
    public class FlyWithWings implements FlyBehavior {
    	public void fly() {   System.out.println("I am flying!");   }
    }
    //以野鸭为例子 来理解
    public class MallardDuck extends Duck {
    	public MallardDuck() {
    	      quackBehavior = new Quack();//可以叫
    	      flyBehavior = new FlyWithWings();//可以飞
    	   }
    }
    

• 这两个接口都有2~3个子类，在实例化Duck子类的时候，可以从接口的子类中自由选择所需要的，以实现所需要的方法 （第23、24行） 接口的使用用association

工厂类

把所有创建对象的工作放到一个类里面

public class SimplePizzaFactory {
    public Pizza createPizza(String type) {
        Pizza pizza = null;
        if (type.equals(“cheese”)) {
            pizza = new CheesePizza();
        } else if (type.equals(“pepperoni”)) {
            pizza = new PepperoniPizza();
        } else if (type.equals(“clam”)) {
            pizza = new ClamPizza();
        } else if (type.equals(“veggie”)) {
            pizza = new VeggiePizza();
        }
        return pizza;
    }
}
//一般还会存在一个借口 比如OnePizza()  然后子类CheesePizza等来重写创造方法
**
**
//可以迅速切换到其他地点  比如NewYorkPizzaFacttory 里面可以创建不同类型的pizza对象

Decorators（同时具备继承和关联）

使一个对象逐步扩大，不断增添东西。而增添的一部分和最大的类基友继承又有关联，使其构成一个圈，把之前的对象圈起来。

灰字的来源：菜鸟教程

意图:动态地给一个对象添加一些额外的职责。就增加功能来说，装饰器模式相比生成子类更为灵活。

主要解决:一般的，我们为了扩展一个类经常使用继承方式实现，由于继承为类引入静态特征，并且随着扩展功能的增多，子类会很膨胀。

何时使用:在不想增加很多子类的情况下扩展类。

如何解决:将具体功能职责划分，同时继承装饰者模式。

关键代码： 1、Component 类充当抽象角色，不应该具体实现。 2、修饰类引用和继承 Component 类，具体扩展类重写父类方法。

• Beverage
  • DarkRoast
  • Condiment
    • Whip
    • Mocha
    • Milk
    • ……

//不断把b赋予新的对象，使b包含的视野不断的变大
//不断给对象b 装饰新的特性
Beverage/*为了之后能够顺利扩大，这里要用继承的大类*/ b = new DarkRoast();
b = new Mocha(b);
b = new Whip(b);
//最后相当于b->whip->mocha->darkroast
***
//其中cost 方法的写法
public double cost(){
	return 0.99;					//<----
}// DarkRoast						//	  |
public double cost(){				//	  |
	return 0.2 + beverage.cost();	//<----	这时的传入Mocha中的beverage是darkroast
}									 //	  |
public double cost(){				//    |
	return 0.1 + beverage.cost();  //------   不断找到最初的方法  这时传入的beverage是mocha

}

观察者模式

灰字的来源：菜鸟教程

意图：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

主要解决：一个对象状态改变给其他对象通知的问题，而且要考虑到易用和低耦合，保证高度的协作。建立一种触发机制。

何时使用：一个对象（目标对象）的状态发生改变，所有的依赖对象（观察者对象）都将得到通知，进行广播通知。

如何解决：使用面向对象技术，可以将这种依赖关系弱化。

关键代码：在抽象类里有一个 ArrayList 存放观察者们。

形象举例 广场舞大妈总是跟着领舞跳

• 创建subject 类

import java.util.ArrayList;
import java.util.List;
public class Subject {
   private List<Observer> observers 
      = new ArrayList<Observer>();//创建观察者列表
   private int state; 
   public int getState() {
      return state;
   } 
   public void setState(int state) {
      this.state = state;
      notifyAllObservers();
   }
   public void attach(Observer observer){
      observers.add(observer);      
   } 
   public void notifyAllObservers(){//通知观察者
      for (Observer observer : observers) {
         observer.update();//触发更新
      }
   }  
}
//观察者抽象类
public abstract class Observer {
   protected Subject subject;
   public abstract void update();
}
//二进制观察者
public class BinaryObserver extends Observer{ 
   public BinaryObserver(Subject subject){
      this.subject = subject;
      this.subject.attach(this);//添加观察者
   }
   public void update() {//更新操作
      System.out.println( "Binary String: " 
      + Integer.toBinaryString( subject.getState() ) ); 
   }
}
//八进制观察者
public class OctalObserver extends Observer{
   public OctalObserver(Subject subject){
      this.subject = subject;
      this.subject.attach(this);
   }
   public void update() {
     System.out.println( "Octal String: " 
     + Integer.toOctalString( subject.getState() ) ); 
   }
}
//在以上代码中 只要subject的status一改变  二进制观察者和八进制观察者的值就一起改变