JAVA设计模式（二）工厂模式与观察者模式

朴灿烈づ我的快乐病毒、 2022-05-31 13:48 228阅读 0赞

## 工厂模式 ##

工厂模式顾名思义则是类似于一个工厂制造产品的模式。如富士康需要制造自己的产品，而同类产品有多种，如手机有各个品牌和型号一样。   
  明白了工厂模式的含义，我们来想想这个模式具体是怎么回事。首先需要的是一个工厂于是就需要一个Factory类，再次就是需要一个抽象的产品类，如手机这个产品抽象类，该类提供了一些通用的生产手机的属性及方法，最后则是我们具体的手机产品。   
下面就以富士康工厂生产小米，苹果，魅族为例。   
首先定义好我们的抽象类Phone

public class abstract Phone {
        //产品的抽象方法，具体实现由各个产品去完成
        public abstract void productPhone();
    }

*  1
 *  2
 *  3
 *  4

接下来具体产品的定义

public class IPhone extends Phone { 
         @Override
            public void productPhone() {
                System.out.println("Iphone开始生产");
            }
    
    }
    public class MiPhone extends Phone { 
         @Override
            public void productPhone() {
                System.out.println("MiPhone开始生产");
            }
    
    }
    public class MeZPhone extends Phone { 
         @Override
            public void productPhone() {
                System.out.println("MeZPhone开始生产");
            }
    
    }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21

在确定了具体的产品后，需要一个工厂来生产他们。

public class FoxFactor {
        public static Phone createComputer(String type){
            Phone mPhone=null;
                switch (type) {
                    case "apple":
                        mPhone=new IPhone();
                       break;
                    case "mi":
                        mPhone=new MiPhone();
                        break;
                    case "mez":
                        mPhone=new MeZPhone();
                        break;
    
                }
                return mPhone;
        }
    }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18

下面需要生产哪一种手机只需要调用工厂的方法 即可，如果升级生产流程更改只需要修改对应手机类进行了。   
下面是调用方法：

public class CreatPhone {
        public static void main(String[]args){
            FoxFactor.createComputer("mi").start();
        }
    }

*  1
 *  2
 *  3
 *  4
 *  5

## 观察者模式 ##

观察者模式：属于行为型模式的一种，它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。   
一般来说定义总是很抽象的，我们举个具体的例子来说明。比如去吃烤肉，几个小伙伴都围着炉子等肉熟，肉熟了后就是肉状态的变化，并且通知给想吃的小伙伴，这样小伙伴们就可以快乐的吃肉了。   
  为了实现这种模型，我们先来梳理下思路。首先是观察者，就是想吃肉的小伙伴们。其次就是被烤的肉了，就是被观察者。这两者之间为了较好的解耦可以通过接口来进行通信。因此就有了观察者接口和被观察者接口。   
先来看看被观察者。

public interface ISubjectBBQ {
    
        //被观察者可以添加、删除、通知观察者
        public void addObserver(PartnerOberver partnerOberver);
        public void deletOberver(PartnerOberver partnerOberver);
        public void notifyProcess(String process);
    }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8

实现了接口的被观察者类。

public class SubjectBBQ implements ISubjectBBQ{ 
    
        private ArrayList<PartnerOberver> mPartnerObervers = null;
    
        public  SubjectBBQ() {
            // TODO Auto-generated constructor stub
            mPartnerObervers = new ArrayList<PartnerOberver>();
        }
        @Override
        public void addObserver(PartnerOberver partnerOberver) {
            // TODO Auto-generated method stub
            mPartnerObervers.add(partnerOberver);
        }
    
        @Override
        public void deletOberver(PartnerOberver partnerOberver) {
            // TODO Auto-generated method stub
            mPartnerObervers.remove(partnerOberver);
        }
    
        @Override
        public void notifyProcess(String processmsg) {
            //当被观察者状态发生变化的时候就通知到观察者
            // TODO Auto-generated method stub
            for(PartnerOberver partnerOberver : mPartnerObervers) {
                partnerOberver.updata(processmsg);
            }
        }
    
    }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22
 *  23
 *  24
 *  25
 *  26
 *  27
 *  28
 *  29
 *  30

下面是观察者相关代码

public interface IPartnerObserver {
    //观察者的方法，用于更新
        public void updata(String processmsg);
    }

*  1
 *  2
 *  3
 *  4
 *  5

public class PartnerOberver implements IPartnerObserver{ 
        private String name;
        private String favorite;
    
        public PartnerOberver(String name,String favorite) {
            // TODO Auto-generated constructor stub
            this.name = name;
            this.favorite = favorite;
        }
        //根据烤肉进度来决定是否开始吃
        @Override
        public void updata(String processmsg) {
            // TODO Auto-generated method stub
            if(processmsg.equals(favorite)) {
                System.out.println(name+" "+favorite+"开吃了");
            }
        }
    }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18

下面是如何使用

public class MyClient {
    
        public static void main(String[] args) {
            // TODO Auto-generated method stub
            SubjectBBQ mSubjectBBQ = new SubjectBBQ();
    
            PartnerOberver partnerA = new PartnerOberver("小A", "七分熟");
            PartnerOberver partnerB = new PartnerOberver("小B", "八分熟");
            PartnerOberver partnerC = new PartnerOberver("小C", "十分熟");
            // 为被观察者（烤肉）注册观察者
            mSubjectBBQ.addObserver(partnerA);
            mSubjectBBQ.addObserver(partnerB);
            mSubjectBBQ.addObserver(partnerC);
    
            //烤肉状态变化
            mSubjectBBQ.notifyProcess("七分熟");
            mSubjectBBQ.notifyProcess("八分熟");
            mSubjectBBQ.notifyProcess("十分熟");
            System.out.println("11");
        }
    
    }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22

小A 七分熟开吃了   
小B 八分熟开吃了   
小C 十分熟开吃了   
观察者模式在Android中有着较多的应用，如在一个adapter钟，数据更新时，notifyDataSetChanged()也是通过观察者模式完成的。