软件开发之路之设计模式(一)

一直都在说设计模式,设计模式,但是它究竟是什么东西,我一直都是云里雾里,具体他有什么好处,有什么特点却说不明白,更别提用了,所有抽时间研究一下

一,单例设计模式

最常用,最容易理解的一种模式

他的特点是:确保一个类只有一个实例,而且自行实例化并向整个系统提供这个实例。

注意事项:
只能使用单例类提供的方式实例化对象,不要使用反射的方式获取,否则会导致实例化了多个对象

具体代码:

   /**
 1. Created by Think on 2017/2/15.
 2. 第一种:单例懒汉式,只有在对象被创建的时候才创建,
 */
public class Singleton {
    //私有成员变量,一般来说需要加volatile修饰,
//    volatile关键字的两层语义
//    一旦一个共享变量（类的成员变量、类的静态成员变量）被volatile修饰之后，那么就具备了两层语义：
//      1）保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。
//      2）禁止进行指令重排序。
    private static volatile Singleton mSingleton = null;
    //私有空参构造
    private Singleton() {
    }
    //对外界提供获取实力的方法
    public static Singleton getInstance(){
        //首先判断对象是否实例化
        if (mSingleton == null){
            //加锁进行第二次判断,防止多线程创建对象导致实例化多个对象
            synchronized (Singleton.class){
                //此时如果对象还没有被实例化才new 一个对象出来并返回
                if (mSingleton == null){
                    mSingleton = new Singleton();
                }
            }
        }
        return mSingleton;
    }
} 

/**
 * Created by Think on 2017/2/15.
 * 第二种单例模式: 一上来就实例化,谁用我给谁,而且不存在多线程实例化多个对象的情况
 */
public class Singleton1 {
    private static volatile Singleton1 mSingleton1 = new Singleton1();

    public Singleton1() {
    }

    public static Singleton1 getInstance(){
        return mSingleton1;
    }
}

二.工厂方法设计模式
定义:
定义一个用于创建对象的接口,由子类去决定创建那个对象,工厂方法模式使一个类的实例化延迟到子类执行;

描述:
在工厂方法模式中，核心的工厂类不再负责所有的对象的创建，而是将具体创建的工作交给子类去做。这个核心类则成为了一个抽象工厂的角色，仅负责给出具体工厂子类必须实现的接口，而不接触哪一个类应当被实例化这种细节。
就好比是富士康一样,他就是一个生产手机的工厂,他可以生产各式各样的手机,但是它具体生产的方式是抽象的,他会根据接到的订单来分配给各个生产线,不同的生产线有不同的分工,所以往细了说,手机是富士康的某一个生产线生产的产品,而这个生产线就是我们的工厂方法的子类,
说到这就清楚了好多,简单的说就是工厂只负责接单,具体操作还是需要由他的子类去完成,不同的功能用的是不同的子类.

来一段示例代码:

/**
 * Created by Think on 2017/2/15.
 * 第一个角色: 抽象工厂,他只有一个生产手机的方法
 */
public interface Factory {
    Phone yieldPhone();
}

/**
 * Created by Think on 2017/2/15.
 * 第二种角色:具体工厂,生产乐视手机
 */
public class LeShiFactory implements Factory {
    @Override
    public Phone yieldPhone() {
        LeShiPhone leShiPhone = new LeShiPhone();
        leShiPhone.setName("乐视2手机");
        leShiPhone.setPrice("2000元");
        return leShiPhone;
    }
}

/**
 * Created by Think on 2017/2/15.
 * 第二种角色:具体工厂,生产小米手机
 */
public class XiaoMiFactory implements Factory {
    @Override
    public Phone yieldPhone() {
        XiaoMiPhone xiaoMiPhone = new XiaoMiPhone();
        xiaoMiPhone.setName("小米手机");
        xiaoMiPhone.setPrice("1000元");
        return xiaoMiPhone;
    }
}

/**
 * Created by Think on 2017/2/15.
 * 第三个角色: 抽象产品类
 */
public abstract class Phone {
    private String name;
    private String price;

    public String getName() {
        return name;
    }

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

    public String getPrice() {
        return price;
    }

    public void setPrice(String price) {
        this.price = price;
    }
}

/**
 * Created by Think on 2017/2/15.
 * 第四个角色: 具体产品类,乐视手机
 */
public class LeShiPhone extends Phone {
}

/**
 * Created by Think on 2017/2/15.
 * 第四个角色 : 具体产品类 ,小米手机
 */
public class XiaoMiPhone extends Phone {
}

最后是客户端角色:

 AlertDialog.Builder mBuilder;  mBuilder = new AlertDialog.Builder(this);
                mBuilder.setMessage("你想要什么手机呢?");
                mBuilder.setPositiveButton("小米手机", new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialog, int which) {
                       mFactory = new XiaoMiFactory();
                        Phone phone = mFactory.yieldPhone();
                        Toast.makeText(MainActivity.this, "给你的"+ phone.getName(), Toast.LENGTH_SHORT).show();
                    }
                });
                mBuilder.setNegativeButton("乐视手机", new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialog, int which) {
                        mFactory = new LeShiFactory();
                        Phone phone = mFactory.yieldPhone();
                        Toast.makeText(MainActivity.this, "给你的" + phone.getName(), Toast.LENGTH_SHORT).show();
                    }
                });
                mBuilder.show();

好了最后是结果了

还有一种叫抽象工厂模式,
他的定义是:
为创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类。

具体描述:
在以下情况下，适用于工厂方法模式：
1. 当一个类不知道它所必须创建的对象的类的时候。
2. 当一个类希望由它的子类来指定它所创建的对象的时候。
3. 当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候。

其实我的实例代码的抽象Phone类就相当于一个抽象工厂,他并不知道要生产什么样的手机,所以只提供属性,具体的局部由子类来完成

以上这些就是我对单例模式和工厂模式的理解,后续还会研究其他的设计模式,有不对的地方还请博友指出,谢谢