JAVA设计模式简单实现 原理 优缺点--持续更新

package com.manbu.test.demo;

import lombok.Data;
import lombok.Setter;
/**
 * @ProjectName: 设计模式
 * @Package: com.manbu.test.demo
 * @ClassName: Designpatterns
 * @Author: 漫步
 * @Description:
 * @Date: 2020/10/26 3:53 下午
 * @Version: 1.0
 */
public class Designpatterns {
    static  final  String type1="mian";
    static  final  String type2="mi";

    public static void main(String[] args) {


        /**
         * 单例模式： 饿汉
         */
        SingletonMode2 singletonMode2 = new SingletonMode2();
        Student student = new Student();

        /**
         * 单例模式： 懒汉
         */
        SingletonMode1 singletonMode1 = new SingletonMode1();
        EatFactory eatFactory;
        /**
         * 简单工厂模式
         * 优点：
         * 工厂类包含必要的逻辑判断，可以决定在什么时候创建哪一个产品的实例。客户端可以免除直接创建产品对象的职责，很方便的创建出相应的产品。工厂和产品的职责区分明确。
         * 客户端无需知道所创建具体产品的类名，只需知道参数即可。
         * 也可以引入配置文件，在不修改客户端代码的情况下更换和添加新的具体产品类。
         * 缺点：
         * 简单工厂模式的工厂类单一，负责所有产品的创建，职责过重，一旦异常，整个系统将受影响。且工厂类代码会非常臃肿，违背高聚合原则。
         * 使用简单工厂模式会增加系统中类的个数（引入新的工厂类），增加系统的复杂度和理解难度
         * 系统扩展困难，一旦增加新产品不得不修改工厂逻辑，在产品类型较多时，可能造成逻辑过于复杂
         * 简单工厂模式使用了 static 工厂方法，造成工厂角色无法形成基于继承的等级结构。
         *
         */
         switch ("mi"){
             case type1:
                 eatFactory = new eatMian();
                 break;
             case type2:
                 eatFactory = new eatMian();
                 break;
             default:
                 eatFactory = null;
                 break;

         }
        eatFactory.eat();
        System.out.println("----");
    }


}
/**
 * 单例模式 实体对象
 */
@Data
@Setter
class Student implements Cloneable{

    private int id;
    private String name;
    private String password;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}
/**
 * 单例模式 懒汉模式
 * 该模式的特点是类加载时没有生成单例，只有当第一次调用 getStudent 方法时才去创建这个单例。代码如下：
 * 注意：如果编写的是多线程程序，则不要删除代码中的关键字 volatile 和 synchronized，否则将存在线程非安全的问题。如果不删除这两个关键字就能保证线程安全，但是每次访问时都要同步，会影响性能，且消耗更多的资源，这是懒汉式单例的缺点。
 */
class SingletonMode1{

    //volatile 关键字 保证 Student 在所有线程中同步
    private static volatile Student instance=null;
    // 构造器
    public SingletonMode1(){

    }    //private 避免类在外部被实例化
    public static synchronized Student getStudent()
    {
        //getInstance 方法前加同步
        if(instance==null)
        {
            instance=new Student();
        }
        return instance;
    }
}

/**
 * 单例模式 饿汉模式
 * 该模式的特点是类一旦加载就创建一个单例，保证在调用 getStudent 方法之前单例已经存在了。
 */
class SingletonMode2 {

    //volatile 关键字 保证 Student 在所有线程中同步
    private static volatile Student instance = null;

    // 构造器
    public SingletonMode2() {

    }    //private 避免类在外部被实例化

    public static synchronized Student getStudent() {
        //getInstance 方法前加同步
        if (instance == null) {
            instance = new Student();
        }
        return instance;
    }



}

/**
 * 简单工厂模式 工厂类
 * 定义工厂提供的信息 具体操作交给实现层决定
 */
interface  EatFactory{
    void eat();
}
/**
 * 简单工厂模式 工厂实现类
 * 具体执行工厂的操作
 */
class eatMian implements EatFactory{

    @Override
    public void eat() {
        System.out.println("I love Eat Mian Tiao");
    }
}
class eatMi implements EatFactory{

    @Override
    public void eat() {
        System.out.println("I love Eat Mi Fan");
    }
}