JAVA设计模式理解与总结 单例模式&工厂模式&建造者模式

码了好几年代码的打字机器我,对于设计模式这个词,肯定是一点也不陌生,但是对于设计模式的理解,因为日常开发中,增删改查较多,使用设计模式思想来优化代码的机会就很少。也不乏在翻阅源码的时候,叹服于别人优秀高效的设计。所有今天抽出点时间,对设计模式做个归纳、记录,以便日后读到优秀的源码,可以自信的说,这**不就是那啥吗,我也会写~

设计模式

设计模式(Design Pattern)是前辈们对代码开发经验的总结,是解决特定问题的一系列套路。它不是语法规定,而是一套用来提高代码可复用性、可维护性、可读性、稳健性以及安全性的解决方案

单例模式

饿汉模式

不管你需不需要,我都给你准备好,对于饿汉来说,心里踏实

饿汉模式很简单,提前提供实例对象 代码样例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class SingleMan {

private SingleMan() {

}
static {
System.out.println("类加载");
}
private static SingleMan instance = new SingleMan();
public static SingleMan getInstance() {
return instance;
}
public void sayHello() {
System.out.println("你好,相亲吗");
}
}

饿汉式与线程安全

实例在类加载时实例化,有JVM保证线程安全。

虚拟机在编译加载某个类的时候,会将所有类变量(static)、静态代码块(static{})进行赋值。

虚拟机会在执行该操作时加锁,保证同一个类加载器下,一个类型只会初始化一次!

题外话: 类的加载时机

JVM只在需要某个类或者使用Class.forName(className)强制加载类的时候才会被调用,如果只是声明某个类的引用,而没有创建对象则不会加载该类

懒汉模式

懒汉模式,厨房有材料,鸡鸭鱼肉,饿得不行了,非吃不可了,才去做饭,此为懒汉

非线程安全的懒汉模式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class SingleMan {

private SingleMan() {
}
static {
System.out.println("类加载");
}
private static SingleMan instacne = null;
public static SingleMan getInstance() {
if (null == instacne) {
instacne = new SingleMan();
}
return instacne;
}
public void sayHello() {
System.out.println("你好,相亲吗");
}
}

线程安全的懒汉模式

使用 双重检验锁

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class SingleMan {

private SingleMan() {
}
static {
System.out.println("类加载");
}
private static SingleMan instacne = null;
public static SingleMan getInstance() {
if (null == instacne) {
synchronized (SingleMan.class) {
if (null == instacne) { //为什么两次判断,想想并发
instacne = new SingleMan();
}
}
}
return instacne;
}
public void sayHello() {
System.out.println("你好,相亲吗");
}
}

懒汉模式不推荐 在getInstance() 方法上加上 synchronized,性能太差了!

懒汉模式 与 volatile

双重检验锁堪称完美,但是还存在不足,问题出在 new SingleMan()上,这段代码在执行的时候,是非原子操作,不同线程交替会造成安全问题

解决很简单,只需要给类变量SingleMan 添加 volatile

volatile 的作用 :

  • 保证了不同线程对这个变量进行操作时的可见性,即一个线程修改了某个变量的值,这新值对其他线程来说是立即可见的
  • 禁止进行指令重排序
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class SingleMan {

private SingleMan() {
}
static {
System.out.println("类加载");
}
private volatile static SingleMan instacne;
public static SingleMan getInstance() {
if (null == instacne) {
synchronized (SingleMan.class) {
if (null == instacne) { //为什么两次判断,想想并发
instacne = new SingleMan();
}
}
}
return instacne;
}
public void sayHello() {
System.out.println("你好,相亲吗");
}
}

工厂模式

定义一个创建对象的接口,让其子类自己决定实例化哪一个工厂类,工厂模式使其创建过程延迟到子类进行

优点:

  1. 一个调用者想创建一个对象,只要知道其名称就可以了。
  2. 扩展性高,如果想增加一个产品,只要扩展一个工厂类就可以。
  3. 屏蔽产品的具体实现,调用者只关心产品的接口。

在任何需要生成复杂对象的地方,都可以使用工厂方法模式

简单工厂模式

看名字就简单,要不就不写了吧? 哈哈

简单工厂模式 就是一个工厂类,里面有一个静态方法,根据我们不同的参数,返回不同的派生自同一个父类(或实现同一接口)的实例对象。

产品类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Animal {
void eat(){};
}
public class Cat extends Animal {
@Override
public void eat() {
System.out.println("小猫吃鱼,喵喵喵~~~");
}
}
public class Dog extends Animal {
@Override
public void eat() {
System.out.println("小狗吃骨头,汪汪~~~");
}
}

工厂:

1
2
3
4
5
6
7
8
9
10
11
public class AnimalFactory {
public static Animal getInstance(String food) {
if (food.equals("yu")) {
return new Dog();
}else if (food.equals("gutou")) {
return new Cat();
}else {
return null;
}
}
}

测试:

1
2
3
4
5
6
public static void main(String[] args) {
Animal animal1 = AnimalFactory.getInstance("yu");
animal1.eat();
Animal animal2 = AnimalFactory.getInstance("gutou");
animal2.eat();
}

小狗吃骨头,汪汪~

小猫吃鱼,喵喵喵~

工厂模式

工厂模式,就是多个工厂的组合使用

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
//地球总厂
interface EarthFactory{
Animal getInstance(String food);
}
//动物厂
public class AnimalFactory implements EarthFactory{
@Override
public Animal getInstance(String food) {
if (food.equals("yu")) {
return new Dog();
}else if (food.equals("gutou")) {
return new Cat();
}else {
return null;
}
}
}
//植物厂
public class PlantFactory implements EarthFactory{
@Override
public Animal getInstance(String food) {
if (food.equals("yu")) {
return new Tree();
}else if (food.equals("gutou")) {
return new Grass();
}else {
return null;
}
}
}

使用

1
2
3
4
public static void main(String[] args) {
EarthFactory ef = new PlantFactory();
ef.getInstance("yu").eat();
}

虽然喂得都是 yu(鱼),但是不同东西,吃的效果就不一样了

抽象工厂模式

抽象工厂模式解决的就是工厂模式产品不匹配的问题

我想造一部手机,有两个工厂,分别定制 主板外壳

使用 华为定制的主板,苹果定制的外壳,组装在一起,肯定会出问题。所以我们采用一个工厂生产一系列原配件的方式

  1. 主板和外壳
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
@Data
public class Bord {
private String name;
public Bord(String name) {
this.name = name;
}
}
@Data
public class Shell {
private String name;

public Shell(String name) {
this.name = name;
}
}
//华为主板栗子
public class HuaweiBord extends Bord {
public HuaweiBord(String name) {
super(name);
}
}
  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
public interface PhoneFactory {
//造主板
Bord makeBord();
//造外壳
Shell makeShell();
}
//华为厂
public class Huawei implements PhoneFactory {
@Override
public Bord makeBord() {
System.out.println("造华为主板");
return new HuaweiBord("华为主板");
}
@Override
public Shell makeShell() {
System.out.println("造华为外壳");
return new HuaweiShell("华为外壳");
}
}
//苹果厂
public class Apple implements PhoneFactory {
@Override
public Bord makeBord() {
System.out.println("造苹果主板");
return new AppleBord("苹果主板");
}
@Override
public Shell makeShell() {
System.out.println("造苹果外壳");
return new AppleShell("苹果外壳");
}
}
  1. 富士康手机组装
1
2
3
4
5
6
7
8
9
public class Fushikang {
private Bord bord;
private Shell shell;
public void build(PhoneFactory factory) {
this.bord = factory.makeBord();
this.shell = factory.makeShell();
System.out.println(bord.getName() + " || " + shell.getName());
}
}
  1. 生成一台华为手机
1
2
3
4
public static void main(String[] args) {
PhoneFactory huawei = new Huawei();
new Fushikang().build(huawei);
}

造华为主板
造华为外壳
华为主板 || 华为外壳

建造者模式

将一个复杂对象的构建与其表示分离,使得同样的构建过程可以创建不同的表示

就是我想组装一台手机, 手机组装的流程是一样的,但是相同的流程,使用不同的配件来组装,得到手机的配置也不一样。

简单地说就是 new xxBuilder().x().y().z().build();

  1. 手机
1
2
3
4
5
6
7
8
9
10
11
12
13
@Data
public class Phone {
private String cpu;
private String screen;
private Integer ram;
private Phone() {
}
public Phone(String cpu, String screen, Integer ram) {
this.cpu = cpu;
this.screen = screen;
this.ram = ram;
}
}
  1. 手机建造者
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class PhoneBuilder {
private Phone phone;
private String cpu;
private String screen;
private Integer ram;

public PhoneBuilder cpu(String cpu) {
this.cpu = cpu;
return this;
}
public PhoneBuilder screen(String screen) {
this.screen = screen;
return this;
}
public PhoneBuilder ram(Integer ram) {
this.ram = ram;
return this;
}
public Phone build() {
return new Phone(this.cpu, this.screen, this.ram);
}
}
  1. 建造手机
1
2
3
public static void main(String[] args) {
Phone iphone = new PhoneBuilder().cpu("amd").screen("1920*1080").ram(16).build();
}

到这里,对于创建对象的创建型模式就先记录到这,原型模式就不介绍了,就是对对象的拷贝

下一篇有时间,记录一下代理模式,适配器模式等





更多好玩好看的内容,欢迎到我的博客交流,共同进步        WaterMin