Please enable JavaScript.
Coggle requires JavaScript to display documents.
Singleton单实例, GoF, factory工厂模式, adapter适配器, facade外观模式, observer观察者模式,…
Singleton单实例
-
-
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()来获取这个唯一的对象
-
-
factory工厂模式
三类工厂
-
抽象工厂模式：在工厂方法模式的基础上，将原有的产品父类增加一个抽象prepare函数，使之成为一个抽象类，再额外增加一个原料工厂接口，再新增各个商店对应的原料工厂类实现原料工厂接口，再在这个基础上，更改产品子类，每个子类中有一个对应的原料工厂，再实现父类抽象函数prepare时，调用原料工厂的函数，以此确保了产品原料的可靠性。
-
-
简单工厂模式
1：所有的产品类统一继承一个产品父类（里面有产品相关制作函数）
2：工厂类中的方法根据传入的参数生成产品的实体对象并返回
3：商店类生成一个工厂对象，再通过一个方法函数向工厂实体传参，得到工厂生产的产品对象
抽象工厂模式
1：增加一个原料工厂接口，里面有对应的原料生产函数；每个不同的商店对应拥有一个原料工厂类，实现原料工厂接口
2：将产品父类中的prepare函数变为抽象函数，产品父类随之变成一个抽象类，所有产品子类继承父类后，在内部生成一个对应商店的原料工厂类，再实现父类的抽象prepare函数中调用原料工厂对象的方法
adapter适配器
-
-
class Circle extends Shape{
...
private XXcircle myXXcircle;//声明对象
...
public Circle(){
myXXcircke= new myXXcircle();//分配空间
}
void public display(){
myXXcircle.displayIt();//直接引用写好的函数即可
}
...
}
-
observer观察者模式
-
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接口，和一系列实现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(...){
...
}
}
command命令模式
-
命令接口：
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最后执行命令即可。
composite组合模式（部分整体模式)
要点：
1：一个抽象父类，包含item子类和menu子类可能需要的抽象方法。
2：munu子类中申请一个父类的列表，并实现相应的remove（）add（）函数。通过这样可以将多个item聚合到一个menu中，也可以让多个menu聚合到一个menu中
-