Java创建型模式

Hello 帅帅 2021-02-05

430

•单例模式•工厂模式•抽象工厂模式•原型模式•建造者模式

单例模式

类的构造函数私有，程序中只用创建一次对象的时候使用

饿汉式（静态常量）

public class Person1 {
    private final static Person1 p = new Person1();


    private Person1() {


    }


    public static Person1 getInstance() {
        return p;
    }
}

饿汉式（静态代码块）

public class Person2 {
    private static Person2 p;


    static {
        p = new Person2();
    }




    private Person2() {


    }


    public static Person2 getInstance() {
        return p;
    }
}

懒汉式(线程不安全)

public class Person3 {
    private static Person3 p;
    private Person3() {
    }
    public static Person3 getInstance() {
        if (p == null) {
            p = new Person3();
        }
        return p;
    }
}

懒汉式(线程安全-同步方法)

public class Person3 {
    private static Person3 p;
    private Person3() {
    }
    public static synchronized Person3 getInstance() {
        if (p == null) {
            p = new Person3();
        }
        return p;
    }
}

懒汉式(线程安全-双重检查)

public class Person4 {
    private static volatile Person4 p;
    private Person4() {
    }
    public static Person4 getInstance() {
        if (p == null) {
            synchronized (Person4.class) {
                if (p == null) {
                    p = new Person4();
                }
            }
        }
        return p;
    }
}

静态内部类

// 静态内部类完成， 推荐使用
class  Person5 {
    private static volatile  Person5 instance;


    //构造器私有化
    private  Person5() {}


    //写一个静态内部类,该类中有一个静态属性  Person5
    private static class  Person5Instance {
        private static final  Person5 INSTANCE = new  Person5();
    }


    //提供一个静态的公有方法，直接返回 Person5Instance.INSTANCE
    public static synchronized  Person5 getInstance() {


        return  Person5Instance.INSTANCE;
    }
}

枚举

enum Person6 {
    INSTANCE; //属性


    public void sayOK() {
        System.out.println("ok~");
    }
}

工厂模式

把创建一个新的对象交给该对象的工厂完成

例：手机工厂，生产手机：（小米，华为）

•新建手机工厂•将要生成的手机类型字符串通过手机工厂方法交给工厂，生产手机•生产成功

Cellphone：

package com.company.demo01factory;


public  interface Cellphone {
    void type();
}

Huawei

package com.company.demo01factory;


public class Huawei implements Cellphone {
    @Override
    public void type() {
        System.out.println("华为手机");
    }
}

XiaoMi

package com.company.demo01factory;


public class XiaoMi implements Cellphone {
    @Override
    public void type() {
        System.out.println("小米手机");
    }
}

CellphoneFactory

package com.company.demo01factory;


public class CellphoneFactory {
    public Cellphone getType(String type) {
        if (type == null) {
            return null;
        }
        return switch (type) {
            case "xiaomi" -> new XiaoMi();
            case "huawei" -> new Huawei();
            default -> null;
        };
    }
}

Test

package com.company.demo01factory;


public class Test {
    public static void main(String[] args) {
        CellphoneFactory cpf = new CellphoneFactory();


        Cellphone xiaomi = cpf.getType("xiaomi");
        xiaomi.type();
    }
}

抽象工厂模式

先选择一个工厂，创建一个新的对象交给该对象的工厂完成

例：手机工厂生产手机（华为，小米，苹果），电脑工厂生产电脑（华为，小米，苹果），选择不同工厂，生产不同产品

•将抽象工厂•手机工厂，电脑工厂继承抽象工厂•选择工厂•选择产品•生产产品

Cellphone

package com.company.demo02abstractFactory.cellphone;


public interface Cellphone {
    void play();
}

Apple

package com.company.demo02abstractFactory.cellphone;


public class Apple implements Cellphone {


    @Override
    public void play() {
        System.out.println("你在玩苹果手机");
    }
}

Huawei

package com.company.demo02abstractFactory.cellphone;


public class Huawei implements Cellphone {


    @Override
    public void play() {
        System.out.println("你在玩华为手机");
    }
}

Xiaomi

package com.company.demo02abstractFactory.cellphone;


public class Xiaomi implements Cellphone {


    @Override
    public void play() {
        System.out.println("你在玩小米手机");
    }
}

Computer

package com.company.demo02abstractFactory.computer;


public interface Computer {
    void use();
}

AppleC

package com.company.demo02abstractFactory.computer;


public class AppleC implements Computer {


    @Override
    public void use() {
        System.out.println("你在使用苹果电脑");
    }
}

HuaweiC

package com.company.demo02abstractFactory.computer;


public class HuaweiC implements Computer {


    @Override
    public void use() {
        System.out.println("你在使用华为电脑");
    }
}

XiaomiC

package com.company.demo02abstractFactory.computer;


public class XiaomiC implements Computer {


    @Override
    public void use() {
        System.out.println("你在使用小米电脑");
    }
}

AbstractFactory

package com.company.demo02abstractFactory;


import com.company.demo02abstractFactory.cellphone.Cellphone;
import com.company.demo02abstractFactory.computer.Computer;


public abstract class AbstractFactory {
    abstract Cellphone createCellphone(String name);
    abstract Computer createComputer(String name);
}

CellphoneFactory

package com.company.demo02abstractFactory;


import com.company.demo02abstractFactory.cellphone.Apple;
import com.company.demo02abstractFactory.cellphone.Cellphone;
import com.company.demo02abstractFactory.cellphone.Huawei;
import com.company.demo02abstractFactory.cellphone.Xiaomi;
import com.company.demo02abstractFactory.computer.Computer;


public class CellphoneFactory extends AbstractFactory {
    @Override
    Cellphone createCellphone(String name) {
        return switch (name) {
            case "Apple" -> new Apple();
            case "Huawei" -> new Huawei();
            case "Xiaomi" -> new Xiaomi();
            default -> null;
        };
    }


    @Override
    Computer createComputer(String name) {
        return null;
    }
}

ComputerFactory

package com.company.demo02abstractFactory;


import com.company.demo02abstractFactory.cellphone.Apple;
import com.company.demo02abstractFactory.cellphone.Cellphone;
import com.company.demo02abstractFactory.cellphone.Huawei;
import com.company.demo02abstractFactory.cellphone.Xiaomi;
import com.company.demo02abstractFactory.computer.AppleC;
import com.company.demo02abstractFactory.computer.Computer;
import com.company.demo02abstractFactory.computer.HuaweiC;
import com.company.demo02abstractFactory.computer.XiaomiC;


public class ComputerFactory extends AbstractFactory {
    @Override
    Cellphone createCellphone(String name) {
        return null;
    }


    @Override
    Computer createComputer(String name) {
        return switch (name) {
            case "AppleC" -> new AppleC();
            case "HuaweiC" -> new HuaweiC();
            case "XiaomiC" -> new XiaomiC();
            default -> null;
        };
    }
}

FactoryProducer

package com.company.demo02abstractFactory;


public class FactoryProducer {
    public static AbstractFactory getFactory(String choice){
        if(choice.equalsIgnoreCase("computer")){
            return new ComputerFactory();
        } else if(choice.equalsIgnoreCase("cellphone")){
            return new CellphoneFactory();
        }
        return null;
    }
}

Test

package com.company.demo02abstractFactory;


import com.company.demo02abstractFactory.computer.Computer;


public class Test {
    public static void main(String[] args) {
        AbstractFactory computer = FactoryProducer.getFactory("computer");
        assert computer != null;
        Computer appleC = computer.createComputer("AppleC");
        appleC.use();
    }
}

原型模式

先创建多个可能用到的对象，在需要时克隆过去

例：动物cache中三个动物对象（猪，猫，狗）

•动物AnimalCache加载•通过动物名称获取动物

Animal

package com.company.demo05prototype;


public abstract class Animal implements Cloneable {
    private Integer id;
    protected String name;
    abstract void play();


    public String getType(){
        return name;
    }


    public Integer getId() {
        return id;
    }


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


    public Object clone() {
        Object clone = null;
        try {
            clone = super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return clone;
    }
}

Cat

package com.company.demo05prototype;


public class Cat extends Animal {
    public Cat() {
        name = "小猫";
    }


    @Override
    void play() {
        System.out.println("猫儿在玩耍");
    }


}

Dog

package com.company.demo05prototype;


public class Dog extends Animal{


    public Dog() {
        name = "小狗";
    }


    @Override
    void play() {
        System.out.println("小狗在玩耍");
    }
}

Pig

package com.company.demo05prototype;


public class Pig extends Animal {


    public Pig() {
        name = "小猪";
    }


    @Override
    void play() {
        System.out.println("小猪在玩耍");
    }
}

AnimalCache

package com.company.demo05prototype;
import java.util.Hashtable;
public class AnimalCache {


    private static Hashtable<Integer, Animal> AnimalMap
            = new Hashtable<Integer, Animal>();


    public static Animal getAnimal(Integer AnimalId) {
        Animal cachedAnimal = AnimalMap.get(AnimalId);
        return (Animal) cachedAnimal.clone();
    }
    public static void loadCache() {
        Cat Cat = new Cat();
        Cat.setId(1);
        AnimalMap.put(Cat.getId(),Cat);


        Dog Dog = new Dog();
        Dog.setId(2);
        AnimalMap.put(Dog.getId(),Dog);


        Pig Pig = new Pig();
        Pig.setId(3);
        AnimalMap.put(Pig.getId(),Pig);
    }
}

Test

package com.company.demo05prototype;


public class Test {
    public static void main(String[] args) {
        AnimalCache.loadCache();


        Animal clonedAnimal = (Animal) AnimalCache.getAnimal(1);
        System.out.println("Animal : " + clonedAnimal.getType());


        Animal clonedAnimal2 = (Animal) AnimalCache.getAnimal(2);
        System.out.println("Animal : " + clonedAnimal2.getType());


        Animal clonedAnimal3 = (Animal) AnimalCache.getAnimal(3);
        System.out.println("Animal : " + clonedAnimal3.getType());
    }
}

建造者模式

多个对象一起建造一个对象

例：比亚迪，特斯拉两个建造者都可以建造电动汽车，由指导则选择由谁来建造

•新建一个指导则，并将生产品牌赋给制造厂•指导者指导建造

Car

package com.company.demo04builder;


public class Car {
    private String name;
    private Integer age;
    private String hobby;


    public String getName() {
        return name;
    }


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


    public Integer getAge() {
        return age;
    }


    public void setAge(Integer age) {
        this.age = age;
    }


    public String getHobby() {
        return hobby;
    }


    public void setHobby(String hobby) {
        this.hobby = hobby;
    }
}

Builder

package com.company.demo04builder;




// 抽象 builder 类
public abstract class Builder {
    abstract void buildAge(Integer i);
    abstract void buildName();
    abstract void buildHobby();
    abstract Car createCar();
}

Byd

package com.company.demo04builder;


public class Byd extends Builder {
    Car car = new Car();


    @Override
    void buildAge(Integer i) {
        car.setAge(i);
    }


    @Override
    void buildName() {
        car.setName("比亚迪");
    }


    @Override
    void buildHobby() {
        car.setHobby("电动");
    }


    @Override
    Car createCar() {
        return car;
    }
}

Tesla

package com.company.demo04builder;




public class Tesla extends Builder {
    Car car = new Car();


    @Override
    void buildAge(Integer i) {
        car.setAge(i);
    }


    @Override
    void buildName() {
        car.setName("特斯拉");
    }


    @Override
    void buildHobby() {
        car.setHobby("也电动");
    }


    @Override
    Car createCar() {
        return car;
    }
}

Director

package com.company.demo04builder;


public class Director {
    private Builder m=null;
    public Director(Builder builder) {
        m = builder;
    }
    public Car construct() {
        m.buildName();
        m.buildAge(12);
        m.buildHobby();
        return m.createCar();
    }
}

Test

package com.company.demo04builder;


public class Test {
    public static void main(String[] args) {
        Director director = new Director(new Tesla());
        Car construct = director.construct();


        System.out.println(construct.getName());


    }
}

数据库

最后修改时间：2021-02-05 15:08:40

文章转载自Hello 帅帅，如果涉嫌侵权，请发送邮件至：contact@modb.pro进行举报，并提供相关证据，一经查实，墨天轮将立刻删除相关内容。

Java创建型模式

单例模式

饿汉式（静态常量）

饿汉式（静态代码块）

懒汉式(线程不安全)

懒汉式(线程安全-同步方法)

懒汉式(线程安全-双重检查)

静态内部类

枚举

工厂模式

抽象工厂模式

原型模式

建造者模式

评论