一、变种Builder模式(构造者模式) 1、构造者模式包含如下角色
Builder:抽象建造者
ConcreteBuilder:具体建造者
Director:指挥者
Product:产品角色
2、对Builer模式使用方法的总结:
对于习惯使用get、set方法的人来说,构造者模式多此一举,但是用起来是真的香啊。 🤣 看看代码多么优雅呢!
(1)、外部类的构造函数私有,且参数为静态内部类;
(2)、静态内部类拥有外部类相同的属;
(3)、为每一个属性,写一个方法,返回的是Builer;
(4)、最后一个方法是build方法,用于构建一个外部类;
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 public class Person { private final int id; private final String name; private int age; private String sex; private String phone; private String address; private String desc; public Person (Builder builder) { this .id = builder.id; this .name = builder.name; this .age = builder.age; this .sex = builder.sex; this .phone = builder.phone; this .address = builder.address; this .desc = builder.desc; } public static class Builder { private final int id; private final String name; private int age; private String sex; private String phone; private String address; private String desc; public Builder (int id, String name) { this .id = id; this .name = name; } public Builder sex (String sex) { this .sex = sex; return this ; } public Builder phone (String phone) { this .phone = phone; return this ; } public Builder address (String address) { this .address = address; return this ; } public Builder desc (String desc) { this .desc = desc; return this ; } public Person builder () { return new Person(this ); } } @Override public String toString () { return "Person{" + "id=" + id + ", name='" + name + '\'' + ", age=" + age + ", sex='" + sex + '\'' + ", phone='" + phone + '\'' + ", address='" + address + '\'' + ", desc='" + desc + '\'' + '}' ; } public static void main (String[] args) { Person person = new Person.Builder(1 ,"michong" ).sex("男" ).builder(); System.out.println(person.toString()); } }
二、单例模式
当需要控制一个类的实例只能有一个,而且客户只能从一个全局访问点访问它时,可以选用单例模式,这些功能恰好是单例模式要解决的问题。
五种实现方式 1、懒汉式
先判断,再生成对象
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 public class Singleton { private static Singleton instance = null ; private Singleton () { } public static synchronized Singleton getInstance () { if (instance == null ) { instance = new Singleton(); } return instance; } }
2、饿汉式
二话不说,直接生成对象
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 public class Singleton2 { private static Singleton2 instance = new Singleton2(); private Singleton2 () { } public static Singleton2 getInstance () { return instance; } }
3、双重加锁 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 public class Singleton3 { private volatile static Singleton3 instance = null ; private Singleton3 () { } public static Singleton3 getInstance () { if (instance == null ) { synchronized (Singleton3.class) { if (instance == null ) { instance = new Singleton3(); } } } return instance; } }
4、静态内部类 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 public class Singleton4 { private static class SingletonHolder { private static Singleton4 instance = new Singleton4(); } private Singleton4 () { } public static Singleton4 getInstance () { return SingletonHolder.instance; } }
5、枚举 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 public enum Singleton5 { instance; public static void main (String[] args) { System.err.println(Singleton5.instance.hashCode()); System.err.println(Singleton5.instance.hashCode()); } }
三、简单工厂模式 1、定义
提供一个创建对象实例
的功能,而无须关心其具体实现。被创建的类型可以是接口
、抽象类
,也可以是具体类
2、选择的时机
完全封装隔离具体实现,让外部只能通过接口来操作封装体
想要把对创建对象的职责集中管理和控制
3、示例代码 Api 1 2 3 4 5 6 7 8 9 10 11 12 13 public interface Api { public void operation (String s) ; }
ImplA 1 2 3 4 5 6 7 8 9 10 11 12 13 public class ImplA implements Api { @Override public void operation (String s) { System.out.println("ImplA s=" + s); } }
ImplB 1 2 3 4 5 6 7 8 9 10 11 12 13 14 public class ImplB implements Api { @Override public void operation (String s) { System.out.println("ImplA s=" + s); } }
Factoty 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 public class Factory { private Factory () { } public static Factory getInstance () { return FactoryHolder.factory; } public Api createApi (int condition) { Api api = null ; if (condition == 1 ) { api = new ImplA(); } else if (condition == 2 ) { api = new ImplB(); } return api; } static class FactoryHolder { public static final Factory factory = new Factory(); } }
Client 1 2 3 4 5 6 7 8 9 10 11 12 13 14 public class Client { public static void main (String[] args) { Api api = Factory.getInstance().createApi(1 ); api.operation("正在使用简单工厂~" ); } }
四、工厂方法模式 1、定义
定义一个用于创建对象的借口,让子类决定实例化哪一个类,FactoryMethod使一个类的实例化延迟到子类。
2、结构 Product
:定义工厂方法所创建的对象的接口,也就是实际需要使用的对象的接口。
ConcreteProduct
:具体的Product接口的实现对象。
Creator
:创建器,声明工厂方法,工厂方法通常会返回一个Product类的实例对象,而且多是抽象方法
ConcreteCreator
:具体的创建器对象,覆盖实现Creator定义的工厂方法,返回具体的Product实例
3、示例代码 Product 1 2 3 4 5 6 7 8 9 public interface Product {}
ConcreteProduct 1 2 3 4 5 6 7 8 9 public class ConcreteProduct implements Product {}
Creator 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 public abstract class Creator { protected abstract Product factoryMethod () ; public void someOperation () { Product product = factoryMethod(); } }
ConcreteCreator 1 2 3 4 5 6 7 8 public class ConcreteCreator extends Creator { @Override protected Product factoryMethod () { return new ConcreteProduct(); } }
五、抽象工厂模式(Abstract Factory Pattern) 1、定义
提供一个创建一系列相关或相互依赖对象的接口,而无须指定它们具体的类。抽象工厂模式又称为Kit模式,属于对象创建型模式。
2、模式结构
AbstractFactory
:抽象工厂
ConcreteFactory
:具体工厂
AbstractProduct
:抽象产品
Product
:具体产品
六、其他 更多的设计模式请看菜鸟教程