1
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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
/**
* 蛋糕接口
*/
public interface Cake {
}
/**
* 奶油蛋糕
*/
public class CreamCake implements Cake {
}
/**
* 水果蛋糕
*/
public class FruitCake implements Cake {
}
/**
* 蛋糕工厂
*/
public class CakeFactory {
/*
* 创建水果蛋糕
*/
public Cake createFruitCake(){
return new FruitCake();
}
/*
* 创建奶油蛋糕
*/
public Cake createCreamCake(){
return new CreamCake();
}
}
/**
*客户端调用
*/
public class Client {
public static void main(String[] args) {
CakeFactory factory = new CakeFactory();
Cake fruitcake = factory.createFruitCake();
Cake creamCake = factory.createCreamCake();
}
}

1
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
/**
* 蛋糕工厂
*/
public class CakeFactory {
/*
* 创建水果蛋糕
*/
public static Cake createFruitCake(){
return new FruitCake();
}
/*
* 创建奶油蛋糕
*/
public static Cake createCreamCake(){
return new CreamCake();
}
}
/**
*客户端调用
*/
public class Client {
public static void main(String[] args) {
Cake fruitcake = CakeFactory.createFruitCake();
Cake creamCake = CakeFactory.createCreamCake();
}
}

1
2
在遵守开闭原则的情况下，使用工厂方法，可以动态的创建新的产品而不需要改动工厂类。

1
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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
/**
* 蛋糕工厂
*/
public interface AbstractCakeFactory {
/*
* 制造蛋糕
*/
public Cake makeCake();
}
/**
* 水果蛋糕工厂
*/
public class FruitCakeFactory implements AbstractCakeFactory {
@Override
public Cake makeCake() {
/*
* 创建水果蛋糕
*/
return new FruitCake();
}
}
/**
* 奶油蛋糕工厂
*/
public class CreamCakeFactory implements AbstractCakeFactory {
@Override
public Cake makeCake() {
/*
* 创建奶油蛋糕
*/
return new CreamCake();
}
}
public class Client {
public static void main(String[] args) {
//想要水果蛋糕，先造一个水果蛋糕工厂，制出来的就是水果蛋糕
AbstractCakeFactory fruitfactory = new FruitCakeFactory();
fruitfactory.makeCake();
//想要奶油蛋糕，先造一个奶油蛋糕工厂，制出来的就是奶油蛋糕
AbstractCakeFactory creamfactory = new CreamCakeFactory();
creamfactory.makeCake();
}
}

1
2
让整个系统中只有一个实例，就像一个国家只能有一个皇帝。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/**
* 皇帝单例
*/
public class Emperor {
//构造器私有
private Emperor(){}
//实例私有
private static Emperor instance;
public static Emperor getEmperor(){
if(null == instance){
synchronized(instance){
if(null == instance){
instance = new Emperor();
}
}
}
return instance;
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/**
* 皇帝单例
*/
public class Emperor {
//构造器私有
private Emperor(){}
//私有内部类
private static class EmperorVoter{
private static Emperor instance = new Emperor();
}
public static Emperor getEmperor(){
return EmperorVoter.instance;
}
}

1
2
3
4
5
6
/**
* 皇帝单例
*/
public enum Emperor {
INSTANCE
}

1
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
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
/**
* 可定制的蛋糕
*/
public class ChosenCake {
//豆沙
private String dousha;
//水果块
private String shuiguo;
public String getDousha() {
return dousha;
}
public void setDousha(String dousha) {
this.dousha = dousha;
}
public String getShuiguo() {
return shuiguo;
}
public void setShuiguo(String shuiguo) {
this.shuiguo = shuiguo;
}
}
/**
* 蛋糕制作者
*/
public interface CakeMaker {
/*
* 加豆沙
*/
public void addDousha();
/*
* 加水果块儿
*/
public void addShuiguo();
/*
* 交付蛋糕
*/
public ChosenCake finishCake();
}
/**
* 蛋糕师傅
*/
public class CakeMaster implements CakeMaker {
//默认制作一个什么都不加的蛋糕
private ChosenCake cake = new ChosenCake();
@Override
public void addDousha() {
cake.setDousha("按您的要求加入了===豆沙===");
}
@Override
public void addShuiguo() {
cake.setShuiguo("按您的要求加入了===水果块儿===");
}
@Override
public ChosenCake finishCake(){
return cake;
}
}
/**
* 客人
*/
public class Guest {
public static void main(String[] args) {
//选一个蛋糕师傅
CakeMaker maker = new CakeMaster();
//给我加点儿豆沙
maker.addDousha();
//给我加点儿水果块
maker.addShuiguo();
//把蛋糕给我吧
ChosenCake cake = maker.finishCake();
}
}

1
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
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
/**
* 开保险箱的方法
*/
public interface OpenBox extends Cloneable{
/*
* 告诉你密码你就可以开（浅复制）
*/
public Object getPassword();
/*
* 配钥匙才可以开（深复制）
*/
public Object copyKey();
}
/**
* 会开保险箱的人
*/
public class BoxOpener implements OpenBox{
/*
* 浅复制，相当于你知道密码了，大家使用的都是同一串密码
*/
@Override
public Object getPassword() {
BoxOpener opener = null;
try {
opener = (BoxOpener)super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return opener;
}
/*
* 深复制，相当于你配了一把钥匙，用的不是一个东西
*/
@Override
public Object copyKey() {
BoxOpener opener = null;
try {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(this);
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bais);
opener = (BoxOpener) ois.readObject();
} catch (Exception e) {
e.printStackTrace();
}
return opener;
}
}
/**
* 测试流程
*/
public class Test {
public static void main(String[] args) {
//保险箱有一个管理者
OpenBox boxKeeper = new BoxOpener();
//领导要开保险箱（浅复制）
OpenBox leader = (OpenBox)boxKeeper.getPassword();
//来了一个新管理员,配把钥匙（深复制）
OpenBox newKeeper = (OpenBox)boxKeeper.copyKey();
}
}

1
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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
public class TriphaseBoard {
/*
* 有三相插口
*/
public boolean hasTriphase(){
System.out.println("==三相插板自带三相输出==");
return true;
}
}
/**
* 多功能插口
*/
public interface MultiSocket {
/*
* 有三相插口
*/
public boolean hasTriphase();
/*
* 有两相插口
*/
public boolean hasTwoPhase();
}
public class MultiPhaseBoard extends TriphaseBoard implements MultiSocket{
/*
* 有两相插口
*/
public boolean hasTwoPhase(){
System.out.println("==多功能插板实现两口的功能==");
return true;
}
}
/**
* 测试流程
*/
public class Test {
public static void main(String[] args) {
MultiSocket board = new MultiPhaseBoard();
board.hasTriphase();
board.hasTwoPhase();
}
}

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
/**
* 功能要求
*/
public interface FunctionInterface {
/*
* 能做软件
*/
public boolean canDoSoft();
/*
* 能修硬件
*/
public boolean canFixhardward();
}
/**
* 软件公司
*/
public class SoftwareCompany {
public boolean canDoSoft(){
System.out.println("软件公司专业做软件");
return true;
}
}
/**
* 硬件公司
*/
public class HardwareCompany implements FunctionInterface{
//外包一家软件公司
private SoftwareCompany softwareCompany;
public HardwareCompany(SoftwareCompany softwareCompany){
this.softwareCompany = softwareCompany;
}
/*
* 用软件公司做软件
*/
@Override
public boolean canDoSoft() {
return softwareCompany.canDoSoft();
}
/*
* 自己修硬件
*/
@Override
public boolean canFixhardward() {
System.out.println("我是硬件公司修硬件没问题");
return true;
}
}
/**
* 测试流程
*/
public class Test {
public static void main(String[] args) {
FunctionInterface function = new HardwareCompany(new SoftwareCompany());
function.canDoSoft();
function.canFixhardward();
}
}

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
/**
* 多方法接口
*/
public interface MultiMethod {
public void method1();
public void method2();
public void method3();
public void methodN();
}
/**
* 抽象类为所有接口方法提供空实现
*/
public class AbstractMultiMethod implements MultiMethod {
@Override
public void method1() {}
@Override
public void method2() {}
@Override
public void method3() {}
@Override
public void methodN() {}
}
/**
* 只用方法1的类
*/
public class UserMethod1 extends AbstractMultiMethod{
@Override
public void method1() {
System.out.println("我只用这个方法，我就重写这个方法就可以了");
}
}
/**
* 只用方法N的类
*/
public class UserMethodN extends AbstractMultiMethod{
@Override
public void methodN() {
System.out.println("我只用这个方法，我就重写这个方法就可以了");
}
}