23种设计模式学习

1
2
3
4
5
6
7
8
interface Interface1{
	void operation1();
	void operation2();
	void operation3()；
	void operation4();
	void operation5();
}

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
接口1
interface Interface1 {
	void operation1();
}
/接口2
interface Interface2 {
	void operation2();
	void operation3();
}
//接口3
interface Interface3 {
	void operation4();
	void operation5();
}

class B implements Interface1, Interface2{
	public void operation1() {
		System.out.println("B实现了operation1");
	}
	public void operation2(){
		System.out.println("B实现了operation2");
	}
	public void operation3({
		System.out.println("B实现了operation3");
	}
}
class A {//A类通过接口Interface1,Interface2依赖(使用)B类，但是只会用到1,2,3方法
	public void depend 1(Interface1 i) {
		i.operation1();
    }
	public void depend2(Interface2 i){
		i.operation2();
    }
    public void depend3(Interface2 i){
		i.operation3();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
interface IOpenAndClose {
	public void open(ITV tv); //抽象方法,接收接口
}
interface ITV {//ITV接口
	public void play();
}
class ChangHong implements ITV {
	@Override
	public void play() {
		//TODO Auto-generated method stubSystem.out.println("长虹电视机，打开");
	}
}
//实现接口
class OpenAndClose implements IOpenAndClose{
	public void open(ITV tv){
		tv.play();
	}
}    

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
interface IOpenAndClose {
	public void open();//抽象方法
}
interface ITV {//ITV接口
	public void play();
}
class OpenAndClose implements IOpenAndClose{
    public ITV tv;//成员
	public OpenAndClose(ITV tv){//构造器
        this.tv = tv;
    }
	public void open(){
        this.tv.play();
    }
}
class ChangHong implements ITV {
	@Override
	public void play() {
        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
23
24
25
26
27
28
interface IOpenAndClose {
	public void open();//抽象方法
	public void setTv(ITV tv);
}
interface ITV {//ITV接口
	public void play();
}
class OpenAndClose implements IOpenAndClose{
	private ITV tv;
	public void setTv(ITV tv){
		this.tv = tv;
    }
	public void open() {
		this.tv.play();
    }
class ChangHong implements ITV{
	@Override
	public void play() {
		//TODO Auto-generated method stub
        System.out. println("长虹电视机，打开");}
	}
}

ITV changHong=new ChangHong();
openAndclose openAndClose = new openAndClose();
openAndclose.setTv(changHong);
openAndClose.open();

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
public class Ocp {
    public static void main(String[] args) {
        //使用看看存在的问题
        GraphicEditor graphicEditor = new GraphicEditor();
        graphicEditor.drawShape(new Rectangle());
        graphicEditor.drawShape(new Circle());
        graphicEditor.drawShape(new Triangle());
    }
}

//这是一个用于绘图的类[使用方]
class GraphicEditor {
    //接收Shape对象，然后根据type，来绘制不同的图形
    public void drawShape(Shape s) {
        if (s.m_type == 1) {
            drawRectangle(s);
        } else if (s.m_type == 2) {
            drawCircle(s);
        } else if (s.m_type == 3) {
            drawTriangle(s);
        }
    }

    //绘制矩形
    public void drawRectangle(Shape r) {
        System.out.println("绘制矩形");
    }

    //绘制圆形
    public void drawCircle(Shape r) {
        System.out.println("绘制圆形");
    }

    //绘制三角形
    public void drawTriangle(Shape r) {
        System.out.println("绘制三角形");
    }
}

//Shape类，基类
class Shape {
    int m_type;
}

class Rectangle extends Shape {
    Rectangle() {
        super.m_type = 1;
    }
}

class Circle extends Shape {
    Circle() {
        super.m_type = 2;
    }
}

//新增画三角形
class Triangle extends Shape {
    Triangle() {
        super.m_type = 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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
public class Ocp {
    public static void main(String[] args) {
        //使用看看存在的问题
        GraphicEditor graphicEditor = new GraphicEditor();
        graphicEditor.drawShape(new Rectangle());
        graphicEditor.drawShape(new Circle());
        graphicEditor.drawShape(new Triangle());
    }
}

//这是一个用于绘图的类「使用方]
class GraphicEditor {
    //接收Shape对象，然后根据type，来绘制不同的图形
    public void drawShape(Shape s) {
        s.draw();
    }
}

//Shape类，基类
abstract class Shape {
    public abstract void draw();//抽象方法
}

class Rectangle extends Shape {
    @Override
    public void draw() {
        System.out.println("绘制矩形");
    }
}

class Circle extends Shape {
    @Override
    public void draw() {
        System.out.println("绘制圆形");
    }
}

//新增画三角形
class Triangle extends Shape {
    @Override
    public void draw() {
        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
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
import java.util.ArrayList;
import java.util.List;

public class Demeter {
    public static void main(String[] args) {
//创建了一个SchoolManager对象
        SchoolManager schoolManager = new SchoolManager();//输出学院的员工id和―学校总部的员工信息
        schoolManager.printAllEmployee(new CollegeManager());
    }

}

//学校总部员工类
class Employee {
    private String id;

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

    public String getId() {
        return id;
    }
}

//学院的员工类
class CollegeEmployee {
    private String id;

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

    public String getId() {
        return id;
    }
}

//管理学院员工的管理类
class CollegeManager {
    //返回学院的所有员工
    public List<CollegeEmployee> getAllEmployee() {
        List<CollegeEmployee> list = new ArrayList<CollegeEmployee>();
        for (int i = 0; i < 10; i++) {//这里我们增加了10个员工到list
            CollegeEmployee emp = new CollegeEmployee();
            emp.setId("学院员工id=" + i);
            list.add(emp);
        }
        return list;
    }

}

//学校管理类
//分析SchoolManager类的直接朋友类有哪些Employee、CollegeManagerl/CollegeEmployee不是直接朋友而是一个陌生类，这样违背了迪米特法则
class SchoolManager {
    //返回学校总部的员工
    public List<Employee> getAllEmployee() {
        List<Employee> list = new ArrayList<Employee>();
        for (int i = 0; i < 5; i++) {
            //这里我们增加了5个员工到list
            Employee emp = new Employee();
            emp.setId("学校总部员工id=" + i);
            list.add(emp);
        }
        return list;
    }

    //该方法完成输出学校总部和学院员工信息(id)
    void printAllEmployee(CollegeManager sub) {
        // 分析问题
        //1．这里的 CollegeEmployee不是SchoolManager 的直接朋友l/2.CollegeEmployee是以局部变量方式出现在SchoolManager
        //违反了迪米特法则
        // 获取到学院员工
        List<CollegeEmployee> list1 = sub.getAllEmployee();
        System.out.println(" ------------学院员工------");
        for (CollegeEmployee e : list1) {
            System.out.println(e.getId());
        }
        //获取到学校总部员工
        List<Employee> list2 = this.getAllEmployee();
        System.out.println("-- - 学校总部员工-- - ");
        for (Employee e : list2) {
            System.out.println(e.getId());
        }
    }
}

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
import java.util.ArrayList;
import java.util.List;

public class Demeter {
    public static void main(String[] args) {
//创建了一个SchoolManager对象
        SchoolManager schoolManager = new SchoolManager();//输出学院的员工id和―学校总部的员工信息
        schoolManager.printAllEmployee(new CollegeManager());
    }

}

//学校总部员工类
class Employee {
    private String id;

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

    public String getId() {
        return id;
    }
}

//学院的员工类
class CollegeEmployee {
    private String id;

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

    public String getId() {
        return id;
    }

}

//管理学院员工的管理类
class CollegeManager {
    //返回学院的所有员工
    public List<CollegeEmployee> getAllEmployee() {
        List<CollegeEmployee> list = new ArrayList<CollegeEmployee>();
        for (int i = 0; i < 10; i++) {//这里我们增加了10个员工到list
            CollegeEmployee emp = new CollegeEmployee();
            emp.setId("学院员工id=" + i);
            list.add(emp);
        }
        return list;
    }

    //输出学院员工的信息
    public void printEmployee() {
        //获取到学院员工
        List<CollegeEmployee> list1 = getAllEmployee();
        System.out.println("------------学院员工--------- ");
        for (CollegeEmployee e : list1) {
            System.out.println(e.getId());
        }
    }
}
    //学校管理类
//分析SchoolManager类的直接朋友类有哪些Employee、CollegeManagerl/CollegeEmployee不是直接朋友而是一个陌生类，这样违背了迪米特法则
    class SchoolManager {
        //返回学校总部的员工
        public List<Employee> getAllEmployee() {
            List<Employee> list = new ArrayList<Employee>();
            for (int i = 0; i < 5; i++) {
                //这里我们增加了5个员工到list
                Employee emp = new Employee();
                emp.setId("学校总部员工id=" + i);
                list.add(emp);
            }
            return list;
        }

        //该方法完成输出学校总部和学院员工信息(id)
        void printAllEmployee(CollegeManager sub) {
            //分析问题
            //1.将输出学院的员工方法，封装到CollegeManager
            sub.printEmployee();
            //获取到学校总部员工
            List<Employee> list2 = this.getAllEmployee();
            System.out.println("-- - 学校总部员工-- - ");
            for (Employee e : list2) {
                System.out.println(e.getId());
            }
        }
    }

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
package com.fuhong.designpattern.singleton;

public class SingletonTest01 {
    public static void main(String[] args) {
        //测试
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance==instance2); // true
        System.out.println(" instance.hashCode=" + instance.hashCode());
        System.out.println(" instance2.hashCode=" + instance2.hashCode());
    }
    //饿汉式(静态变量)
    static class Singleton {
        //1.构造器私有化，外部能new
        private Singleton() {
        }
        //2.本类内部创建对象实例
        private final static Singleton instance = new Singleton();
        //3．提供一个公有的静态方法，返回实例对象
        public static Singleton getInstance() {
            return instance;
        }
    }
}

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
package com.fuhong.designpattern.singleton;

public class SingletonTest02 {
    public static void main(String[] args) {
//测试
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2);//true
        System.out.println("instance.hashCode=" + instance.hashCode());
        System.out.println("instance2.hashCode=" + instance2.hashCode());
    }
}

//饿汉式(静态变量)
class Singleton {
    //1.构造器私有化，外部能new
    private Singleton() {

    }

    private final static Singleton instance;

    static {//在静态代码块中，创建单例对象
        instance = new Singleton();
    }

    //3.提供一个公有的静态方法，返回实例对象
    public static Singleton getInstance() {
        return instance;
    }
}

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
package com.fuhong.designpattern.singleton;

public class SingletonTest03 {
    public static void main(String[] args) {
        //测试
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2); // true
        System.out.println(" instance.hashCode=" + instance.hashCode());
        System.out.println(" instance2.hashCode=" + instance2.hashCode());
    }

    static class Singleton {
        private static Singleton instance;

        private Singleton() {
        }

        //提供一个静态的公有方法，当使用到该方法时，才去创建instance
        // 即懒汉式
        public static Singleton getInstance() {
            if (instance == null) {
                instance = new Singleton();
            }
            return instance;
        }
    }
}

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
package com.fuhong.designpattern.singleton;

public class SingletonTest04 {
    public static void main(String[] args) {
        //测试
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2); // true
        System.out.println(" instance.hashCode=" + instance.hashCode());
        System.out.println(" instance2.hashCode=" + instance2.hashCode());
    }

    //懒汉式(线程安全，同步方法)
    static class Singleton {
        private static Singleton instance;

        private Singleton() {
        }

        //提供一个静态的公有方法，加入同步处理的代码，解决线程安全问题//即懒汉式
        public static synchronized Singleton getInstance() {
            if (instance == null) {
                instance = new Singleton();
            }
            return instance;
        }
    }
}

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
package com.fuhong.designpattern.singleton;

public class SingletonTest05 {
    public static void main(String[] args) {
        //测试
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2); // true
        System.out.println(" instance.hashCode=" + instance.hashCode());
        System.out.println(" instance2.hashCode=" + instance2.hashCode());
    }

    //懒汉式(线程不安全，同步方法)
    static class Singleton {
        private static Singleton instance;

        private Singleton() {
        }

        //提供一个静态的公有方法，加入同步处理的代码，解决线程安全问题//即懒汉式
        public static Singleton getInstance() {
            if (instance == null) {
                synchronized ("1") {
                    instance = new Singleton();
                }
            }
            return instance;
        }
    }
}

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
package com.fuhong.designpattern.singleton;

public class SingletonTest06 {
    public static void main(String[] args) {
        //测试
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2); // true
        System.out.println(" instance.hashCode=" + instance.hashCode());
        System.out.println(" instance2.hashCode=" + instance2.hashCode());
    }

    //懒汉式(线程安全，同步方法)
    static class Singleton {
        private static volatile Singleton instance;
        private Singleton() {
        }
        //提供一个静态的公有方法，加入双重检查代码，解决线程安全问题,同时解决懒加载问题/同时保证了效率,推荐使用
        public static synchronized Singleton getInstance() {
            if (instance == null) {
                synchronized (Singleton.class) {
                    if (instance == null) {
                        instance = new Singleton();
                    }
                }
            }
            return instance;
        }
    }
}

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
package com.fuhong.designpattern.singleton;

public class SingletonTest07 {
    public static void main(String[] args) {
        //测试
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2); // true
        System.out.println(" instance.hashCode=" + instance.hashCode());
        System.out.println(" instance2.hashCode=" + instance2.hashCode());
    }

    //静态内部类完成，推荐使用
    static class Singleton {

        //构造器私有化
        private Singleton() {
        }
		//在外面的类被装载时，静态内部类不会被装载，getInstance()时静态内部类被装载，且只会被装载一次 线程安全
        //写一个静态内部类,该类中有一个静态属性Singleton
        private static class SingletonInstance {
            private static final Singleton INSTANCE = new Singleton();
        }

        //提供一个静态的公有方法，直接返回SingletonInstance.INSTANCE
        public static  Singleton getInstance() {
            return SingletonInstance.INSTANCE;
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package com.fuhong.designpattern.singleton;

public class SingletonTest08 {
    public static void main(String[] args) {
        Singleton instance = Singleton.INSTANCE;
        Singleton instance2 = Singleton.INSTANCE;
        System.out.println(instance == instance2);
        System.out.println(instance.hashCode());
        System.out.println(instance2.hashCode());
        instance.sayOK();
    }

    //使用枚举，可以实现单例，推荐
    enum Singleton {
        INSTANCE;//属性

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//披萨的抽象类，供所有的披萨继承
public abstract class Pizza {
    public abstract void prepare();

    public void bake() {
        System.out.println("烤焙");
    }

    public void cut() {
        System.out.println("切片");
    }

    public void box() {
        System.out.println("装盒");
    }
}

1
2
3
4
5
6
7
8
9
10
/**
 * 具体的披萨01
 */
public class ChessPizza extends Pizza{
    @Override
    public void prepare() {
        System.out.println("ChessPizza准备");
    }
}

1
2
3
4
5
6
7
8
9
10
/**
 * 具体的披萨02
 */
public class GreekPizza extends Pizza{
    @Override
    public void prepare() {
        System.out.println("GreekPizza准备");
    }
}

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
/**
 * 披萨订购
 */
public class OrderPizza {
    public OrderPizza() {
        Pizza pizza = null;
        String orderType; //订购披萨的类型
        do {
            orderType = "getType()";//这里应该是订购输入类型
            if (orderType.equals("greek")) {
                pizza = new GreekPizza();
            } else if (orderType.equals("cheese")) {
                pizza = new ChessPizza();
            } else {
                break;
            }
            //输出pizza 制作过程
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
        } while (true);
    }
}

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 class OrderPizza {
    //定义一个简单工厂对象
    SimpleFactory simpleFactory;
    Pizza pizza = null;

    //构造器
    public OrderPizza(SimpleFactory simpleFactory) {
        setFactory(simpleFactory);
    }

    public void setFactory(SimpleFactory simpleFactory) {
        String orderType = "xxx";//用户输入的
        this.simpleFactory = simpleFactory;//设置简单工厂对象
        do {
            pizza = this.simpleFactory.createPizza(orderType);
            //输出pizza
            if (pizza != null) {//订购成功
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            } else {
                System.out.println("订购披萨失败");
                break;
            }
        } while (true);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//简单工厂类
public class SimpleFactory {
    //更加orderType返回对应的Pizza 对象
    public Pizza createPizza(String orderType) {
        Pizza pizza = null;
        System.out.println("使用简单工厂模式");
        if (orderType.equals("greek")) {
            pizza = new GreekPizza();
        } else if (orderType.equals("chess")) {
            pizza = new ChessPizza();
        }
        return pizza;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public abstract class Pizza {
    public abstract void prepare();

    public void bake() {
        System.out.println("拷贝");
    }

    public void cut() {
        System.out.println("切片");
    }

    public void box() {
        System.out.println("装盒");
    }
}

1
2
3
4
5
6
7
8
9
import com.fuhong.designpattern.factory.simpleFactory.old.Pizza;

public class BJPepperPizza extends Pizza {
    @Override
    public void prepare() {
        System.out.println("BJPepperPizza 准备");
    }
}

1
2
3
4
5
6
7
8
9
import com.fuhong.designpattern.factory.simpleFactory.old.Pizza;

public class BJCheesePizza extends Pizza {
    @Override
    public void prepare() {
        System.out.println("BJCheesePizza 准备");
    }
}

1
2
3
4
5
6
7
8
9
import com.fuhong.designpattern.factory.simpleFactory.old.Pizza;

public class LDCheesePizza extends Pizza {
    @Override
    public void prepare() {
        System.out.println("LDCheesePizza 准备");
    }
}

1
2
3
4
5
6
7
8
9
import com.fuhong.designpattern.factory.simpleFactory.old.Pizza;

public class LDPepperPizza extends Pizza {
    @Override
    public void prepare() {
        System.out.println("LDPepperPizza 准备");
    }
}

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
import com.fuhong.designpattern.factory.simpleFactory.old.Pizza;

/**
 * 披萨订购类
 */
public abstract class OrderPizzaMethodFactory {
    //定义一个抽象方法，createPizza，让各个工厂子类自己实现
    abstract Pizza createPizza(String orderType);

    public OrderPizzaMethodFactory() {
        Pizza pizza=null;
        do {
            //orderType依靠用户传入 getType方法用户传入
            pizza = createPizza("");//抽象方法，由工厂子类完成
            //输出pizza
            if (pizza != null) {//订购成功
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            } else {
                System.out.println("订购披萨失败");
                break;
            }
        } while (true);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import com.fuhong.designpattern.factory.simpleFactory.old.Pizza;

public class BJOrderPizza extends OrderPizzaMethodFactory {
    @Override
    Pizza createPizza(String orderType) {
        Pizza pizza = null;
        if (orderType.equals("cheese")) {
            pizza = new BJCheesePizza();
        } else if (orderType.equals("pepper")) {
            pizza = new BJPepperPizza();
        }
        return pizza;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import com.fuhong.designpattern.factory.simpleFactory.old.Pizza;

public class LDOrderPizza extends OrderPizzaMethodFactory {
    @Override
    Pizza createPizza(String orderType) {
        Pizza pizza = null;
        if (orderType.equals("cheese")) {
            pizza = new LDCheesePizza();
        } else if (orderType.equals("pepper")) {
            pizza = new LDPepperPizza();
        }
        //TODO Auto-generated method stub
        return pizza;
    }
}

1
2
3
4
5
6
7
8
import com.fuhong.designpattern.factory.simpleFactory.old.Pizza;

//一个抽象工厂模式的抽象层(接口)
public interface AbsFactory {
    //让下面的工厂子类来具体实现
    public Pizza createPizza(String orderType);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import com.fuhong.designpattern.factory.simpleFactory.methodFactory.BJCheesePizza;
import com.fuhong.designpattern.factory.simpleFactory.methodFactory.BJPepperPizza;
import com.fuhong.designpattern.factory.simpleFactory.old.Pizza;

//这是工厂子类
public class BJFactory implements AbsFactory {
    @Override
    public Pizza createPizza(String orderType) {
        System.out.println("~使用的是抽象工厂模式~");
        Pizza pizza = null;
        if ("cheese".equals(orderType)) {
            pizza = new BJCheesePizza();
        } else if ("pepper".equals(orderType)) {
            pizza = new BJPepperPizza();
        }
        return pizza;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import com.fuhong.designpattern.factory.simpleFactory.methodFactory.LDCheesePizza;
import com.fuhong.designpattern.factory.simpleFactory.methodFactory.LDPepperPizza;
import com.fuhong.designpattern.factory.simpleFactory.old.Pizza;

//这是工厂子类
public class LDFactory implements AbsFactory {
    @Override
    public Pizza createPizza(String orderType) {
        System.out.println("~使用的是抽象工厂模式~");
        Pizza pizza = null;
        if ("cheese".equals(orderType)) {
            pizza = new LDCheesePizza();
        } else if ("pepper".equals(orderType)) {
            pizza = new LDPepperPizza();
        }
        return pizza;
    }
}

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
import com.fuhong.designpattern.factory.simpleFactory.old.Pizza;

public class OrderPizza {
    AbsFactory factory;

    //构造器
    public OrderPizza(AbsFactory factory) {
        setFactory(factory);
    }

    private void setFactory(AbsFactory factory) {
        Pizza pizza = null;
        //用户输入
        String orderType = "";
        // 用户输入
        this.factory = factory;
        do {
            //factory可能是北京的工厂子类，也可能是伦敦的工厂子类
            pizza = factory.createPizza(orderType);
            if (pizza != null) {
                // 订购ok
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            } else {
                System.out.println("订购失败");
                break;
            }
        } while (true);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Client {
    public static void main(String[] args) {
        Sheep sheep = new Sheep(1, "yang1", "red");
        Sheep sheep1 = new Sheep(sheep.getAge(), sheep.getName(), sheep.getColor());
        Sheep sheep2 = new Sheep(sheep.getAge(), sheep.getName(), sheep.getColor());
        Sheep sheep3 = new Sheep(sheep.getAge(), sheep.getName(), sheep.getColor());
        Sheep sheep4 = new Sheep(sheep.getAge(), sheep.getName(), sheep.getColor());
        //.....
        System.out.println(sheep);
        //.....
    }
}

1
2
3
4
5
6
7
8
9
10
import com.fuhong.designpattern.prototype.old.Sheep;

public class newClient {
    public static void main(String[] args) {
        Sheep sheep = new Sheep(1, "yang1", "red");
        Sheep sheep1 = (Sheep)sheep.clone();
        System.out.println(sheep1);
    }
}

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
public class Sheep implements Cloneable {
    private int age;
    private String name;
    private String color;

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public Sheep(int age, String name, String color) {
        this.age = age;
        this.name = name;
        this.color = color;
    }

    @Override
    public String toString() {
        return "Sheep{" +
                "age=" + age +
                ", name='" + name + ''' +
                ", color='" + color + ''' +
                '}';
    }

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

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
import java.io.*;

public class DeepProtoType implements Serializable, Cloneable {
    public String name;//String 属性
    public DeepProtoType deepCloneableTarget;// 引用类型

    public DeepProtoType() {
        super();
    }

    //深拷贝–方式1使用clone方法
    @Override
    protected Object clone() {
        Object deep = null;
        DeepProtoType deepProtoType = null;
        //这里完成对基本数据类型(属性)和 String 的克隆
        try {
            deep = super.clone();
            //对引用类型的属性，进行单独处理
            deepProtoType = (DeepProtoType) deep;
            deepProtoType.deepCloneableTarget = (DeepProtoType) deepCloneableTarget.clone();

        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return deepProtoType;
    }

    //深拷贝–方式2通过对象的序列化实现(推荐)
    public Object deepClone() {
        //创建流对象
        ByteArrayOutputStream bos = null;
        ObjectOutputStream oos = null;
        ByteArrayInputStream bis = null;
        ObjectInputStream ois = null;
        try {
            //序列化
            bos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(bos);
            oos.writeObject(this);//当前这个对象以对象流的方式输出
            //反序列化
            bis = new ByteArrayInputStream(bos.toByteArray());
            ois = new ObjectInputStream(bis);
            return (DeepProtoType) ois.readObject();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
            return null;
        } finally {
            //关闭流
            try {
                assert bos != null;
                bos.close();
                assert oos != null;
                oos.close();
                assert bis != null;
                bis.close();
                assert ois != null;
                ois.close();
            } catch (Exception e2) {
                System.out.println(e2.getMessage());
            }
        }
    }
}

1
2
3
4
5
6
7
public class Client {
    public static void main(String[] args) {
        CommonHouse commonHouse = new CommonHouse();
        commonHouse.build();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public abstract class AbstractHouse {
    //打地基
    public abstract void buildBasic();

    //砌墙
    public abstract void buildWalls();

    //封顶
    public abstract void roofed();

    public void build() {
        buildBasic();
        buildWalls();
        roofed();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class CommonHouse extends AbstractHouse {
    @Override
    public void buildBasic() {
        System.out.println("普通房子打地基");
    }

    @Override
    public void buildWalls() {
        System.out.println("普通房子砌墙");
    }

    @Override
    public void roofed() {
        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
23
24
25
26
27
28
29
30
31
//产品->Product
public class House {
    private String baise;
    private String wall;
    private String roofed;

    public String getBaise() {
        return baise;
    }

    public void setBaise(String baise) {
        this.baise = baise;
    }

    public String getWall() {
        return wall;
    }

    public void setWall(String wall) {
        this.wall = wall;
    }

    public String getRoofed() {
        return roofed;
    }

    public void setRoofed(String roofed) {
        this.roofed = roofed;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//抽象的建造者
public abstract class HouseBuilder {
    protected House house = new House();

    //将建造的流程写好，抽象的方法
    public abstract void buildBasic();

    public abstract void buildWalls();

    public abstract void roofed();

    //建造房子好，将产品(房子)返回
    public House buildHouse() {
        return house;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class CommonHouse extends HouseBuilder {
    @Override
    public void buildBasic() {
        house.setBaise("普通房子打地基5米");
        System.out.println("普通房子打地基5米");
    }

    @Override
    public void buildWalls() {
        System.out.println("普通房子砌墙10cm ");
    }

    @Override
    public void roofed() {
        System.out.println("普通房子屋顶 ");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class HighHouse extends HouseBuilder {   
	@Override
    public void buildBasic() {
        System.out.println("高楼的打地基100米");
    }

    @Override
    public void buildWalls() {
        System.out.println("高楼的砌墙20cm ");
    }

    @Override
    public void roofed() {
        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 HouseDirector {
    HouseBuilder houseBuilder = null;

    //构造器传入houseBuilder
    public HouseDirector(HouseBuilder houseBuilder) {
        this.houseBuilder = houseBuilder;
    }

    //通过setter传入 houseBuilder
    public void setHouseBuilder(HouseBuilder houseBuilder) {
        this.houseBuilder = houseBuilder;
    }

    //如何处理建造房子的流程，交给指挥者
    public House constructHouse() {
        houseBuilder.buildBasic();
        houseBuilder.buildWalls ();
        houseBuilder.roofed();
        return houseBuilder.buildHouse();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Client {
    public static void main(String[] args) {
        //盖普通房子
        CommonHouse commonHouse = new CommonHouse();//准备创建房子的指挥者
        HouseDirector houseDirector = new HouseDirector(commonHouse);
        //完成盖房子，返回产品(普通房子)
        House house = houseDirector.constructHouse();
        // System.out.println("输出流程");
        System.out.println("-盖高楼 - ");
        HighBuilding highBuilding = new HighBuilding();//重置建造者
        houseDirector.setHouseBuilder(highBuilding);//完成盖房子，返回产品(高楼)
        houseDirector.constructHouse();
    }
}

1
2
3
4
5
6
7
8
public class Client {
    public static void main(String[] args) {
        System.out.println(" =—-类适配器模式=——=");
        Phone phone = new Phone();
        phone.charging(new VoltageAdapter());
    }
}

1
2
3
4
5
6
7
8
9
10
11
public class Phone {
    //充电
    public void charging(IVoltage5V iVoltage5V) {
        if (iVoltage5V.output5V() == 5) {
            System.out.println("电压为5V，可以充电~~");
        } else if (iVoltage5V.output5V() > 5) {
            System.out.println("电压大于5V，不能充电~~");
        }
    }
}

1
2
3
4
5
//适配接口
public interface IVoltage5V {
    public int output5V();
}

1
2
3
4
5
6
7
8
9
10
//被适配的类
public class Voltage220V {
    //输出220V的电压
    public int output220V() {
        int src = 220;
        System.out.println("电压=" + src + "伏");
        return src;
    }
}

1
2
3
4
5
6
7
8
9
10
public class VoltageAdapter extends Voltage220V implements IVoltage5V {
    @Override
    public int output5V() {
        //获取到220V电压
        int srcV = output220V();
        int dstV = srcV / 44;//转成5v
        return dstV;
    }
}

1
2
3
4
5
6
7
8
public class Client {
    public static void main(String[] args) {
        System.out.println(" =—-对象适配器模式=——=");
        Phone phone = new Phone();
        phone.charging(new VoltageAdapter(new Voltage220V()));
    }
}

1
2
3
4
5
6
7
8
9
10
11
public class Phone {
    //充电
    public void charging(IVoltage5V iVoltage5V) {
        if (iVoltage5V.output5V() == 5) {
            System.out.println("电压为5V，可以充电~~");
        } else if (iVoltage5V.output5V() > 5) {
            System.out.println("电压大于5V，不能充电~~");
        }
    }
}

1
2
3
4
5
6
7
8
9
10
//被适配的类
public class Voltage220V {
    //输出220V的电压
    public int output220V() {
        int src = 220;
        System.out.println("电压=" + src + "伏");
        return src;
    }
}

1
2
3
4
5
//适配接口
public interface IVoltage5V {
    public int output5V();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class VoltageAdapter implements IVoltage5V {
    private final Voltage220V voltage220V;

    //通过构造传入
    public VoltageAdapter(Voltage220V voltage220V) {
        this.voltage220V = voltage220V;
    }

    @Override
    public int output5V() {
        int dst = 0;
        if (null != voltage220V) {
            int src = voltage220V.output220V();//获取220V电压
            System.out.println("使用对象适配器，进行适配~~");
            dst = src / 44;
            System.out.println("适配完成，输出的电压为=" + dst);
        }
        return dst;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
public class Client {
    public static void main(String[] args) {
        AbsAdapter absAdapter = new AbsAdapter() {
            //只需要去覆盖我们需要使用接口方法aOverride
            public void m1() {
                System.out.println("使用了m1的方法");
            }
        };
        absAdapter.m1();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//在AbsAdapter我们将Interface4 的方法进行默认实现
public abstract class AbsAdapter implements Interface4 {
    //默认实现
    public void m1() {
    }

    public void m2() {
    }

    public void m3() {
    }

    public void m4() {
    }
}

1
2
3
4
5
6
7
8
9
10
public interface Interface4 {
    public void m1();

    public void m2();

    public void m3();

    public void m4();
}

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
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
   HttpServletRequest processedRequest = request;
   HandlerExecutionChain mappedHandler = null;
   boolean multipartRequestParsed = false;

   WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

   try {
      ModelAndView mv = null;
      Exception dispatchException = null;

      try {
         processedRequest = checkMultipart(request); //1 将request交给processedRequest
         multipartRequestParsed = (processedRequest != request);

         // Determine handler for the current request.
         mappedHandler = getHandler(processedRequest); //2.通过processedRequest拿到mappedHandler
         if (mappedHandler == null) {
            noHandlerFound(processedRequest, response);
            return;
         }

         // Determine handler adapter for the current request.
         HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());//3.通过mappedHandler，遍历所有的Adapter得到具体controller对应的HandlerAdapter

         // Process last-modified header, if supported by the handler.
         String method = request.getMethod();
         boolean isGet = HttpMethod.GET.matches(method);
         if (isGet || HttpMethod.HEAD.matches(method)) {
            long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
            if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
               return;
            }
         }

         if (!mappedHandler.applyPreHandle(processedRequest, response)) {
            return;
         }

         // Actually invoke the handler.
         mv = ha.handle(processedRequest, response, mappedHandler.getHandler());//4.通过适配器调用具体controller的handle方法

         if (asyncManager.isConcurrentHandlingStarted()) {
            return;
         }

         applyDefaultViewName(processedRequest, mv);
         mappedHandler.applyPostHandle(processedRequest, response, mv);
      }
      catch (Exception ex) {
         dispatchException = ex;
      }
      catch (Throwable err) {
         // As of 4.3, we're processing Errors thrown from handler methods as well,
         // making them available for @ExceptionHandler methods and other scenarios.
         dispatchException = new NestedServletException("Handler dispatch failed", err);
      }
      processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
   }
   catch (Exception ex) {
      triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
   }
   catch (Throwable err) {
      triggerAfterCompletion(processedRequest, response, mappedHandler,
            new NestedServletException("Handler processing failed", err));
   }
   finally {
      if (asyncManager.isConcurrentHandlingStarted()) {
         // Instead of postHandle and afterCompletion
         if (mappedHandler != null) {
            mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
         }
      }
      else {
         // Clean up any resources used by a multipart request.
         if (multipartRequestParsed) {
            cleanupMultipart(processedRequest);
         }
      }
   }
}

1
2
3
4
5
6
7
8
9
10
11
12
protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
   if (this.handlerAdapters != null) {
      for (HandlerAdapter adapter : this.handlerAdapters) {//1.遍历所有handlerAdapters，得到具体controller对应的HandlerAdapter
         if (adapter.supports(handler)) {//2.HandlerAdapter接口的supports体现接口适配器模式，具体的适配器去实现
            return adapter;
         }
      }
   }
   throw new ServletException("No adapter for handler [" + handler +
         "]: The DispatcherServlet configuration needs to include a HandlerAdapter that supports this handler");
}

1
2
boolean supports(Object handler);

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
public class Client {
    public static void main(String[] args) {
//获取折叠式手机（样式＋品牌)
        Phone phone1 = new FoldedPhone(new XiaoMi());
        phone1.open();
        phone1.call();
        phone1.close();
        System.out.println("++++++++++++++++++++++++");
        Phone phone2 = new FoldedPhone(new Vivo());
        phone2.open();
        phone2.call();
        phone2.close();
        System.out.println("++++++++++++++++++++++++++++++");
        UpRightPhone phone3 = new UpRightPhone(new XiaoMi());
        phone3.open();
        phone3.call();
        phone3.close();
        System.out.println("++++++++++++++++++++++++++");
        UpRightPhone phone4 = new UpRightPhone(new Vivo());
        phone4.open();
        phone4.call();
        phone4.close();
    }
}

1
2
3
4
5
6
7
8
9
//接口
public interface Brand {
    void open();

    void close();

    void call();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public abstract class Phone {
    //组合品牌
    private Brand brand;

    //构造器
    public Phone(Brand brand) {
        super();
        this.brand = brand;
    }

    protected void open() {
        this.brand.open(); //组合品牌的open
    }

    protected void close() {
        brand.close();
    }

    protected void call() {
        brand.call();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//折叠手机
public class FoldedPhone extends Phone {
    //构造器
    public FoldedPhone(Brand brand) {
        super(brand);//调用抽象父类的构造
    }

    public void open() {
        super.open();//调用抽象父类的open
        System.out.println("折叠样式手机");
    }

    public void close() {
        super.close();
        System.out.println("折叠样式手机");
    }

    public void call() {
        super.call();
        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 UpRightPhone extends Phone {
    //构造器
    public UpRightPhone(Brand brand) {
        super(brand);
    }

    public void open() {
        super.open();
        System.out.println("直立样式手机");
    }

    public void close() {
        super.close();
        System.out.println("直立样式手机 ");
    }

    public void call() {
        super.call();
        System.out.println("直立样式手机 ");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class Vivo implements Brand {
    @Override
    public void open() {
        System.out.println(" Vivo手机开机 ");
    }

    @Override
    public void close() {
        System.out.println(" Vivo手机关机");
    }

    @Override
    public void call() {
        System.out.println(" Vivo手机打电话");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class XiaoMi implements Brand {
    @Override
    public void open() {
        System.out.println("小米手机开机 ");
    }

    @Override
    public void close() {
        System.out.println("小米手机关机 ");
    }

    @Override
    public void call() {
        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
23
24
25
26
27
public class CoffeeBar {
    public static void main(String[] args) {

//装饰者模式下的订单:2份巧克力+一份牛奶的LongBlack
//1、点一份LongBlack
        Drink order = new LongBlack();
        System.out.println("费用1=" + order.cost());
        System.out.println("描述=" + order.getDes());
// 2.order 加入一份牛奶
        order = new Milk(order);
        System.out.println(" order加入一份牛奶费用=" + order.cost());
        System.out.println(" order 加入一份牛奶描述=" + order.getDes());
// 3. order加入一份巧克力
        order = new Chocolate(order);
        System.out.println(" order 加入一份牛奶加入一份巧克力费用=" + order.cost());
        System.out.println(" order加入一份牛奶加入一份巧克力描述=" + order.getDes());

        System.out.println(" ++++++++++++++++++++++++");
        Drink order2 = new DeCaf();
        System.out.println(" order2无因咖啡―费用=" + order2.cost());
        System.out.println(" order2无因咖啡描述=" + order2.getDes());
        order2 = new Milk(order2);
        System.out.println(" order2无因咖啡加入一份牛奶费用=" + order2.cost());
        System.out.println(" order2无因咖啡加入一份牛奶描述=" + order2.getDes());
    }
}

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 Drink {
    public String des; //描述
    private float price = 0.0f;

    public String getDes() {
        return des;
    }

    public void setDes(String des) {
        this.des = des;
    }

    public float getPrice() {
        return price;
    }

    public void setPrice(float price) {
        this.price = price;
    }

    //计算费用的抽象方法子类来实现
    public abstract float cost();
}