Java学习笔记——初识设计模式（单例和简单工厂）

设计模式（单例和简单工厂）

设计模式
    1 单例设计模式
    2 简单工厂设计模式

第一节 设计模式

设计模式

设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。

简单理解：特定问题的特定解决方法。

1.1 单例设计模式

1.1.1 什么是单例：
    在程序运行，一个类只需要一个实例，不能出现多个实例，就叫单例。

1.1.2 单例的模式动机：
    在一个系统或平台中，某个类的实例（对象），只需要有一个
    一个朝代只能有一个皇帝，一个公司只能有一个老板

1.1.3 实现原理：封装
    得到一个类的对象，需要通过new关键字，调用构造方法创建对象

    实现过程：
    分析：某个类只能有一个对象，但是构造方法只要一调用就会产生新的对象，可以通过封装将构造方法进行私有化；
    若构造方法私有化，那么此类将没有对象
    私有化的构造方法可以在类内部调用创建对象

1.1.4 需要完成的事项：
        1）私有化构造方法；
        2）在类内创建对象；
        3）提供一个共有的方法，用来获取本类对象

1.1.5 实现方式：
    单例分为懒汉式和饿汉式
    核心：
    构造方法私有：不能在类外随意创建对象
    在类内部声明一个本类静态的对象作为属性
    提供一个共有静态的方法用来获取本类对象

饿汉式代码实现：

public class Boss{
    //属性
    private String name;
    private int age;
    //私有化构造方法
    private Boss(String name, int age){
        this.name = name;
        this.age = age;
    }
    //私有静态本类对象作为属性
    private static Boss boss = new Boss("马云",12);
    //提供共有静态方法获取本类对象
    public static Boss getBoss(){
        return boss;
    }
}

懒汉式代码实现：

pulbic class King{
    //属性
    private String name;
    private int age;
    //私有构造方法
    private King(String name, int age){
        this.name = name;
        this.age = age;
    }
    //私有静态本类对象
    private static King king;
    //共有静态方法获取本类对象
    public static King getKing(){
        if(king==null){
            king = new King("唐太宗",12);
        }
        return king;
    }
}

思考：懒汉式和饿汉式有什么区别？
书写上的区别：懒汉是调用方法是初始化对象，饿汉是声明同时初始化
使用上没有区别
存储时：在第一次获取单例类对象前，懒汉比饿汉节省空间
多线程操作时区别：懒汉式存在线程安全问题，饿汉式不存在

1.2 简单工厂设计模式

1.原理：多态

生活中的工厂：手机厂，电视厂，服装厂…

2.动机：

考虑一个简单的软件应用场景，一个软件系统可以提供多个外观不同的按钮（如圆形按钮、矩形按钮、菱形按钮等），这些按钮都源自同一个基类，不过在继承基类后不同的子类修改了部分属性从而使得它们可以呈现不同的外观，如果我们希望在使用这些按钮时，不需要知道这些具体按钮类的名字，只需要知道表示该按钮类的一个参数，并提供一个调用方便的方法，把该参数传入方法即可返回一个相应的按钮对象，此时，就可以使用简单工厂模式。

3.优缺点：

优点：工厂类包含产品的判断逻辑，可以决定创建哪一个产品类的实例，客户端可以免除直接创建产品对象的责任，而仅仅“消费”产品；简单工厂模式通过这种做法实现了对责任的分割，它提供了专门的工厂类用于创建对象。

缺点：由于工厂类集中了所有产品创建逻辑，一旦不能正常工作，整个系统都要受到影响。使用简单工厂模式将会增加系统中类的个数，在一定程序上增加了系统的复杂度和理解难度。系统扩展困难，一旦添加新产品就不得不修改工厂逻辑，在产品类型较多时，可能造成工厂逻辑过于复杂，不利于系统的扩展和维护。

4.案例：

服装厂：生产服装

分析：

需要一个服装厂类：工厂，类中具有生产服装的功能（创建服装对象）

服装类(父类产品)：抽象类表示

服装子类(具体产品): 普通类表示

客户程序：使用工厂的程序。

/**
 * 服装类
 * @author wgy
 *
 */
public abstract class Clothing {
    //准备布料
    public abstract void prepare();

    //制作
    public abstract void make();

    //包装
    public abstract void box();
}


public interface FuZhuang {
    //成员方法：
    public abstract void fun();
}
/**
 * 裤子
 * @author wgy
 *
 */
public class Trousers extends Clothing{

    @Override
    public void prepare() {
        System.out.println("准备制作裤子的布料......");

    }

    @Override
    public void make() {
        System.out.println("开始制作......");
    }

    @Override
    public void box() {
        prepare();
        make();
        System.out.println("包装完毕.....");

    }

}

/**
 * T恤
 * @author wgy
 *
 */
public class Tshirt extends Clothing{

    @Override
    public void prepare() {
        System.out.println("准备制作T恤的布料...");
    }

    @Override
    public void make() {
        System.out.println("开始制作T恤......");
    }

    @Override
    public void box() {
        prepare();
        make();
        System.out.println("打包T恤.....");

    }

}

public class Factory {
        /**
     * 创建对象方法
     * 1 表示 Trousers
     * 2 表示 Tshirt
     * @return
     */
    public static Clothing create(int type) {
        Clothing clothing=null;
        if(type==1) {
            clothing=new Trousers();
        }else if(type==2){
            clothing=new Tshirt();
        }
        if(clothing!=null) {
            clothing.box();
        }
        return clothing;
    }
}
import java.util.Scanner;
public class Test {
    public static void main(String[] args) {
        System.out.println("--------欢迎来到郑帅服装厂--------");
        System.out.println("-----------1 裤子   2 T恤-----------------");
        System.out.println("请选择购买的衣服");
        Scanner input=new Scanner(System.in);
        int choice=input.nextInt();
        Clothing clothing=Factory.create(choice);
        if(clothing!=null) {
            System.out.println("购买成功");
        }else{
             System.out.println("购买失败");
        }
    }
}

总结

1 设计模式：特定问题的特定解决方法      

1.1 单例设计模式 ：  
    懒汉式 
    饿汉式
    1 私有化构造方法
    2 在类内部创建一个静态对象
    3 通过一个公开的方法返回这个对象

1.2 简单工厂设计模式： 把对象的创建交给一个独立的工厂类创建。把对象的创建和使用分隔开
    1 父类产品
    2 子类产品
    3 工厂
    4 客户程序