设计模式之创建型模式

设计模式之创建型模式

单例模式

是 Java 中最简单的设计模式之一涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。

public class SingletonMode {
    //单例模式之饿汉式
    // 首先，将 new Singleton() 堵死
    private SingletonMode() {};
    //创建私有静态实例，意味着这个类第一次使用的时候就会进行创建，即提前new好，之后直接使用即可
    public static SingletonMode singletonModeHungry = new SingletonMode();
//    public static SingletonMode getInstance(){
//        return singletonModeHungry;
//    }

    //单例模式之懒汉式(和饿汉模式相比，这边不需要先实例化出来，注意这里的 volatile)
    public static volatile SingletonMode singletonModeSluggard  = null;
    public static SingletonMode getInstance(){
        if(singletonModeSluggard == null){
            //加锁
            synchronized(SingletonMode.class){
                //二次判断即双重检查
                if (singletonModeSluggard == null){
                    singletonModeSluggard = new SingletonMode();
                }
            }
        }
        return singletonModeSluggard;
    }
}

package com.xaingyang.test.dataCenter;

/**
 * @description 枚举方式进行实例化，是线程安全的，此种方式也是线程最安全的
 */
public class SingletonMode2 {

    private SingletonMode2(){}

    public static SingletonMode2 getInstance(){
        return Singleton.SINGLETON.SingletonMode2 ();
    }

    private enum Singleton{
        SINGLETON;
        private SingletonMode2 singletonMode2;

        Singleton(){
            singletonMode2 = new SingletonMode2();
        }
        public SingletonMode2 getSingletonMode2(){
            return singletonExample7;
        }
    }
}

抽象工厂模式

围绕一个超级工厂创建其他工厂，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。

//创建接口
public interface Cat {

    /**
     * 定义方法
     */
    void eat();
}
public interface Dog {

    /**
     * 定义方法
     */
    void eat();
}
//创建方法实现接口
public class BlackCat implements Cat {
    @Override
    public void eat() {
        System.out.println("吃吃吃");
    }
}
public class BlackDog implements Dog {
    @Override
    public void eat() {
        System.out.println("hehehhehh");
    }
}
public class WhiteCat implements Cat {
    @Override
    public void eat() {
        System.out.println("就吃吃吃");
    }
}
public class WhiteDog implements Dog {
    @Override
    public void eat() {
        System.out.println("heheaihisahdiasndiaiadd");
    }
}
//创建抽象工厂
/**
 *这个接口就是类图中标识的
 *  AbstractFactory抽象工厂
 */
public interface AnimalFactory {
    /**
     * 定义创建Icat接口实例的方法
     */
     Cat creatCat();
    /**
     * 定义创建Idog接口实例的方法
     */
     Dog creatDog();
}
//实现抽象工厂
public class BlackAnimalFactory implements AnimalFactory {
    @Override
    public Cat creatCat() {
        return new BlackCat();
    }

    @Override
    public Dog creatDog() {
        return new BlackDog();
    }
}
public class WhiteAnimalFactory implements AnimalFactory {
    @Override
    public Cat creatCat() {
        return new WhiteCat();
    }

    @Override
    public Dog creatDog() {
        return new WhiteDog();
    }
}
//测试类
public static void main(String[] args) {
       BlackAnimalFactory blackAnimalFactory = new BlackAnimalFactory();
       Cat iCat = blackAnimalFactory.creatCat();
       iCat.eat();
       Dog iDog = blackAnimalFactory.creatDog();
       iDog.eat();

       WhiteAnimalFactory whiteAnimalFactory = new WhiteAnimalFactory();
       whiteAnimalFactory.creatCat().eat();
       whiteAnimalFactory.creatDog().eat();
}

建造者模式

使用多个简单的对象一步一步构建成一个复杂的对象，一个 Builder 类会一步一步构造最终的对象。该 Builder 类是独立于其他对象的。

/**
 * Created by xiangyang on 2021/1/14
 * 建造者模式
 */
public class BuilderPattern {
    //属性
    private String name;
    private String password;
    private String nickName;
    private int age;
    // 构造方法私有化，不然客户端就会直接调用构造方法了
    private BuilderPattern(String name,String password,String nickName,int age){
        this.name = name;
        this.password = password;
        this.nickName = nickName;
        this.age = age;
    }
    // 静态方法，用于生成一个 Builder，这个不一定要有，不过写这个方法是一个很好的习惯，
    // 有些代码要求别人写 new User.UserBuilder().a()...build() 看上去就没那么好
    public static UserBuilder builder() {
        return new UserBuilder();
    }
    public static class UserBuilder {
        //属性
        private String name;
        private String password;
        private String nickName;
        private int age;
        private UserBuilder(){}
        // 链式调用设置各个属性值，返回 this，即 UserBuilder
        public UserBuilder name(String name) {
            this.name = name;
            return this;
        }
        public UserBuilder password(String password) {
            this.password = password;
            return this;
        }
        public UserBuilder nickName(String nickName) {
            this.nickName = nickName;
            return this;
        }
        public UserBuilder age(int age) {
            this.age = age;
            return this;
        }
        // build() 方法负责将 UserBuilder 中设置好的属性“复制”到 User 中。
        // 当然，可以在 “复制” 之前做点检验
        public BuilderPattern build() {
            if (name == null || password == null) {
                throw new RuntimeException("用户名和密码必填");
            }
            if (age <= 0 || age >= 150) {
                throw new RuntimeException("年龄不合法");
            }
            // 还可以做赋予”默认值“的功能
            if (nickName == null) {
                nickName = name;
            }
            System.out.println(name);
            return new BuilderPattern(name, password, nickName, age);

        }
        public static void main(String[] args) {
            BuilderPattern d = BuilderPattern.builder()
                    .name("foo")
                    .password("pAss12345")
                    .age(25)
                    .build();
        }
    }
}

原型模式

用于创建重复的对象，同时又能保证性能。这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时，则采用这种模式。

  /**
     * 原型类，
     */
    public class Prototype implements Cloneable {
        private String name;
        public void setName(String name) {
              this.name = name;
        }
        public String getName() {
			return this.name;
		}
        public Object clone() {
			try {
				return super.clone();
			} catch (Exception e) {
				e.printStackTrace();
				return null;
            }
        }
    }
    /**
     * 原型类的子类
     */
    public class ConcretePrototype extends Prototype {
	public ConcretePrototype(String name) {
			setName(name);
	}
}
    /**
     * 测试类
     */
    public class Test {
	public static void main(String[] args) {
		Prototype pro = new ConcretePrototype("prototype");
		Prototype pro2 = (Prototype)pro.clone();
		System.out.println(pro.getName());
		System.out.println(pro2.getName());
		}
    }