Java-6种常用的设计模式

一.单例模式

（一）要点

1.某个类只有一个实例
2.它必须自行创建对象
3.它必须自行向整个系统提供这个实例

（二）实现单例模式要注意以下几点

1.私有的构造方法。保证外部无法创建实例。
2.私有的静态的类型引用。因为静态就可以保证只有一个变量引用
3.提供获取实例的方法。方法名一般为getInstance()。

（三）两种实现方式

1.单例模式之懒汉式

优点：需要对象的时候才创建。
缺点：线程不安全（可以在获取对象的方法申明上用synchronized修饰来保证线程安全）

单例模式之恶汉式

优点：实现简单。
缺点：在不需要的时候，白创建了对象，造成资源浪费

二.简单工厂模式

（一）目的

提供一个统一创建对象的场所

（二）实质

简单工厂模式的实质是由一个工厂类根据传入的参数，动态的决定应该创建哪一个产品类的实例，并且这些产品类继承自一个父类或接口

（三）要点

（1）工厂（Factory）角色。它是简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。工厂类可以被外界直接调用，创建所需的产品对象。
（2）抽象（Product）角色。简单工厂模式创建对象所属类的父类，它负责描述所有实例所共有的公共接口。
（3）具体产品角色。是简单工厂模式的创建目标，是一个具体的实例对象

（四）例子

三.工厂方法模式

（一）概述

简单工厂模式是工厂模式中最简单的一种，它在应对产品类别比较多的时候，往往力不从心，因此就有了工厂方法模式的出现。
工厂方法模式是简单工厂模式的衍生，解决了许多简单工厂模式的问题。完全实现“开闭原则”。其次更复杂的层次结构，可以应用于产品结构复杂的场合。

（二）原理

工厂方法模式对简单工厂模式进行了抽象。有一个抽象的Factory类（可以是抽象类或者接口），这个类将不再负责具体的产品生产，而是只制订一些规范（也就是申明一些抽象方法），具体的生产工作由其子类去完成。在这个模式中，工厂类和产品类可以一一对应。即一个抽象工厂对应一个抽象产品，一个具体工厂对应一个具体产品

（三）

四．抽象工厂方法模式

（一）概述

如果抽象角色不止一个时，也就是工厂需要造出多种产品（这些产品是有联系的）的时候，简单工厂模式和工厂方法模式就不太应付得了。此时，就需要使用抽象工厂方法模式了，它就是为了专门应对多种抽象产品而设计的。

（二）原理

当每个抽象产品都有多于一个的具体子类的时候，工厂角色怎么知道实例化哪一个类呢？如每个抽象产品角色都有两个具体产品。其实，抽象工厂模式提供两个具体工厂角色，分别对应着两个具体产品角色，每一个具体工厂角色只负责某一个产品角色的实例化。每一个具体工厂类只负责创建某一具体子类的实例。例如一个抽象的汽车工厂可以生产汽车及其配套的轮子，它的子类工厂是轿车工厂和卡车工厂，轿车工厂可以生产轿车和轿车轮子，卡车工厂可以生产卡车和卡车轮子。

（三）代码

abstract class Auto {//车类
}
class Car extends Auto{//轿车类
}
class Truck extends Auto{//卡车类
}
abstract class Wheel{//抽象的轮胎类
    
}
class Carwheel extends Wheel{//汽车轮胎
    
}
class Truckwheel extends Wheel{//卡车轮胎
    
}
interface createWheelAble{
    public abstract Wheel createWheel();
}
abstract class AutoFactory implements createWheelAble{
    public abstract Auto createAuto();//创建一个汽车的抽象方法
    public abstract Wheel createWheel();//创建一个轮胎的抽象方法
}
class Carfactory extends AutoFactory{

    @Override
    public Auto createAuto() {
        return new Car ();
    }

    @Override
    public Wheel createWheel() {
        return new Carwheel ();
    }
}
class Truckfactory extends AutoFactory{

    @Override
    public Auto createAuto() {
        return new Truck ();
    }

    @Override
    public Wheel createWheel() {
        return new Truckwheel ();
    }
}

接下来看看如何生产

五．观察者模式

（一）概述

观察者模式有称为监听者模式，它广泛的应用于图形化编程中。例如，当用户单击某个按钮的时候，应该做出什么响应；当商城打折的时候，应该通过Ｅ－ｍａｉｌ和电话等形式通知消费者。

（二）实现

实现观察者模式有很多方式，比较直观的一种是使用“注册，通知，撤销注册”的形式，大致过程如下：
１．观察者（Ｏｂｓｅｒｖｅｒ）将自己注册到被观察者对象（Ｓｕｂｊｅｃｔ）中，被观察者对象将观察者存放在一个容器（Ｃｏｎｔａｉｎｅｒ）中．
２．被观察对象发生了某种变化（如按钮被单击，商品价格发生变化等），从容器中得到所有注册过的观察者，将变化通知给观察者。在代码中，需要做的就是遍历容器中的观察者，调用他们的回调方法。
３．观察者告诉被观察者要撤销观察，被观察者从容器中将观察者去除。

（三）代码

package com.westos.mydemo.demo4;

import java.util.HashSet;

public class ObserverPattern {
    public static void main(String[] args) {
        Product product = new Product ( "OPPO-r9", 1140 );
        WebObserver webObserver = new WebObserver ( );//第一个观测者
        MailObserver mailObserver = new MailObserver ( );//第二个观测者
        product.addObserver ( webObserver );
        product.addObserver ( mailObserver );
        System.out.println ("===第一次价格改动===" );
        product.setPrice ( 1056 );
        webObserver.unreg ( product );   //网页观察者取消观察
        System.out.println ("===第二次价格改动===" );
        product.setPrice ( 998 );
    }
}

interface Observer{//观察者接口
    public void update(Product product);
    public void unreg(Product product);
}
class WebObserver implements Observer{

    @Override
    public void update(Product product) {
        System.out.println ("通过网页为所有会员发送价格变化消息："+product.getName ()+":"+product.getPrice ());
    }

    @Override
    public void unreg(Product product) {
        product.getObservers ().remove ( this );
    }
}
class MailObserver implements Observer{

    @Override
    public void update(Product product) {
        System.out.println ("通过Mail为所有会员发送价格变化消息："+product.getName ()+":"+product.getPrice ());
    }

    @Override
    public void unreg(Product product) {
        product.getObservers ().remove ( this );
    }
}
class Product{//产品类，被观察者
    private double price;//价格
    private String name;//商品名称
    private HashSet<Observer> observers;//存放观察者对象

    public Product( String name,double price) {
        this.price = price;
        this.name = name;
        observers=new HashSet < Observer> ( );
    }
    public void addObserver( Observer observer){//添加观察者
        observers.add ( observer );
    }
    public void notifyObserver(){
        for (Observer observer : observers) {
            observer.update ( this );
        }
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
        //当价格改变时通知观察者
        notifyObserver ();
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public HashSet <Observer> getObservers() {
        return observers;
    }

    public void setObservers(HashSet <Observer> observers) {
        this.observers = observers;
    }

}

六．模版设计模式

（一）概述

模版方法模式就是定义一个算法的骨架，而将具体的算法延迟到子类中来实现

（二）优缺点

优点：使用模版方法模式，在定义算法骨架的同时，可以很灵活的实现具体的算法，满足用户灵活多变的需求
缺点：如果算法骨架有修改的话，则需要修改抽象类

（三）代码

public abstract class CalcTime {
    //计算耗时的方法
    public long getTime(){
        long begin = System.currentTimeMillis();
        testTime();
        long end = System.currentTimeMillis();
        return end-begin;
    }

    public abstract void  testTime();
｝
public class TestFor extends CalcTime{
    @Override
    public void testTime() {
        for (int i = 0; i < 10000; i++) {
            System.out.println();
        }
    }
}
public class Test4 {
    public static void main(String[] args) {
    	long time = new TestFor().getTime();
        System.out.println(time);
    }
}