Java常用的设计模式

常用的设计模式分类： 
创建型（创建一个对象）：单例模式、工厂模式、抽象工厂模式 
结构型（将几个对象组织成一个结构）：桥接模式、外观模式、代理模式 
行为型（多个对象间的通信）：观察者模式、策略模式 
其中，工厂模式、桥接模式、策略模式有点像，放在一起理解（几个对象具有共同特征，因此继承共同的接口，然后通过工厂、桥去访问）。另外，工厂模式和外观模式（几个对象间有先后关系，是串行的，而非工厂模式中的并行，因此几个对象组合成一个外观类，通过这个外观类来访问）区别很明显，也因此放在一起理解。
设计模式的原则
总结起来，就是多用接口/抽象类，从而增加代码的可扩展性(减少修改代码)。降低模块间的依赖和联系。 
体现了OOP的模块化、可扩展性等特征。

1.工厂模式
定义与使用场合：现在需要创建几个对象，且这几个对象有共同特征，则不需要具体创建各个对象，而是创建对象工厂类即可。 
一般常用静态工厂模式。

public interface Sender {  
    public void Send();  
}  

public class MailSender implements Sender {  
    @Override  
    public void Send() {  
        System.out.println("this is mailsender!");  
    }  
}  

public class SmsSender implements Sender {  

    @Override  
    public void Send() {  
        System.out.println("this is sms sender!");  
    }  
}  

public class SendFactory {  

    public static Sender produceMail(){  
        return new MailSender();  
    }  

    public static Sender produceSms(){  
        return new SmsSender();  
    }  
}  

public class FactoryTest {  

    public static void main(String[] args) {      
        Sender sender = SendFactory.produceMail();  
        sender.Send();  
    }  
}  

一、单例模式

/**  
 * 线程安全  并且效率高  
 *  
 */  
public class SingletonTest {   
    private static SingletonTest instance;   
  
    private SingletonTest() {   
    }   
  
    public static SingletonTest getIstance() {   
        if (instance == null) {   
            synchronized (SingletonTest.class) {   
                if (instance == null) {   
                    instance = new SingletonTest();   
                }   
            }   
        }   
        return instance;   
    }   
}  

2.工厂设计模式

程序在接口和子类之间加入了一个过渡端，通过此过渡端可以动态取得实现了共同接口的子类实例化对象。

Java代码 
interface Animal { // 定义一个动物的接口  
    public void say(); // 说话方法  
}   
  
class Cat implements Animal { // 定义子类Cat  
    @Override  
    public void say() { // 覆写say()方法  
        System.out.println("我是猫咪，喵呜！");   
    }   
}   
  
class Dog implements Animal { // 定义子类Dog  
  
    @Override  
    public void say() { // 覆写say()方法  
        System.out.println("我是小狗，汪汪！");   
    }   
}   
  
class Factory { // 定义工厂类  
    public static Animal getInstance(String className) {   
        Animal a = null; // 定义接口对象  
        if ("Cat".equals(className)) { // 判断是哪个子类的标记  
            a = new Cat(); // 通过Cat子类实例化接口  
        }   
        if ("Dog".equals(className)) { // 判断是哪个子类的标记  
            a = new Dog(); // 通过Dog子类实例化接口  
        }   
        return a;   
    }   
}   
  
public class FactoryDemo {   
  
    public static void main(String[] args) {   
        Animal a = null; // 定义接口对象  
        a = Factory.getInstance(args[0]); // 通过工厂获取实例  
        if (a != null) { // 判断对象是否为空  
            a.say(); // 调用方法   
        }   
    }   
}  

3.代理设计模式

  指由一个代理主题来操作真实主题，真实主题执行具体的业务操作，而代理主题负责其他相关业务的处理。比如生活中的通过代理访问网络，客户通过网络代理连接网络（具体业务），由代理服务器完成用户权限和访问限制等与上网相关的其他操作（相关业务）。

Java代码
interface Network { // 定义Network接口  
    public void browse(); // 定义浏览的抽象方法  
}   
  
class Real implements Network { // 真实的上网操作  
    public void browse() { // 覆写抽象方法  
        System.out.println("上网浏览信息！");   
    }   
}   
  
class Proxy implements Network { // 代理上网  
    private Network network;   
  
    public Proxy(Network network) {// 设置代理的真实操作  
        this.network = network; // 设置代理的子类  
    }   
  
    public void check() { // 身份验证操作  
        System.out.println("检查用户是否合法！");   
    }   
  
    public void browse() {   
        this.check(); // 调用具体的代理业务操作  
        this.network.browse(); // 调用真实的上网操作  
    }   
}   
  
public class ProxyDemo {   
    public static void main(String args[]) {   
        Network net = null; // 定义接口对象  
        net = new Proxy(new Real()); // 实例化代理，同时传入代理的真实操作  
        net.browse(); // 调用代理的上网操作   
    }   
}  

4.观察者设计模式

 所谓观察者模式，举个例子现在许多购房者都密切观察者房价的变化，当房价变化时，所有购房者都能观察到，以上的购房者属于观察者，这便是观察者模式。
 java中可以借助Observable类和Observer接口轻松实现以上功能。当然此种模式的实现也不仅仅局限于采用这两个类。

定义与使用场景：一个对象(subject)被其他多个对象(observer)所依赖。则当一个对象变化时，发出通知，其它依赖该对象的对象都会收到通知，并且随着变化。 
比如 声音报警器和闪光灯报警器分别订阅热水器温度，热水器温度过高时，发出通知，两个报警器分别发声、闪光以实现报警。 
又比如很多人订阅微信公众号，该公众号有更新文章时，自动通知每个订阅的用户。 
**实现：**1,多个观察者要订阅这个对象 2，这个对象要发出通知

import java.util.Observable;   
import java.util.Observer;   
  
class House extends Observable {   
    private float price;   
  
    public void setPrice(float price) {   
        this.setChanged();// 设置变化点  
        this.notifyObservers(price);// 通知所有观察者价格改变  
        this.price = price;   
    }   
  
    public float getPrice() {   
        return this.price;   
    }   
  
    public House(float price) {   
        this.price = price;   
    }   
  
    public String toString() {   
        return "房子价格为: " + this.price;   
    }   
}   
  
class HousePriceObserver implements Observer {   
    private String name;   
  
    public HousePriceObserver(String name) {   
        super();   
        this.name = name;   
    }   
  
    @Override  
    public void update(Observable o, Object arg) {// 只要改变了 observable 对象就调用此方法  
        if (arg instanceof Float) {   
            System.out.println(this.name + "观察的价格更改为:"  
                    + ((Float) arg).floatValue());   
        }   
  
    }   
  
}   
  
public class ObserDeom {   
    public static void main(String[] args) {   
        House h = new House(1000000);   
        HousePriceObserver hpo1 = new HousePriceObserver("购房者A");   
        HousePriceObserver hpo2 = new HousePriceObserver("购房者B");   
        HousePriceObserver hpo3 = new HousePriceObserver("购房者C");   
        h.addObserver(hpo1);// 给房子注册观察者   
        h.addObserver(hpo2);// 给房子注册观察者   
        h.addObserver(hpo3);// 给房子注册观察者   
        System.out.println(h);// 输出房子价格   
        // 修改房子价格，会触发update(Observable o, Object arg)方法通知购房者新的房价信息  
        h.setPrice(2222222);//   
        System.out.println(h);// 再次输出房子价格   
    }   
}