类的多重性（multiplicity）
对类的可同时存在的对象的数目的限制，称为类的多重性

public class SingleObject {
private static SingleObject instance = new SingleObject();//创建私有静态对象
private SingleObject(){}//让构造函数私有，这样类就不会被实例化
public static Singletonobject getInstance(）{
return instance;
}//获取唯一可调用对象
public void showMessage(){
System.out.println("Helloworld");}
}

在程序中通过Singletonobject object=Singletonobject.getInstance()来获取这个唯一的对象

您希望只有一个对象，但没有全局对象可以控制此对象的实例化。您还希望确保所有实体都使用此对象的同一实例，而不传递对所有实体的引用。

将一个类的接口转换为客户希望的另一个类的接口

要点，在类的内部声明一个要适配的类的私有对象，并在构造函数中为其分配空间，然后方法全部调用对象已有的函数

class Circle extends Shape{
...
private XXcircle myXXcircle;//声明对象
...
public Circle(){
myXXcircke= new myXXcircle();//分配空间
}
void public display(){
myXXcircle.displayIt();//直接引用写好的函数即可
}
...
}

要点：定义具有所需接口的一个或者多个新的类，让这个新类使用现有的系统。

简化了所需子系统的使用，但是客户端可能无法使用部分功能

外观目的是生成更简单的界面，但适配器是针对现有界面进行设计

外观对象通常是单实例（GRASP中的Controller是经典的外观）

Subject接口：
public interface Subject{
public void registerObserver(Observer O);
public void removeObserver(Observer O);
public void notifyObservers();
}

Observer接口：
public interface Observer{
public void update(...)
}

Subject对象：
public class MySubject implements Subject{
private ArrayList observers;
public MySubject(){
observers=new ArrayLists();
}
public void registerObserver(Observer o}
observers.add(o);
}
public void removeObserver(Obsrver o){
int j=observer.indexOf(o);
if(j>=0){
observers.remove(o);
}}

//提醒所有的观察者改变数据
public notifyObservers(){
for(int j=0;j<observers.size();j++){
Observer observer=(Observer)observer.get(j);
observer.update(...)
}}
public void measurementsChanged(){
notufyObservers();}

要点：Subject接口需要有注册函数、删除函数、提醒函数；Observer接口需要有更新函数；实现Subject时补充函数后再额外加一个measurementChanged（）函数，里面封装提醒函数

缺点：所有信息都被强行给了观察者，如果想添加一个参数需要修改所有观察者接收函数

优点：观察者主动获取信息，添加一个参数无需修改观察者

定义一系列算法，把它们封装起来，并且使它们可以互换（主要用于一个系统中存在很多类，而区分他们的是他们的直接行为）

要点：一个Strategy接口，和一系列实现Strategy的实体策略类，一个Context类用于切换、执行策略,包含私有strategy对象，构造函数时将需要的strategy传入，以及一个执行strategy的函数。

public interface Strategy{
public int doOperation(...);
}
//一系列实体策略：
public myStrategy1 implements Strategy{
Override
public int doOperation(...){...}
}
}
public myStrategy2 implements Strategy{...}
//Context类：
public Context{
private Stratrgy strategy;
public Context( Strategy strategy){
this.strateg=stratrgy;
}
public int execyteStrategy(...){
...
}
}

工厂方法模式：在简单工厂的基础上，将产品的制作函数放入商店的抽象方法中，使得子类商店能够有自己独特的产品制作方法

抽象工厂模式：在工厂方法模式的基础上，将原有的产品父类增加一个抽象prepare函数，使之成为一个抽象类，再额外增加一个原料工厂接口，再新增各个商店对应的原料工厂类实现原料工厂接口，再在这个基础上，更改产品子类，每个子类中有一个对应的原料工厂，再实现父类抽象函数prepare时，调用原料工厂的函数，以此确保了产品原料的可靠性。

1：所有的产品类统一继承一个产品父类（里面有产品相关制作函数）
2：工厂类中的方法根据传入的参数生成产品的实体对象并返回
3：商店类生成一个工厂对象，再通过一个方法函数向工厂实体传参，得到工厂生产的产品对象

2：不通商店子类通过共仓类获得一个产品对象，再通过实现制作产品的抽象函数赋予产品特色

1：将商店变为抽象商店，简单工厂中的传参函数保持不变，设置一个抽象方法制作不同产品，

1：增加一个原料工厂接口，里面有对应的原料生产函数；每个不同的商店对应拥有一个原料工厂类，实现原料工厂接口

2：将产品父类中的prepare函数变为抽象函数，产品父类随之变成一个抽象类，所有产品子类继承父类后，在内部生成一个对应商店的原料工厂类，再实现父类的抽象prepare函数中调用原料工厂对象的方法

将一个请求封装成一个对象使我们可以用不同的请求对客户进行参数化（解除行为i请求者和实现者之间的紧耦关系）

命令接口：
public interface Order{
void excute();
}
Stock类：
public Stock{
...
public void buy(){...}
public void sell(){...}
}

实现命令的类：
public calss BuyStock implements Order{
private Stock abcStock;
public BuyStock(Stock abcStock){
this.abcstock=abcStock;
}
public void excute(){
abcStock.buy();
}
}
public class SellStock implements Order{
...
}
命令调用类：
public class Broker{
private List<Order> orderList=new ArrayList<Order>()'
public void takOrder(OPrder order){
orderlist.add(order)
}
public placeoreders(){
for(Order order:orderlist){
order.excute();
}
orderList.clear();
}
}
命令执行类：
public class commandPatternDemo{
public static void main(String[]args){
Stock abcStock=new Stock();
BuyStock buyStockOrder= new BuyStock(abcStock);
SellStock sellStockOrder= new SellStock(abcStock)
Broker broker=new Broker();
broker.takeOrer(buyStockOrer);
broker.takeOrder(SellStockOrder);
broker.placeOreders();}}}

要点：1：Stock类中包含一系列对象操作函数
2：命令接口Order含有一个excute（），所有命令子类实现这个函数，同时在内部申请一个Stock对象，在excute时调用对象的函数
3：实现命令的类Broker中有一个List<Order>用于储存所有的命令，包含一个takeOrder（）函数用于添加每一个命令，placeOrder（）函数用于执行每一个order中的excute函数。
4：命令执行类中将上述所有类都对象化，将所有order都添加进如broker中，broker最后执行命令即可。

要点：
1：一个抽象父类，包含item子类和menu子类可能需要的抽象方法。
2：munu子类中申请一个父类的列表，并实现相应的remove（）add（）函数。通过这样可以将多个item聚合到一个menu中，也可以让多个menu聚合到一个menu中

将对象组合成树形结构以表示“部分-整体”的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。