1-001设计模式面试题(1)视频出处:https://www.bilibili.com/video/BV1G4411c7N4?from=search&seid=10283063300932661959&spm_id_from=333.337.0.0
原型设计模式问题
-
原型设计模式的拷贝和浅拷贝是什么,并写出深拷贝的两种方式的源码重写
- 重写clone方法来实现深拷贝
- 使用序列化来实现深拷贝
-
在 Spring框架中哪里使用到原型模武,并对源码进行分析
-
例如
-
Spring中原型bean的到建,就是原型模式的应用
-
-
设计模式中的7大原则:
- 单一职责原则
- 接口隔离原则
- 依赖倒转原则
- 里氏替换原则
- 开闭原则 (ocp原则 工厂模式就用到了)
- 迪米特法则
- 合成复用原则
**金融借贷平台项目:**借贷平台的订单,有审核发布抢单等等步骤,随着操作的不同,尝改变订单的状态,项自中的这个模块买现就会使用到状态模式,请你使用状态模式进行设计,并完成实际代码.
回题分析:
这类代码难以应对变化,在添加一种状态时我们需要手动幂加 if/else,在添加一种功能时,要对所有的状态进行判断。因此代码会支得越来睡肿,并且一旦没有外理某个状态,便会发生极其严重的BUG,难以维护
状态的转变
单例设计模式一共有几种实现方式?请分别用代码实现,并说明各个实现方式的优点和缺点?
单例设计模式一共有8种写法,后面我们会依次讲到
- 1)饿汉式两种
- 2)懒汉式三种
- 3)双重樟查 (多线程问题)
- 4)静态内部类 (可以解决多线程问题,和懒加载问题)
5)枚举
3-003何时会用到设计模式软件工程中,设计模式( design pattern)是对软件设计中普遍在在(反复出现)的各种题,所提出的解决方案。
这个术语是由埃里希伽玛( Erich gamma)等人在1990年代从建筑设计领域引入到计算机科学的
- 拿实际工作经历来说,当一个项目开发完后,如果客户提出增新功能,怎么办?
- 如果项目开发完后,原来程序员离职,你接手维护该项目怎么办?
- 前程序员门槛越来越高,一线公司(大厂),都会问你在实际项目中使用过什么设计模式,怎样使用的,解决了什么问题?
- 设计模式在软件中哪里?
课程亮点和授课方式
- 1)课程深入蜻蜓点水
- 2)课程成体紫,非星星点灯
- 3)高效而愉快的学习,设计模式很有用,其实也很好玩,很像小时候搭
- 积木,怎样搭建更加稳定,坚固
- 4)设计模式很重要,因为包含很多编程思想,还是有一定难度的,我们
- 努力做到通俗易懂
- 5)采用应用场景->设计模式->剖析原理->分析实现步骤(图解)->代码
- 实现->框架或项目源码分析(戗找到使用的地方)的步骤讲解[如:建造
- 6)课程目标:让大家掌握本质,达能在工作中灵活运用解决实际问题和优化程序结构的目的
编写软件过程中,程序员面临着来自耦合性,内聚性以及可维护性,可扩展性,重用性,灵活性等多方面的挑战,设计模式是为了让程序(软件),具有更好
- 1)代码重用性 (相同的代码不用多次编写)
- 2)可读性 (编程规范性,增加代码可读性)
- 3)可扩展性 (增加新功能)
- 4)可靠性 (增加新功能后,对原有功能没有影响)
- 5)使程序呈现高内聚,低耦合的特性
分析金句
设计模式包含了面向对象的精髓,“懂了设计模式,你就懂了面向对象分析和设计的精要"
Scott Mayers在其巨著《 Effective C++》就曾经说过:C艹老手和C+新手的区别就前者手背上有很多伤疤.
单一职责原则
(对类来说的,即一个类应该只负责一项职责)如类A负责两个不同职责:职责1,职责2。
当职责1需求
改变A时,可能造成职责2执行错误,所以需要将类A的粒度分解为A1,A2
比如,UserMapper只能操作User表,如果还操作了order表,那么就应该分为userMapper和OrderMapper两个class.
6-006单一职责原则**(一个类只负责一个方面的功能)**单一职责原则注意事项和细节
- 1)降低类的复杂度一类只负责一项职责。
- 2)提高类的可误性,可维护性
- 3)降低变更引起的风险
- 4)通常情况下,我们应当遵守单一职责原则,只有逻辑足够简单,才可以在代码级违
反单一职责原则;只有类中方法数量足够少,可以在方法级别保持单一职责原则
package com.yk.__p6_006__单一职责原则_;
import com.sun.org.slf4j.internal.Logger;
import com.sun.org.slf4j.internal.LoggerFactory;
public class Test2 {
private static final Logger logger = LoggerFactory.getLogger(Test.class);
public static void main(String[] args) {
RoadVechcle vehicle = new RoadVechcle();
vehicle.run("汽车");
AirVehicle airVehicle = new AirVehicle();
airVehicle.run("飞机");
}
}
class RoadVechcle {
void run(String name) {
System.out.println(name + "在公路运行");
}
}
class AirVehicle {
void run(String name) {
System.out.println(name + "在天上运行");
}
}
比如在此时又让汽车在10点~12点才可以运行
可以直接在RoadVechcle里面修改,不会影响AirVehicle.
7-007单一职责原则小结对类来说的,即一个类应该只负责一项职责,I如类A负责两个不同职责:职责1,职责2。当职责1需求变更而改变A时,可能造成职责2执行错误,所以需要将类A的粒度分解为A1,A2。
学了设计模式就会少些很多ifelse。用类来化解ifelse。
单一职责原则注意事项和细节
- 1)降低类的复杂度一类只负责一项职责。
- 2)提高类的可误性,可维护性
- 3)降低变更引起的风险
- 4)通常情况下,我们应当遵守单一职责原则,只有逻辑足够简单,才可以在代码级违
反单一职责原则;只有类中方法数量足够少,可以在方法级别保持单一职责原则
8-008接口隔离原则(1)(使用者只需要实现自己需要的接口,不会实现不需要实现的接口)通俗的说:单一职责,userMapper只能负责User.不能操作order
基本介绍
- 1)客户端不应该依赖它不需要的接口,即一个类对另一个类的依赖应该建立在最小的接口上。
- 2)先看一张图:
- 3)类A通过接口 interface1依赖类B,类C通过接口 Interface1依赖类D,如果接口interface1对于类A和类C来说不是最小接口那么类B和类D必须去实现他们不需要的方法。
- 4)按隔离原则应当这样处理:
- 将接口 interface1拆分为独立的几个接口,类A和类C分别与他们需要的接口建立依赖关系。也就是采用接口隔离原则.
package com.yk.__p8_008__接口隔离原则_1__;
public class Test {
}
interface Interface1 {
void option1();
void option2();
void option3();
void option4();
void option5();
}
class B implements Interface1 {
@Override
public void option1() {
System.out.println(" B - option1");
}
@Override
public void option2() {
System.out.println(" B - option2");
}
@Override
public void option3() {
System.out.println(" B - option3");
}
@Override
public void option4() {
System.out.println(" B - option4");
}
@Override
public void option5() {
System.out.println(" B - option5");
}
}
class D implements Interface1 {
@Override
public void option1() {
System.out.println(" D - option1");
}
@Override
public void option2() {
System.out.println(" D - option2");
}
@Override
public void option3() {
System.out.println(" D - option3");
}
@Override
public void option4() {
System.out.println(" D - option4");
}
@Override
public void option5() {
System.out.println(" D - option5");
}
}
//A类通过接口 Interface1依赖(使用)B类,但是只会用到123方法
class A{
public void depend2(Interface1 interface1) {
interface1.option3();
interface1.option2();
interface1.option1();
}
}
//C类通过接口 Interface1依赖(使用)D类,但是只会用到145方法
class C{
public void depend3(Interface1 interface1) {
interface1.option1();
interface1.option4();
interface1.option5();
}
}
这样做是有问题的,A用不到的方法也需要重写了,D用不到的方法也重写了.
应该把接口拆分.
9-009接口隔离原则(2)接口拆分.B实现interface1,interface2
接口拆分.D实现interface1,interface3
Java
package com.yk.__p9_009__接口隔离原则_2__;
public class Test {
public static void main(String[] args) {
A a = new A();
a.depend1(new B());
a.depend2(new B());
}
}
interface Interface1 {
void option1();
}
interface Interface2 {
void option2();
void option3();
}
interface Interface3{
void option4();
void option5();
}
class B implements Interface1,Interface2 {
@Override
public void option1() {
System.out.println(" B - option1");
}
@Override
public void option2() {
System.out.println(" B - option2");
}
@Override
public void option3() {
System.out.println(" B - option3");
}
}
class D implements Interface1,Interface3 {
@Override
public void option1() {
System.out.println(" D - option1");
}
@Override
public void option4() {
System.out.println(" D - option4");
}
@Override
public void option5() {
System.out.println(" D - option5");
}
}
//A类通过接口 Interface1依赖(使用)B类,但是只会用到123方法
class A{
public void depend1(Interface1 interface1) {
interface1.option1();
}
public void depend2(Interface2 interface1) {
interface1.option2();
}
public void depend3(Interface2 interface1) {
interface1.option3();
}
}
//C类通过接口 Interface1依赖(使用)D类,但是只会用到145方法
class C{
public void depend1(Interface1 interface1) {
interface1.option1();
}
public void depend4(Interface3 interface1) {
interface1.option4();
}
public void depend5(Interface3 interface1) {
interface1.option5();
}
}
通俗的说:
10-010接口隔离原则小结就是依赖的接口,都是需要用到的接口.不能说有一个接口我用不到还需要实现
- 依赖是通过接口来依赖的
- 只需要实现有用的接口.
基本介绍
依赖倒转原则( Dependence Inversion Principle)是指
- 1)高层模块不应该赖低层模块,二者都应该依赖其抽象
- 2)抽象不应该依赖细节,细节应该依赖抽象
- 3)依赖倒转(倒置)的中心思想是面向接口编程
- 4)依赖倒转原则是基于这样的设计理念:相对于细节的多变性,抽象的东西要稳定的多。以抽象为基础搭建的架构比以细节为基础的架构要稳定的多。在java中,抽象指的是接口或抽象类,细节就是具体的实现类
- 5)使用接口或抽象类的目的是制定好规范,而不涉及任何具体的操作,把展现细节的任务交给他们的实现类去完成
12-012依赖倒转原则(2)高级的模块不应该依赖低级模块,应该依赖于接口
package com.yk.__p12_012__依赖倒转原则_2__;
public class Main {
public static void main(String[] args) {
Person person = new Person();
person.recive(new Email());
person.recive(new Weixin());
}
}
//完成 Person接收消息的功能
//方式1分析
//1.简单,比较容易想到
//2.如果我们获取的对象是微信,短信等等,则新增类,同时 Perons也要增加相应的接收方法
//3.解决思路:引入一个抽象的接口 REceiver,表示接收者,这样 Person类与接口 REceiver发生依赖
class Person{
void recive(IReciver email) {
System.out.println("接收电子邮件:" + email.getInfo());
}
}
class Email implements IReciver {
public String getInfo() {
return "Hello";
}
}
//定义接口
interface IReciver{
String getInfo();
}
//增加微信
class Weixin implements IReciver {
public String getInfo() {
return "微信";
}
}
设置的三中方法:
- 通过接口传递
- 通过构造器传递
- 通过set方法传递
- 1)低层模块尽量都要有抽象类或接囗,或者两者都有,程序稳定性更好
- 2)变量的声明类型尽量是抽象类或接口,这样我们的变量引用和实际对象间,就存在一个缓冲层,利于程序扩展和优化.
- 3)继承时遵循里氏替换原则
里氏替换原则
oo中的继性的思考和说明
- 1)继承包含这样一层含义:父类中凡是已经实现好的方法,实际上是在设定规范和契约,虽然它不强制要求所有的子类必须遵循这些契约,但是如果子类对这些已经实现的方法任意修改,就会对整个继承体系造成破坏。
- 2)继承在给程序设计带来便利的同时,也带来了弊端。比如使用继承会给程序带来侵入性,程序的可移植性降低,增加对象间的耦合性,如果一个类被其他的类所继承则当这个类需要修改时,必须考虑到所有的子类,并且父类修改后,所有涉及到子类的功能都有可能产生故障
- 3)问题提出:在编程中,如何正确的使用继承?=>里氏替换原则
基本介绍
- 1)里氏替换原则( Liskov Substitution Principle)在1988年,由麻省理工学院的以为姓里的女士提出的。
- 2)如果对每个类型为T1的对象01,都有类型为T2的对象o2,使得以T1定义的所有程序P在所有的对象o都代换成o2时,程序P的行为没有发生变化,那么类型T2是类型T1的子类型。换句话说,所有引用基类的地方必须能透明地使用其子类的对象。
- 3)在使用继承时,遵循里氏替换原则**,在子类中尽量不要重写父类的方法**
- 4)里氏替换原则告诉我们,继承实际上让两个类耦合性增强了**,在适当的情况下,可以通过聚合,组合,依赖来解决问题。**
极端情况 A继承了B,A重写了所有的B的方法.那么继承就没有意义了. 如果出现这种极端的情况, 那么可以提升出一个base类. 让A和B都去集成这个class15-015里氏替换原则(2)
A不小心重写了B的方法function1.
package com.yk.__p15_015__里氏替换原则_2__;
public class Main {
public static void main(String[] args) {
A a = new A();
System.out.println("11 - 3 =" + a.function1(11, 3));
System.out.println("1 - 8 = " + a.function1(1, 8));
System.out.println("-------------------------------");
B b = new B();
System.out.println("11 - 3 =" + b.function1(11, 3));
System.out.println("1 - 8 = " + b.function1(1, 8));
System.out.println("11 + 3 + 9 = " + b.function2(11, 3));
}
}
//A 类,返回两个数的差值
class A{
public int function1(int num1, int num2) {
return num1 - num2;
}
}
class B extends A {
public int function1(int num1, int num2) {
return num1 + num2;
}
public int function2(int num1, int num2) {
return function1(num1, num2) + 9;
}
}
此时程序运行,发现不满足里氏替换原则
- 1)我们发现原来运行正常的相减功能发生了错误。原因就是类B无意中重写了父类的方法,造成原有功能出现错误。在实际编程中,我们常常会通过重写父类的方法完成新的功能,这样写起来虽然简单,但整个继承体系的复用性会比较差。特别是运行多态比较频繁的时候
- 2)通用的做法是:原来的父类和子类都继承一个更通俗的基类,原有的继承关系去掉,采用依赖,聚合,组合等关系代替.
package com.yk.__p15_015__里氏替换原则_2__._改进;
public class Main {
public static void main(String[] args) {
A a = new A();
System.out.println("11 - 3 =" + a.function1(11, 3));
System.out.println("1 - 8 = " + a.function1(1, 8));
System.out.println("-------------------------------");
B b = new B();
System.out.println("11 - 3 =" + b.function1(11, 3));
System.out.println("1 - 8 = " + b.function1(1, 8));
System.out.println("11 + 3 + 9 = " + b.function2(11, 3));
}
}
//创建一个更加基础的基类
class Base{
}
//A 类,返回两个数的差值
class A extends Base {
public int function1(int num1, int num2) {
return num1 - num2;
}
}
class B extends Base {
public static final A a = new A();
public int function1(int num1, int num2) {
return a.function1(num1, num2);
}
public int function2(int num1, int num2) {
return a.function1(num1, num2) + 9;
}
}
继承虽然好,但是也会给我们带来一些问题.
所以才引用出来了里氏替换原则.
16-016开闭原则(1)(ocp原则,(使用者)对扩展开放,对修改关闭)- 1)开閉原则( Open Closed Principle)是编程中最基础、最重要的设计原则
- 2)一个软件实体如类,模块和函数应该对扩展开放,对修关闭。用抽象构建框架,用实现扩展细节
- 3)当软件需要变化时,尽量通过扩展软件实体的行为来实现变化,而不是通过修改已有的代码来实现变化
- 4)编程中遵循其它原则,以及使用设计模式的目的就是遵循开闭原则
对扩展开方,对修改关闭
package com.yk.__p16_016__开闭原则_1__;
public class Ocp {
public static void main(String[] args) {
//使用看看存在的问题
GraphicEditor graphicEditor = new GraphicEditor();
graphicEditor.drawShape(new Rectangle());
graphicEditor.drawShape(new Circle());
}
}
//这是一个用于绘图的类 [使用方]
class GraphicEditor {
//接收Shape对象,然后根据type,来绘制不同的图形
public void drawShape(Shape s) {
if (s.m_type == 1)
drawRectangle(s);
else if (s.m_type == 2)
drawCircle(s);
}
//绘制矩形
public void drawRectangle(Shape r) {
System.out.println(" 绘制矩形 ");
}
//绘制圆形
public void drawCircle(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;
}
}
17-017开闭原则(2)
如果需要添加一个新功能,绘制三角形
首先需要新增一个类 ,与此同时需要修改(使用者)GraphicEditor类中的方法
如果需要添加一个新功能,绘制三角形
首先需要新增一个类 ,与此同时需要修改(使用者)GraphicEditor类中的方法
//新增画三角形
class Triangle extends Shape {
Triangle() {
super.m_type = 3;
}
}
同时需要在drawShape方法中修改,增加
else if (s.m_type == 3) drawTriangle(s);
并且还得新增 drawTriangle()方法来完成绘制
可以发现新增功能时需要修改原来的功能、
改进:
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());
graphicEditor.drawShape(new OtherGraphic());
}
}
//这是一个用于绘图的类 [使用方]
class GraphicEditor {
//接收Shape对象,调用draw方法
public void drawShape(Shape s) {
s.draw();
}
}
//Shape类,基类
abstract class Shape {
int m_type;
public abstract void draw();//抽象方法
}
class Rectangle extends Shape {
Rectangle() {
super.m_type = 1;
}
@Override
public void draw() {
// TODO Auto-generated method stub
System.out.println(" 绘制矩形 ");
}
}
class Circle extends Shape {
Circle() {
super.m_type = 2;
}
@Override
public void draw() {
// TODO Auto-generated method stub
System.out.println(" 绘制圆形 ");
}
}
//新增画三角形
class Triangle extends Shape {
Triangle() {
super.m_type = 3;
}
@Override
public void draw() {
// TODO Auto-generated method stub
System.out.println(" 绘制三角形 ");
}
}
//新增一个图形
class OtherGraphic extends Shape {
OtherGraphic() {
super.m_type = 4;
}
@Override
public void draw() {
// TODO Auto-generated method stub
System.out.println(" 绘制其它图形 ");
}
}
18-018开闭原则小结
- 1)开閉原则( Open Closed Principle)是编程中最基础、最重要的设计原则(都是为了实现这个原则)
- 2)一个软件实体如类,模块和函数应该对扩展开放,对修关闭。用抽象构建框架,用实现扩展细节
- 3)当软件需要变化时,尽量通过扩展软件实体的行为来实现变化,而不是通过修改已有的代码来实现变化
- 4)编程中遵循其它原则,以及使用设计模式的目的就是遵循开闭原则
增加新功能时候:
尽量是新增代码,不是去修改和复写代码19-019迪米特法则(1)(最少知道原则)
基本介绍
- 1)一个对象应该对其他对象保持最少的了解
- 2)类与类关系越密切,耦合度越大
- 3)迪米特法则( Demeter Principle又叫最少知道原则,即一个类对自己依赖的类知道的越少越好。也就是说,对于被依赖的类不管多么复杂,都尽量将逻辑封装在类的内部。对外除了提供的pubc方法,不对外泄露任何信息)
- 4)迪米特法则还有个更简单的定义:只与直接的朋友通信
- 5)直接的朋友:每个对象都会与其他对象由耦合关系,只要两个对象之间有耦合关系我们就说这两个对象之间是朋友关系。
耦合的方式很多,依赖,关联,组合,聚合等。其中,我们称出现成员变量,方法参数,方法返回值中的类为直接的朋友,而出现在局部变量中的类不是直接的朋友。
也就是说,陌生的类最好不要以局部变量的形式出现在类的内部.
应用实例有一个学校,下属有各个学院和总部,现要求打印出学校总部员工ID和学院员工的id
public class Demeter1 {
public static void main(String[] args) {
SchoolManager schoolManager = new SchoolManager();
schoolManager.printAllEmployee(new CollegeManager());
}
}
//学校总部员工
class Employee {
private String id;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
}
//学院员工
class CollegeEmployee {
private String id;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
}
//管理学院员工
class CollegeManager {
public List getAllEmployee() {
List arrayList = new ArrayList<>();
for (int i = 0; i < 10; i++) {
CollegeEmployee collegeEmployee = new CollegeEmployee();
collegeEmployee.setId("学院员工id=" + (i + 1));
arrayList.add(collegeEmployee);
}
return arrayList;
}
}
//学校管理类
class SchoolManager {
public List getAllEmployee() {
List list = new ArrayList<>();
for (int i = 0; i < 5; i++) {
Employee employee = new Employee();
employee.setId("学校总部员工id=" + (i + 1));
list.add(employee);
}
return list;
}
void printAllEmployee(CollegeManager collegeManager) {
//获取学院员工
List allEmployee = collegeManager.getAllEmployee();
System.out.println("=================学院员工=================");
for (CollegeEmployee employee : allEmployee) {
System.out.println(employee.getId());
}
//获取学校总部员工
List employeeList = this.getAllEmployee();
System.out.println("================学校总部员工=================");
for (Employee employee : employeeList) {
System.out.println(employee.getId());
}
}
}
分析:
(1)前面设计的问题在于SchoolManager中,CollegeEmployee类并不是SchoolManager类的直接朋友
(2)按照迪米特法则,应该避免类中出现这样非直接朋友关系的耦合
改进:在CollegeManager类中直接新增一个printEmployee方法专门用于打印学院员工信息
public class Demeter1 {
public static void main(String[] args) {
SchoolManager schoolManager = new SchoolManager();
schoolManager.printAllEmployee(new CollegeManager());
}
}
//学校总部员工
class Employee {
private String id;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
}
//学院员工
class CollegeEmployee {
private String id;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
}
//管理学院员工
class CollegeManager {
public List getAllEmployee() {
List arrayList = new ArrayList<>();
for (int i = 0; i < 10; i++) {
CollegeEmployee collegeEmployee = new CollegeEmployee();
collegeEmployee.setId("学院员工id=" + (i + 1));
arrayList.add(collegeEmployee);
}
return arrayList;
}
public void printEmployee(){
//获取学院员工
List allEmployee = this.getAllEmployee();
System.out.println("=================学院员工=================");
for (CollegeEmployee employee : allEmployee) {
System.out.println(employee.getId());
}
}
}
//学校管理类
class SchoolManager {
public List getAllEmployee() {
List list = new ArrayList<>();
for (int i = 0; i < 5; i++) {
Employee employee = new Employee();
employee.setId("学校总部员工id=" + (i + 1));
list.add(employee);
}
return list;
}
void printAllEmployee(CollegeManager collegeManager) {
collegeManager.printEmployee();
//获取学校总部员工
List employeeList = this.getAllEmployee();
System.out.println("================学校总部员工=================");
for (Employee employee : employeeList) {
System.out.println(employee.getId());
}
}
}
21-021迪米特法则注意事项
三、注意事项和细节
- (1)迪米特法则的核心是降低类之间的耦合
- (2)注意:由于每个类都减少了不必要的依赖,因此迪米特法则只是要求降低类间(对象间)耦合关系,并不是要求完全没有依赖关系
尽量使用合成/聚合的方式,而不是使用继承
应用实例此处有两个类,A类和B类,然后我们接到一个需求,需要在B类中使用到A类的方法
解决方案1:直接让B类继承A类
1 public class A {
2 void operation1(){
3 //do something...
4 }
5
6 void operation2(){
7 //do something...
8 }
9 }
10
11 class B extends A{
12 @Override
13 void operation1() {
14 super.operation1();
15 }
16
17 @Override
18 void operation2() {
19 super.operation2();
20 }
21 }
分析:如果只是让B类去使用A类中的方法,使用继承就会让B类和A类之间的耦合性增强(一旦A类发生任何变动就会影响到B类),可以使用合成/聚合的方式替代继承
解决方案2:让A类作为B类方法的参数来实现依赖关系
代码实现:
1 public class A {
2 void operation1() {
3 //do something...
4 }
5
6 void operation2() {
7 //do something...
8 }
9 }
10
11 class B {
12 void operation1(A a) {
13 a.operation1();
14 a.operation2();
15 }
16 }
解决方案3:将A类的实例作为B类的成员变量来实现聚合关系
代码实现:
1 public class A {
2 void operation1() {
3 //do something...
4 }
5
6 void operation2() {
7 //do something...
8 }
9 }
10
11 class B {
12 private A a;
13
14 public void setA(A a) {
15 this.a = a;
16 }
17 }
解决方案4:将A类在B类中实例化来实现组合关系
代码实现:
1 public class A {
2 void operation1() {
3 //do something...
4 }
5
6 void operation2() {
7 //do something...
8 }
9 }
10
11 class B {
12 A a = new A();
13 }
三、设计原则的核心思想
(1)找出应用中可能需要变化之处,把它们独立出来,不要和那些不需要变化的代码混在一起
(2)针对接口编程,而不是针对实现编程
(3)为了交互对象之间的松耦合设计而努力
23-023UML基本介绍 一、基本介绍(1)UML——Unified modeling language(统一建模语言),是一种用于软件系统分析和设计的语言工具,它用于帮助软件开发人员进行思考和记录思路的结果
(2)UML 本身是一套符号的规定,就像数学符号和化学符号一样,这些符号用于描述软件模型中的各个元素和他们之间的关系,比如类、接口、实现、泛化、依赖、组合、聚合等,如下图
https://haokan.baidu.com/v?vid=16530443885328155091
24-024UML类图 二、UML图画 UML 图与写文章差不多,都是把自己的思想描述给别人看,关键在于思路和条理
UML 图分类:
(1)用例图(use case)
(2)静态结构图:类图、对象图、包图、组件图、部署图
(3)动态行为图:交互图(时序图与协作图)、状态图、活动图
三、UML类图(1)用于描述系统中的类(对象)本身的组成和类(对象)之间的各种静态关系
(2)类之间的关系:依赖、泛化(继承)、实现、关联、聚合与组合
25-025类的依赖、泛化和实现举例:将以下代码转换为UML类图
class Person { //代码形式->类图
private Integer id;
private String name;
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
}
UML类图—依赖关系(Dependence)
只要是在类中用到了对方,那么他们之间就存在依赖关系。如果没有对方,连编译都无法通过
示例代码:
class PersonServiceBean {
private PersonDao personDao;
public void save(Person person){
}
public IDCard getIDCard(Integer personid) {
}
public void modify() {
Department department = new Department();
}
}
class PersonDao {
}
class IDCard {
}
class Person {
}
class Department {
}
总结:如何判断两个类之间是否为依赖关系
(1)类中用到了对方
(2)类的成员属性
(3)方法的返回类型
(4)方法接收的参数类型
(5)方法体中使用到
UML类图—泛化关系(Generalization)泛化关系实际上就是继承关系,它是依赖关系的特例
示例代码:
abstract class DaoSupport {
public void save(Object entity) {
}
public void delete(Object id) {
}
}
class PersonServiceBean extends DaoSupport {
}
总结:
(1)泛化关系实际上就是继承关系
(2)如果 A 类继承了 B 类,我们就说 A 和 B 存在泛化关系
26-026类的关联、聚合和组合 UML类图—实现关系(Implementation)实现关系实际上就是 A类实现 B 接口,它是依赖关系的特例
示例代码:
interface PersonService {
void delete(Integer id);
}
class PersonServiceBean implements PersonService {
public void delete(Integer id) {
}
}
UML类图—关联关系(Association)
关联关系实际上就是类和类之间的联系,它是依赖关系的特例
关联具有导航性,即双向关系或单向关系
关系具有多重性:如“1”(表示有且仅有一个),“0…”(表示0个或者多个),“0,1”(表示0个或者一个),“n…m”(表示n到m个都可以),“m…*”(表示至少m个)
单向一对一关系:
public class Person {
private IDCard idCard;
}
public class IDCard {
}
双向一对一关系:
public class Person {
private IDCard idCard;
}
public class IDCard {
private Person person;
}
UML类图—聚合关系(Aggregation)
聚合关系(Aggregation)表示的是整体和部分的关系,整体与部分可以分开
聚合关系是关联关系的特例,所以他具有关联的导航性与多重性
举例:一台电脑由键盘(keyboard)、显示器(monitor),鼠标(mouse)等组成,组成电脑的各个配件是可以从电脑上分离出来的,使用带空心菱形的实线来表示
public class Computer {
private Mouse mouse;
private Keyboard keyboard;
private Monitor monitor;
public void setMouse(Mouse mouse) {
}
public void setKeyboard(Keyboard keyboard) {
}
public void setMonitor(Monitor monitor) {
}
}
public class Keyboard {
}
public class Monitor {
}
public class Mouse {
}
UML类图—组合关系(Composition)
组合关系(Composition)跟聚合关系(Aggregation)一样,也是整体与部分的关系,但是整体与部分不可以分开
例如:在程序中我们定义实体:Person,IDCard 和 Head, 那么 Head 和 Person 就是组合,IDCard 和 Person 就是聚合,但是如果在程序中 Person 实体中定义了对 IDCard 进行级联删除,即删除 Person 时连同 IDCard 一起删除,那么 IDCard 和 Person 就是组合了
具体代码:
public class Person {
private IDCard idCard;
private final Hand hand = new Hand();
}
public class IDCard {
}
public class Hand {
}
27-027类图六大关系总结
依赖、泛化(继承)、实现、关联、聚合与组合
28-028设计模式概述和分类 掌握设计模式的层次(以独孤求败的五种用剑境界作对比)第1层:刚开始学编程不久,听说过什么是设计模式(“凌厉刚猛,无坚不摧,弱冠前以之与河朔群雄争锋。”)
第2层:有很长时间的编程经验,自己写了很多代码,其中用到了设计模式,但是自己却不知道(“紫薇软剑,三十岁前所用,误伤义士不祥,乃弃之深谷。”)
第3层:学习过了设计模式,发现自己已经在使用了,并且发现了一些新的模式挺好用的(“重剑无锋,大巧不工。四十岁前恃之横行天下。”)
第4层:阅读了很多别人写的源码和框架,在其中看到别人设计模式,并且能够领会设计模式的精妙和带来的好处(“四十岁後,不滞于物,草木竹石均可为剑。”)
第5层:代码写着写着,自己都没有意识到使用了设计模式,并且熟练的写了出来(“自此精修,渐进于无剑胜有剑之境。”)
设计模式介绍设计模式是程序员在面对同类软件工程设计问题所总结出来的有用的经验,模式不是代码,而是某类问题的通用解决方案,设计模式(Design Pattern)代表了最佳的实践。
这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的
设计模式的本质提高软件的可维护性,通用性和扩展性,并降低软件的复杂度
《设计模式》是一本经典的书,作者是 Erich Gamma、Richard Helm、Ralph Johnson 和 John Vlissides Design
设计模式并不拘泥于某种语言,Java,PHP,C++ 都有设计模式.
设计模式类型设计模式从目的来看的话分为三种类型
创建型模式:这类模式提供创建对象的机制, 能够提升已有代码的灵活性和可复用性。
例如:单例模式、抽象工厂模式、原型模式、建造者模式、工厂模式
结构型模式:这类模式介绍如何将对象和类组装成较大的结构, 并同时保持结构的灵活和高效。
例如:适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式
行为型模式:这类模式负责对象间的高效沟通和职责委派。
例如:模版方法模式、命令模式、访问者模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式(责任链模式)
从范围(实现手段)来看的话分为两种
类模式:处理类与子类的静态关系(继承)
对象模式:处理对象间的动态关系(组合)
29-029单例(静态常量饿汉式)所谓类的单例设计模式,就是采取一定的方法保证在整个的软件系统中,对某个类只能存在一个对象实例,并且该类只提供一个取得其对象实例的方法(静态方法)。
比如Hibernate的SessionFactory,它充当数据存储源的代理,并负责创建Session对象。
SessionFactory并不是轻量级的,一般情况下,一个项目通常只需要一个SessionFactory就够,这是就会使用到单例模式。
单例模式有八种方式:
- 饿汉式(静态常量)
- 饿汉式(静态代码块)
- 懒汉式(线程不安全)
- 懒汉式(线程安全,同步方法)
- 懒汉式(线程安全,同步代码块)
- 双重检查
- 静态内部类
- 枚举
饿汉式(静态常量)应用实例 步骤如下:
-
构造器私有化 (防止 new )
-
类的内部创建对象
-
向外暴露一个静态的公共方法。 getInstance
-
代码实现
public class SingletonTest { public static void main(String[] args) { System.out.println(Singleton.getInstance() == Singleton.getInstance()); System.out.println(Singleton.getInstance().hashCode()); System.out.println(Singleton.getInstance().hashCode()); } } class Singleton{ //1. 构造器私有化,防止直接new private Singleton(){ } //2. 提供一个静态私有常量,在类加载时直接创建一个对象赋值给这个静态私有常量 private static final Singleton instance=new Singleton(); //3. 提供一个对外的方法,获取实例 public static Singleton getInstance(){ return instance; } }
优缺点说明:
- 优点:这种写法比较简单,就是在类装载的时候就完成实例化。避免了线程同步问题。
- 缺点:在类装载的时候就完成实例化,没有达到Lazy Loading的效果。如果从始 至终从未使用过这个实例,则会造成内存的浪费
- 这种方式基于classloder机制避免了多线程的同步问题,不过, instance在类装载 时就实例化,在单例模式中大多数都是调用getInstance方法, 但是导致类装载 的原因有很多种, 因此不能确定有其他的方式(或者其他的静态方法)导致类 装载,这时候初始化instance就没有达到lazy loading的效果
- 结论:这种单例模式可用, 可能造成内存浪费
30-030单例(静态代码块饿汉式) 饿汉式(静态代码块)因为JVM在装载类的时候是线程安全的,所以饿汉式的写法是天然的线程安全,但是没有做到懒加载 如果开发者确信这个类会被加载,且只会被加载一次,加载时机也是确定的,则饿汉式也是推荐的写法
饿汉式(静态代码块)应用实例
public class SingletonTest {
public static void main(String[] args) {
System.out.println(Singleton.getInstance() == Singleton.getInstance());
System.out.println(Singleton.getInstance().hashCode());
System.out.println(Singleton.getInstance().hashCode());
}
}
class Singleton {
private static final Singleton instance;
// 在静态代码块中创建单例对象
static {
instance = new Singleton();
}
private Singleton() {
}
public static Singleton getInstance() {
return instance;
}
}
优缺点说明:
- 这种方式和上面的方式其实类似,只不过将类实例化的过程放在了静态代码块中,也是在类装载的时候,就执行静态代码块中的代码,初始化类的实例。优缺点和上面是一样的。
- 结论: 这种单例模式可用,但是可能造成内存浪费
31-031单例(线程不安全懒汉式) 懒汉式(线程不安全)类在加载时,静态变量以及静态代码块是一起组装到方法中一起执行的,所以这两种写法本质是没有区别的
public class SingletonTest {
public static void main(String[] args) {
System.out.println(Singleton.getInstance() == Singleton.getInstance());
System.out.println(Singleton.getInstance().hashCode());
System.out.println(Singleton.getInstance().hashCode());
}
}
class Singleton {
private static Singleton instance;
private Singleton() {
}
// 当调用该方法时才会创建对象
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
优缺点说明:
- 起到了Lazy Loading的效果,但是只能在单线程下使用。
- 如果在多线程下,一个线程进入了if (instance == null)判断语句块,还未来得及往下执行,另一个线程也通过了这个判断语句,这时便会产生多个实例。所以在多线程环境下不可使用这种方式
- 结论:在实际开发中,不要使用这种方式
懒汉式(线程安全,同步方法)
public class SingletonTest {
public static void main(String[] args) {
System.out.println(Singleton.getInstance() == Singleton.getInstance());
System.out.println(Singleton.getInstance().hashCode());
System.out.println(Singleton.getInstance().hashCode());
}
}
class Singleton {
private static Singleton instance;
private Singleton() {
}
//加入了同步方法,解决了线程不安全问题
public synchronized static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
优缺点说明:
- 解决了线程不安全问题
- 效率太低了,每个线程在想获得类的实例时候,执行getInstance()方法都要进行同步。而其实这个方法只执行一次实例化代码就够了,后面的想获得该类实例,直接return就行了。方法进行同步效率太低
- 结论: 在实际开发中, 不推荐使用这种方式
懒汉式(线程安全,同步代码块)应用实例 代码演示:
public class SingletonTest {
public static void main(String[] args) {
System.out.println(Singleton.getInstance() == Singleton.getInstance());
System.out.println(Singleton.getInstance().hashCode());
System.out.println(Singleton.getInstance().hashCode());
}
}
class Singleton {
private static Singleton instance;
private Singleton() {
}
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
instance = new Singleton();
}
}
return instance;
}
}
优缺点说明:
- 这种方式,本意是想对第四种实现方式的改进,因为前面同步方法效率太低,改为同步产生实例化的的代码块
- 但是这种同步并不能起到线程同步的作用。跟第3种实现方式遇到的情形一致,假如一个线程进入了if (instance == null)判断语句块,还未来得及往下执行,另一个线程也通过了这个判断语句,这时便会产生多个实例
- 结论:在实际开发中, 不能使用这种方式
双重检查应用实例
public class SingletonTest {
public static void main(String[] args) {
System.out.println(Singleton.getInstance() == Singleton.getInstance());
System.out.println(Singleton.getInstance().hashCode());
System.out.println(Singleton.getInstance().hashCode());
}
}
class Singleton {
private static volatile Singleton instance;
private Singleton() {
}
public static Singleton getInstance() {
//在同步代码块外面检查,防止实例创建后每次都进入同步块中,这样会降低效率
if (instance == null) {
synchronized (Singleton.class) {
//在同步块内部,创建对象的时候,进行判断,防止最开始没有创建对象的时候,会有多个线程进来创建实例
if(instance==null){
instance = new Singleton();
}
}
}
return instance;
}
}
优缺点说明:
- Double-Check概念是多线程开发中常使用到的, 如代码中所示,我们进行了两次if (singleton == null)检查,这样就可以保证线程安全了。
- 这样,实例化代码只用执行一次,后面再次访问时,判断if (singleton == null), 直接return实例化对象,也避免的反复进行方法同步.
- 线程安全;延迟加载;效率较高
- 结论:在实际开发中,推荐使用这种单例设计模式
静态内部类应用实例
public class SingletonTest {
public static void main(String[] args) {
System.out.println(Singleton.getInstance() == Singleton.getInstance());
System.out.println(Singleton.getInstance().hashCode());
System.out.println(Singleton.getInstance().hashCode());
}
}
class Singleton {
private Singleton() {
}
private static class SingletonInstance {
private static final Singleton INSTANCE = new Singleton();
}
public static Singleton getInstance() {
return SingletonInstance.INSTANCE;
}
}
优缺点说明:
- 这种方式采用了类装载的机制来保证初始化实例时只有一个线程。
- 静态内部类方式在Singleton类被装载时并不会立即实例化,而是在需要实例化时,调用getInstance方法,才会装载SingletonInstance类,从而完成Singleton的实例化。
- 类的静态属性只会在第一次加载类的时候初始化,所以在这里, JVM帮助我们 保证了线程的安全性,在类进行初始化时,别的线程是无法进入的。
- 优点:避免了线程不安全,利用静态内部类特点实现延迟加载,效率高
- 结论:推荐使用.
36-036单例(枚举方式) 枚举类加载器加载类只会加载一次(在类不存在时) 内部类的加载时机与外部类不同,内部类只有在使用的时候才会被加载 JVM在装载类的时候是线程安全的
枚举应用实例
public class SingletonTest {
public static void main(String[] args) {
System.out.println(Singleton.INSTANCE==Singleton.INSTANCE);
System.out.println(Singleton.INSTANCE.hashCode());
System.out.println(Singleton.INSTANCE.hashCode());
}
}
enum Singleton {
INSTANCE;
public void sayOK(){
System.out.println("ok");
}
}
优缺点说明:
- 这借助JDK1.5中添加的枚举来实现单例模式。不仅能避免多线程同步问题,而且还能防止反序列化重新创建新的对象。
- 这种方式是Effective Java作者Josh Bloch 提倡的方式 3 结论:推荐使用
简单的饿汉式代码
38-038单例模式注意事项 5.10 单例模式注意事项和细节说明- 单例模式保证了 系统内存中该类只存在一个对象,节省了系统资源,对于一些需要频繁创建销毁的对象,使用单例模式可以提高系统性能
- 当想实例化一个单例类的时候,必须要记住使用相应的获取对象的方法,而不是使用new
- 单例模式使用的场景:需要频繁的进行创建和销毁的对象、创建对象时耗时过多或耗费资源过多(即:重量级对象), 但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象(比如数据源、 session工厂等)
看一个具体的需求 看一个披萨的项目:要便于披萨种类的扩展,要便于维护
- 披萨的种类很多(比如 GreekPizz、 CheesePizz 等)
- 披萨的制作有 prepare, bake, cut, box
- 完成披萨店订购功能。
使用传统的方式来完成
//将Pizza 类做成抽象
abstract class Pizza {
protected String name; //名字
//准备原材料, 不同的披萨不一样,因此,我们做成抽象方法
public abstract void prepare();
public void bake() {
System.out.println(name + " baking;");
}
public void cut() {
System.out.println(name + " cutting;");
}
//打包
public void box() {
System.out.println(name + " boxing;");
}
public void setName(String name) {
this.name = name;
}
}
class PepperPizza extends Pizza {
@Override
public void prepare() {
// TODO Auto-generated method stub
System.out.println(" 给胡椒披萨准备原材料 ");
}
}
class GreekPizza extends Pizza {
@Override
public void prepare() {
// TODO Auto-generated method stub
System.out.println(" 给希腊披萨 准备原材料 ");
}
}
class CheesePizza extends Pizza {
@Override
public void prepare() {
// TODO Auto-generated method stub
System.out.println(" 给制作奶酪披萨 准备原材料 ");
}
}
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
class OrderPizza {
// 构造器
public OrderPizza() {
Pizza pizza = null;
String orderType; // 订购披萨的类型
do {
orderType = getType();
if (orderType.equals("greek")) {
pizza = new GreekPizza();
pizza.setName(" 希腊披萨 ");
} else if (orderType.equals("cheese")) {
pizza = new CheesePizza();
pizza.setName(" 奶酪披萨 ");
} else if (orderType.equals("pepper")) {
pizza = new PepperPizza();
pizza.setName("胡椒披萨");
} else {
break;
}
//输出pizza 制作过程
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
} while (true);
}
// 写一个方法,可以获取客户希望订购的披萨种类
private String getType() {
try {
BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
System.out.println("input pizza 种类:");
String str = strin.readLine();
return str;
} catch (IOException e) {
e.printStackTrace();
return "";
}
}
}
//相当于一个客户端,发出订购
public class PizzaStore {
public static void main(String[] args) {
new OrderPizza();
}
}
40-040简单工厂模式(2)-披萨订购
新增披萨的时候发现会修改代码,违反了ocp的原则.
上面的代码,在生产Pizza时,需要使用if...else进行判断Pizza的种类,如果添加了Pizza的种类,则if...else的代码就需要进行修改了。如果有多处代码都进行了生产Pizza,那么每当修改了Pizza的种类,则多处的代码都需要修改
传统的方式的优缺点
- 优点是比较好理解,简单易操作。
- 绝对是违反了设计模式的ocp原则,即对扩展开放,对修改关闭。即当我们给类增加新功能的时候,尽量不修改代码,或者可行少修改代码。
- 比如我们这时要新增加一个Pizza的种类(Pepper披萨),我们需要做如下修改。 如果我们增加一个Pizza 类,只要是订购Pizza的代码都需要修改。
- 改进的思路分析
- 分析:修改代码可以接受,但是如果我们在其他的地方也有创建Pizza的代码,就意味着,也需要修改,而创建Pizza的代码,经常有多处。
- 想法:把创建比萨对象封装到一个类中,这样我们有新的披萨种类时,只需要修改该类就可,其他有创造到披萨对象的代码就不需要修改了.->简单工厂模式
- 简单工厂模式是属于创造型模式,是工厂模式的一种。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式
- 简单工厂模式:定义了一个创建对象的类,由这个类来封装实例化对象的行为(代码)
- 在软件开发中,当我们会用到大量的创造某种,某类或者某批对象时,就会使用到工厂模式
使用简单工厂模式
- 简单工厂模式的设计方案: 定义一个可以实例化Pizza对象的类,封装创建对象的代码。
修改上面的代码如下:
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class OrderPizza {
//定义一个简单工厂对象
SimpleFactory simpleFactory;
Pizza pizza = null;
//构造器
public OrderPizza(SimpleFactory simpleFactory) {
setFactory(simpleFactory);
}
public void setFactory(SimpleFactory simpleFactory) {
String orderType = ""; //用户输入的
this.simpleFactory = simpleFactory; //设置简单工厂对象
do {
orderType = getType();
pizza = this.simpleFactory.createPizza(orderType);
//输出pizza
if (pizza != null) { //订购成功
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
} else {
System.out.println(" 订购披萨失败 ");
break;
}
} while (true);
}
// 写一个方法,可以获取客户希望订购的披萨种类
private String getType() {
try {
BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
System.out.println("input pizza 种类:");
String str = strin.readLine();
return str;
} catch (IOException e) {
e.printStackTrace();
return "";
}
}
}
//简单工厂类
public class SimpleFactory {
//更加orderType 返回对应的Pizza 对象
public Pizza createPizza(String orderType) {
Pizza pizza = null;
System.out.println("使用简单工厂模式");
if (orderType.equals("greek")) {
pizza = new GreekPizza();
pizza.setName(" 希腊披萨 ");
} else if (orderType.equals("cheese")) {
pizza = new CheesePizza();
pizza.setName(" 奶酪披萨 ");
} else if (orderType.equals("pepper")) {
pizza = new PepperPizza();
pizza.setName("胡椒披萨");
}
return pizza;
}
}
//相当于一个客户端,发出订购
public class PizzaStore {
public static void main(String[] args) {
//使用简单工厂模式
new OrderPizza(new SimpleFactory());
}
}
修改后,不管开发的时候,哪个地方需要生产Pizza,都只需要调用SimpleFactory类的createPizza方法,而且如果有新增的Pizza,则只需要在新增Pizza类后修改SimpleFactory类的逻辑,而其他的业务代码都不需要进行修改
以后新增OrderPizza2 OrderPizza3 …都不需要做修改
42-042简单工厂模式(4)-披萨订购简单工厂模式还可以将工厂类的创建实例的方法定义成静态方法 代码如下:
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class OrderPizza {
Pizza pizza = null;
String orderType = "";
// 构造器
public OrderPizza2() {
do {
orderType = getType();
pizza = SimpleFactory.createPizza2(orderType);
// 输出pizza
if (pizza != null) { // 订购成功
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
} else {
System.out.println(" 订购披萨失败 ");
break;
}
} while (true);
}
// 写一个方法,可以获取客户希望订购的披萨种类
private String getType() {
try {
BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
System.out.println("input pizza 种类:");
String str = strin.readLine();
return str;
} catch (IOException e) {
e.printStackTrace();
return "";
}
}
}
//相当于一个客户端,发出订购
public class PizzaStore {
public static void main(String[] args) {
new OrderPizza();
}
}
43-043工厂方法模式(1)-披萨订购
看一个新的需求 披萨项目新的需求:客户在点披萨时,可以点不同口味的披萨,比如 北京的奶酪pizza、北京的胡椒pizza 或者是伦敦的奶酪pizza、 伦敦的胡椒pizza。
思路1 使用简单工厂模式,创建不同的简单工厂类,比如BJPizzaSimpleFactory、LDPizzaSimpleFactory 等等.从当前这个案例来说,也是可以的,但是考虑到项目的规模,以及软件的可维护性、可扩展性并不是特别好
思路2 使用工厂方法模式
工厂方法模式介绍 工厂方法模式设计方案:将披萨项目的实例化功能抽象成抽象方法,在不同的口味点餐子类中具体实现。 工厂方法模式:定义了一个创建对象的抽象方法,由子类决定要实例化的类。工厂方法模式将对象的实例化推迟到子类。
44-044工厂方法模式(2)-披萨订购工厂方法模式应用案例 披萨项目新的需求:客户在点披萨时,可以点不同口味的披萨,比如 北京的奶酪pizza、北京的胡椒pizza 或者是伦敦的奶酪pizza、伦敦的胡椒pizza.
//将Pizza 类做成抽象
public abstract class Pizza {
protected String name; //名字
//准备原材料, 不同的披萨不一样,因此,我们做成抽象方法
public abstract void prepare();
public void bake() {
System.out.println(name + " baking;");
}
public void cut() {
System.out.println(name + " cutting;");
}
//打包
public void box() {
System.out.println(name + " boxing;");
}
public void setName(String name) {
this.name = name;
}
}
public class LDPepperPizza extends Pizza {
@Override
public void prepare() {
setName("伦敦的胡椒pizza");
System.out.println(" 伦敦的胡椒pizza 准备原材料");
}
}
public class LDCheesePizza extends Pizza {
@Override
public void prepare() {
setName("伦敦的奶酪pizza");
System.out.println(" 伦敦的奶酪pizza 准备原材料");
}
}
public class BJPepperPizza extends Pizza {
@Override
public void prepare() {
setName("北京的胡椒pizza");
System.out.println(" 北京的胡椒pizza 准备原材料");
}
}
public class BJCheesePizza extends Pizza {
@Override
public void prepare() {
setName("北京的奶酪pizza");
System.out.println(" 北京的奶酪pizza 准备原材料");
}
}
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public abstract class OrderPizza {
//定义一个抽象方法,createPizza , 让各个工厂子类自己实现
abstract Pizza createPizza(String orderType);
// 构造器
public OrderPizza() {
Pizza pizza = null;
String orderType; // 订购披萨的类型
do {
orderType = getType();
pizza = createPizza(orderType); //抽象方法,由工厂子类完成
//输出pizza 制作过程
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
} while (true);
}
// 写一个方法,可以获取客户希望订购的披萨种类
private String getType() {
try {
BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
System.out.println("input pizza 种类:");
String str = strin.readLine();
return str;
} catch (IOException e) {
e.printStackTrace();
return "";
}
}
}
public class BJOrderPizza extends OrderPizza {
@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;
}
}
public class LDOrderPizza extends OrderPizza {
@Override
Pizza createPizza(String orderType) {
Pizza pizza = null;
if (orderType.equals("cheese")) {
pizza = new LDCheesePizza();
} else if (orderType.equals("pepper")) {
pizza = new LDPepperPizza();
}
return pizza;
}
}
public class PizzaStore {
public static void main(String[] args) {
String loc = "bj";
if (loc.equals("bj")) {
//创建北京口味的各种Pizza
new BJOrderPizza();
} else {
//创建伦敦口味的各种Pizza
new LDOrderPizza();
}
}
}
45-045抽象工厂模式(1)-披萨订购
抽象工厂模式
基本介绍
- 抽象工厂模式:定义了一个interface用于创建相关或有依赖关系的对象簇,而无需指明具体的类
- 抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合。
- 从设计层面看,抽象工厂模式就是对简单工厂模式的改进(或者称为进一步的抽象)。
- 将工厂抽象成两层, AbsFactory(抽象工厂) 和 具体实现的工厂子类。程序员可以根据创建对象类型使用对应的工厂子类。 这样将单个的简单工厂类变成了工厂簇,更利于代码的维护和扩展
抽象工厂模式应用实例
将上面的抽象方法模式代码进行修改,关于Pizza的定义不需要修改,现在就是需要创建三个工厂,其中一个是抽象的工厂接口,另外两个是抽象工厂的实现类。然后OrderPizza类只需要在创建Pizza订单的时候,依赖传入的工厂类来进行Pizza的创建
//一个抽象工厂模式的抽象层(接口)
public interface AbsFactory {
//让下面的工厂子类来 具体实现
Pizza createPizza(String orderType);
}
//这是工厂子类
public class BJFactory implements AbsFactory {
@Override
public Pizza createPizza(String orderType) {
System.out.println("~使用的是抽象工厂模式~");
// TODO Auto-generated method stub
Pizza pizza = null;
if (orderType.equals("cheese")) {
pizza = new BJCheesePizza();
} else if (orderType.equals("pepper")) {
pizza = new BJPepperPizza();
}
return pizza;
}
}
public class LDFactory implements AbsFactory {
@Override
public Pizza createPizza(String orderType) {
System.out.println("~使用的是抽象工厂模式~");
Pizza pizza = null;
if (orderType.equals("cheese")) {
pizza = new LDCheesePizza();
} else if (orderType.equals("pepper")) {
pizza = new LDPepperPizza();
}
return pizza;
}
}
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
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 {
orderType = getType();
// factory 可能是北京的工厂子类,也可能是伦敦的工厂子类
pizza = factory.createPizza(orderType);
if (pizza != null) { // 订购ok
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
} else {
System.out.println("订购失败");
break;
}
} while (true);
}
// 写一个方法,可以获取客户希望订购的披萨种类
private String getType() {
try {
BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
System.out.println("input pizza 种类:");
String str = strin.readLine();
return str;
} catch (IOException e) {
e.printStackTrace();
return "";
}
}
}
public class PizzaStore {
public static void main(String[] args) {
new OrderPizza(new LDFactory());
}
}
46-046抽象工厂模式(2)-披萨订购
对比这三个工厂模式的区别:
- 简单工厂模式实现了将客户端和生成Pizza类的代码进行分离,在工厂类中可以添加所需的Pizza的逻辑代码。但是这不符合"开发-闭合"原则,也就是说对扩展开发,对修改关闭。目前简单工厂模式每次在新增Pizza种类时,就需要修改工厂类的创建实例的代码,增加if-else判断
- 工厂方法将生成Pizza的时机延迟,通过对应的工厂类来生成对于的Pizza类,即无论增加多少Pizza种类,都只需要增加对应的工厂类来实现。但是如果Pizza种类过多,就会生成很多工厂类。这也不是很方便
- 抽象工厂模式中可以定义实现不止一个工厂接口,一个工厂也可以生成不止一个产品类,抽象工厂模式将Pizza进行分类,然后每一大类的Pizza种类对应一个工厂实现
-
工厂模式的意义
-
将实例化对象的代码提取出来,放到一个类中统一管理和维护,达到和主项目的依赖关系的解耦。从而提高项目的扩展和维护性。
-
三种工厂模式(简单工厂模式,工厂方法模式,抽象工厂模式)
-
设计模式的依赖抽象原则
- 创建对象实例时,不要直接new类,而是把这个new类的动作放在一个工厂的方法中,并返回。有的书上说,变量不要直接持有具体类的引用
- 不要让类继承具体类,而是继承抽象类或者是实现 Linterface(接口)
- 不要覆盖基类中已经实现的方法。
- 工厂模式的意义
将实例化对象的代码提取出来,放到一个类中统一管理和维护,达到和主项目的依赖关系的解耦。从而提高项目的扩展和维护性。
- 三种工厂模式 (简单工厂模式、工厂方法模式、抽象工厂模式)
- 设计模式的依赖抽象原则
创建对象实例时,不要直接 new 类, 而是把这个new 类的动作放在一个工厂的方法中,并返回。有的书上说,变量不要直接持有具体类的引用。 不要让类继承具体类,而是继承抽象类或者是实现interface(接口) 不要覆盖基类中已经实现的方法。
49-049原型模式(1)-克隆羊 问题导入克隆羊问题 现在有一只羊tom, 姓名为: tom, 年龄为: 1, 颜色为:白色,请编写程序创建和tom羊 属性完全相同的10只羊。
传统方式解决克隆羊问题
public class Sheep {
private String name;
private int age;
private String color;
public Sheep(String name, int age, String color) {
super();
this.name = name;
this.age = age;
this.color = color;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
@Override
public String toString() {
return "Sheep [name=" + name + ", age=" + age + ", color=" + color + "]";
}
}
public class Client {
public static void main(String[] args) {
//传统的方法
Sheep sheep = new Sheep("tom", 1, "白色");
Sheep sheep2 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
Sheep sheep3 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
Sheep sheep4 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
Sheep sheep5 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
System.out.println(sheep);
System.out.println(sheep2);
System.out.println(sheep3);
System.out.println(sheep4);
System.out.println(sheep5);
}
}
传统的方式的优缺点
- 优点是比较好理解,简单易操作。
- 在创建新的对象时, 总是需要重新获取原始对象的属性,如果创建的对象比较复杂时,效率较低
- 总是需要重新初始化对象,而不是动态地获得对象运行时的状态, 不够灵活
- 改进的思路分析
思路: Java中Object类是所有类的根类, Object类提供了一个clone()方法,该方法可以 将一个Java对象复制一份,但是需要实现clone的Java类必须要实现一个接口Cloneable, 该接口表示该类能够复制且具有复制的能力 => 原型模式
50-050原型模式(2)-克隆羊基本介绍
- 1)原型模式( Prototype模式)是指:用原型实例指定创建对象的种类,并且通过拷贝这些原型,创建新的对象
- 2)原型模式是一种创建型设计模式,允许一个对象再创建另外一个可定制的对象无需知道如何创建的细节
- 3)工作原理是:通过将一个原型对象传给那个要发动创建的对象,这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建,即对象 clone
- 4)形象的理解:孙大圣拔出猴毛,变出其它孙大圣
public class Sheep implements Cloneable {
private String name;
private int age;
private String color;
private final String address = "蒙古羊";
public Sheep friend; //是对象, 克隆是会如何处理
public Sheep(String name, int age, String color) {
super();
this.name = name;
this.age = age;
this.color = color;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
@Override
public String toString() {
return "Sheep [name=" + name + ", age=" + age + ", color=" + color + ", address=" + address + "]";
}
//克隆该实例,使用默认的clone方法来完成
@Override
protected Object clone() {
Sheep sheep = null;
try {
sheep = (Sheep) super.clone();
} catch (Exception e) {
System.out.println(e.getMessage());
}
return sheep;
}
}
public class Client {
public static void main(String[] args) {
System.out.println("原型模式完成对象的创建");
// TODO Auto-generated method stub
Sheep sheep = new Sheep("tom", 1, "白色");
sheep.friend = new Sheep("jack", 2, "黑色");
Sheep sheep2 = (Sheep) sheep.clone(); //克隆
Sheep sheep3 = (Sheep) sheep.clone(); //克隆
Sheep sheep4 = (Sheep) sheep.clone(); //克隆
Sheep sheep5 = (Sheep) sheep.clone(); //克隆
System.out.println("sheep2 =" + sheep2 + "sheep2.friend=" + sheep2.friend.hashCode());
System.out.println("sheep3 =" + sheep3 + "sheep3.friend=" + sheep3.friend.hashCode());
System.out.println("sheep4 =" + sheep4 + "sheep4.friend=" + sheep4.friend.hashCode());
System.out.println("sheep5 =" + sheep5 + "sheep5.friend=" + sheep5.friend.hashCode());
}
}
51-051原型模式(3)-Spring源码分析 52-052原型模式(4)-深拷贝上面的类所对应的对象在克隆的时候,其属性如果是基本数据类型和String类型,都会被拷贝,且实例对象和拷贝所得的对象,它们的内存地址空间是不同的。但是如果类中的属性为引用型属性,则其属性其实仍是地址复制
浅拷贝的介绍
- 对于数据类型是基本数据类型的成员变量,浅拷贝会直接进行值传递,也就是将该属性值复制一份给新的对象。
- 对于数据类型是引用数据类型的成员变量,比如说成员变量是某个数组、某个类的对象等,那么浅拷贝会进行引用传递,也就是只是将该成员变量的引用值(内存地址)复制一份给新的对象。因为实际上两个对象的该成员变量都指向同一个实例。在这种情况下,在一个对象中修改该成员变量会影响到另一个对象的该成员变量值
- 前面我们克隆羊就是浅拷贝
- 浅拷贝是使用默认的 clone()方法来实现:sheep = (Sheep) super.clone();
深拷贝基本介绍
- 复制对象的所有基本数据类型的成员变量值
- 为所有引用数据类型的成员变量申请存储空间,并复制每个引用数据类型成员变量所引用的对象,直到该对象可达的所有对象。也就是说,对象进行深拷贝要对整个对象进行拷贝
- 深拷贝实现方式1:重写clone方法来实现深拷贝
- 深拷贝实现方式2:通过对象序列化实现深拷贝(推荐)
深拷贝应用实例
-
使用 重写clone方法实现深拷贝
public class DeepCloneableTarget implements Cloneable { private final String cloneName; private final String cloneClass; //构造器 public DeepCloneableTarget(String cloneName, String cloneClass) { this.cloneName = cloneName; this.cloneClass = cloneClass; } //因为该类的属性,都是String , 因此我们这里使用默认的clone完成即可 @Override protected Object clone() throws CloneNotSupportedException { return super.clone(); } }public class DeepProtoType implements Cloneable { public String name; //String 属性 public DeepCloneableTarget deepCloneableTarget;// 引用类型 public DeepProtoType() { super(); } //深拷贝 - 方式 1 使用clone 方法 @Override protected Object clone() throws CloneNotSupportedException { Object deep = null; //这里完成对基本数据类型(属性)和String的克隆 deep = super.clone(); //对引用类型的属性,进行单独处理 DeepProtoType deepProtoType = (DeepProtoType) deep; deepProtoType.deepCloneableTarget = (DeepCloneableTarget) deepCloneableTarget.clone(); // TODO Auto-generated method stub return deepProtoType; } }public class Client { public static void main(String[] args) throws Exception { DeepProtoType p = new DeepProtoType(); p.name = "宋江"; p.deepCloneableTarget = new DeepCloneableTarget("大牛", "小牛"); //方式1 完成深拷贝 DeepProtoType p1 = (DeepProtoType) p.clone(); System.out.println("p.name=" + p.name + "p.deepCloneableTarget=" + p.deepCloneableTarget.hashCode()); System.out.println("p2.name=" + p.name + "p2.deepCloneableTarget=" + p1.deepCloneableTarget.hashCode()); } }使用序列化来实现深拷贝。只需要修改被克隆的类中的方法,提供一个用于克隆的方法,该方法体内使用序列化使用对属性,无论是基本类型还是引用类型,进行克隆
import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.io.Serializable; public class DeepProtoType implements Serializable { public String name; //String 属性 public DeepCloneableTarget deepCloneableTarget;// 引用类型 public DeepProtoType() { super(); } //深拷贝 - 方式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); DeepProtoType copyObj = (DeepProtoType) ois.readObject(); return copyObj; } catch (Exception e) { e.printStackTrace(); return null; } finally { //关闭流 try { bos.close(); oos.close(); bis.close(); ois.close(); } catch (Exception e2) { System.out.println(e2.getMessage()); } } } }public class Client { public static void main(String[] args) throws Exception { DeepProtoType p = new DeepProtoType(); p.name = "宋江"; p.deepCloneableTarget = new DeepCloneableTarget("大牛", "小牛"); //方式2 完成深拷贝 DeepProtoType p2 = (DeepProtoType) p.deepClone(); System.out.println("p.name=" + p.name + "p.deepCloneableTarget=" + p.deepCloneableTarget.hashCode()); System.out.println("p2.name=" + p.name + "p2.deepCloneableTarget=" + p2.deepCloneableTarget.hashCode()); } }
- 创建新的对象比较复杂时,可以利用原型模式简化对象的创建过程,同时也能够提高效率
- 不用重新初始化对象,而是动态地获得对象运行时的状态
- 如果原始对象发生变化(增加或者减少属性),其它克隆对象的也会发生相应的变化,无需修改代码
- 在实现深克隆的时候可能需要比较复杂的代码
- 缺点:需要为每一个类配备一个克隆方法,这对全新的类来说不是很难,但对已有的类进行改造时,需要修改其源代码,违背了ocp原则
盖房项目需求
- 需要建房子:这一过程为打桩、 砌墙、封顶
- 房子有各种各样的,比如普通房,高楼,别墅,各种房子的过程虽然一样,但是要求不要相同的.
- 请编写程序,完成需求
传统方式解决盖房需求
public abstract class AbstractHouse {
//打地基
public abstract void buildBasic();
//砌墙
public abstract void buildWalls();
//封顶
public abstract void roofed();
public void build() {
buildBasic();
buildWalls();
roofed();
}
}
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(" 普通房子封顶 ");
}
}
public class Client {
public static void main(String[] args) {
CommonHouse commonHouse = new CommonHouse();
commonHouse.build();
}
}
传统方式解决盖房需求问题分析
- 优点是比较好理解,简单易操作。
- 设计的程序结构,过于简单,没有设计缓存层对象,程序的扩展和维护不好. 也就是说,这种设计方案,把产品(即:房子) 和 创建产品的过程(即:建房子流程) 封装在一起,耦合性增强了。
- 解决方案:将产品和产品建造过程解耦 => 建造者模式
- 建造者模式(Builder Pattern) 又叫生成器模式,是一种对象构建模式。它可以将复杂对象的建造过程抽象出来(抽象类别),使这个抽象过程的不同实现方法可以构造出不同表现(属性)的对象。
- 建造者模式 是一步一步创建一个复杂的对象,它允许用户只通过指定复杂对象的类型和内容就可以构建它们,用户不需要知道内部的具体构建细节。
- 建造者模式的四个角色
- Product(产品角色):一个具体的产品对象。
- Builder(抽象建造者):创建一个Product对象的各个部件指定的 接口/抽象类。
- ConcreteBuilder(具体建造者):实现接口,构建和装配各个部件。
- Director(指挥者):构建一个使用Builder接口的对象。它主要是用于创建一个复杂的对象。它主要有两个作用,一是:隔离了客户与对象的生产过程,二是:负责控制产品对象的生产过程。
改进:
//产品->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;
}
}
// 抽象的建造者
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;
}
}
public class CommonHouse extends HouseBuilder {
@Override
public void buildBasic() {
System.out.println(" 普通房子打地基5米 ");
}
@Override
public void buildWalls() {
System.out.println(" 普通房子砌墙10cm ");
}
@Override
public void roofed() {
System.out.println(" 普通房子屋顶 ");
}
}
public class HighBuilding 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(" 高楼的透明屋顶 ");
}
}
//指挥者,这里去指定制作流程,返回产品
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();
}
}
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();
}
}
58-058建造者模式(4)-StringBuilder源码
建造者模式在JDK的应用
- java.lang.StringBuilder中的建造者模式
- 原始码中建构者模式角色分析
- Appendable接口定义了多个append方法(抽象方法),即Appendable为抽象建造者,定义了抽象方法
- String AbstractStringBuilder实现了可附加的接口方法,这里的AbstractStringBuilder已经是建造者,只是不能实例化
- StringBuilder即成为了指挥者角色,同时并入了具体的建造者,建造方法的实现是由AbstractStringBuilder完成,而StringBuilder继承了AbstractStringBuilder
- 客户端(使用程序)不必知道产品内部组成的细节,将产品本身与产品的创建过程解耦,使得相同的创建过程可以创建不同的产品对象
- 每一个具体建造者都相对独立,而与其他的具体建造者无关,因此可以很方便地替换具体建造者或增加新的具体建造者, 用户使用不同的具体建造者即可得到不同的产品对象
- 可以更加精细地控制产品的创建过程 。将复杂产品的创建步骤分解在不同的方法中,使得创建过程更加清晰,也更方便使用程序来控制创建过程
- 增加新的具体建造者无须修改原有类库的代码,指挥者类针对抽象建造者类编程,系统扩展方便,符合 “开闭原则”
- 建造者模式所创建的产品一般具有较多的共同点,其组成部分相似, 如果产品之间 的差异性很大,则不适合使用建造者模式,因此其使用范围受到一定的限制。
- 如果产品的内部变化复杂,可能会导致需要定义很多具体建造者类来实现这种变化,导致系统变得很庞大, 因此在这种情况下,要考虑是否选择建造者模式
- 抽象工厂模式VS建造者模式 抽象工厂模式实现对产品家族的创建,一个产品家族是这样的一系列产品:具有不同分类维度的产品组合,采用抽象工厂模式不需要关心构建过程,只关心什么产品由什么工厂生产即可。而建造者模式则是要求按照指定的蓝图建造产品,它的主要目的是通过组装零配件而产生一个新产品
泰国旅游使用插座问题 现实生活中的适配器例子 泰国插座用的是两孔的(欧标) ,可以买个多功能转换插头 (适配器) ,这样就可以使用了
适配器模式基本介绍- 适配器模式(Adapter Pattern)将某个类的接口转换成客户端期望的另一个接口表 示,主的目的是兼容性,让原本因接口不匹配不能一起工作的两个类可以协同 工作。其别名为包装器(Wrapper)
- 适配器模式属于结构型模式
- 主要分为三类:类适配器模式、对象适配器模式、接口适配器模式
- 适配器模式:将一个类的接口转换成另一种接口.让原本接口不兼容的类可以兼容
- 从用户的角度看不到被适配者,是解耦的
- 用户调用适配器转化出来的目标接口方法, 适配器再调用被适配者的相关接口方法
- 用户收到反馈结果,感觉只是和目标接口交互
类适配器模式应用实例
应用实例说明 以生活中充电器的例子来讲解适配器,充电器本身相当于Adapter, 220V交流电相当于src (即被适配者), 我们的目dst(即 目标)是5V直流电。因为手机只能直接使用5V的电压充电,使用适配器后,手机是使用充5V的方式进行充电,只不过接了适配器,其实真正在使用的还是220V,但是经过转换后让手机能充上5V的电.
思路分析(类图)
代码实现
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, 不能充电~~");
}
}
}
//适配接口
public interface IVoltage5V {
int output5V();
}
//被适配的类
public class Voltage220V {
//输出220V的电压
public int output220V() {
int src = 220;
System.out.println("电压=" + src + "伏");
return src;
}
}
//适配器类
public class VoltageAdapter extends Voltage220V implements IVoltage5V {
@Override
public int output5V() {
//获取到220V电压
int srcV = output220V();
int dstV = srcV / 44; //转成 5v
return dstV;
}
}
public class Client {
public static void main(String[] args) {
System.out.println(" === 类适配器模式 ====");
Phone phone = new Phone();
phone.charging(new VoltageAdapter());//手机使用适配器充电
}
}
适配器继承了一个类,此类是充220V电压,而实现的是充5V电压的接口,手机充电调用的是充5V电压的接口方法,只不过真正执行方法时,是调用的适配器实现的该方法,该方法对200V电压->5V电压之间进行了转换
类适配器模式注意事项和细节
- Java是单继承机制,所以类适配器需要继承src类这一点算是一个缺点, 因为这要 求dst必须是接口,有一定局限性;
- src类的方法在Adapter中都会暴露出来,也增加了使用的成本。
- 由于其继承了src类,所以它可以根据需求重写src类的方法,使得Adapter的灵 活性增强了。
对象适配器模式介绍
- 基本思路和类的适配器模式相同,只是将Adapter类作修改,不是继承src类,而是持有src类的实例,以解决兼容性的问题。 即:持有 src类,实现 dst 类接口,完成src->dst的适配
- 根据“合成复用原则”,在系统中尽量使用关联关系来替代继承关系。
- 对象适配器模式是适配器模式常用的一种
对象适配器模式应用实例
- 应用实例说明 以生活中充电器的例子来讲解适配器,充电器本身相当于Adapter, 220V交流电 相当于src (即被适配者), 我们的目dst(即目标)是5V直流电, 使用对象适配器模 式完成。
- 思路分析(类图): 只需修改适配器即可, 如下:
代码实现
只需要修改适配器类,将原先适配器“继承被适配类,实现适配接口”,修改成“聚合依赖被适配类,然后实现适配接口”
//适配器类
public class VoltageAdapter implements IVoltage5V {
// 关联关系-聚合
private Voltage220V voltage220V;
//通过构造器,传入一个 Voltage220V 实例
public VoltageAdapter(Voltage220V voltage220v) {
this.voltage220V = voltage220v;
}
public void setVoltage220V(Voltage220V voltage220V) {
this.voltage220V = voltage220V;
}
@Override
public int output5V() {
int dst = 0;
if (null != voltage220V) {
//获取220V 电压
int src = voltage220V.output220V();
System.out.println("使用对象适配器,进行适配~~");
dst = src / 44;
System.out.println("适配完成,输出的电压为=" + dst);
}else{
System.out.println("适配器没有通上电");
}
return dst;
}
}
public class Client {
public static void main(String[] args) {
System.out.println(" === 对象适配器模式 ====");
Phone phone = new Phone();
phone.charging(new VoltageAdapter(new Voltage220V()));
}
}
对象适配器模式注意事项和细节
- 对象适配器和类适配器其实算是同一种思想,只不过实现方式不同。根据合成复用原则, 使用组合替代继承, 所以它解决了类适配器必须继承src的局限性问题,也不再要求dst必须是接口。
- 使用成本更低,更灵活。
接口适配器模式介绍
- 一些书籍称为:适配器模式(Default Adapter Pattern)或缺省适配器模式。
- 当不需要全部实现接口提供的方法时,可先设计一个抽象类实现接口,并为该接口中每个方法提供一个默认实现(空方法),那么该抽象类的子类可有选择地覆盖父类的某些方法来实现需求
- 适用于一个接口不想使用其所有的方法的情况
接口适配器模式应用实例
-
Android中的属性动画ValueAnimator类可以通过addListener(AnimatorListener listener)方法添加监听器, 那么常规写法如下:
ValueAnimator valueAnimator = ValueAnimator.ofInt(0,100) valueAnimator.addListener(new Animator.AnimatorListener(){ @Override public void onAnimationStart(Animator animation) { } @Override public void onAnimationEnd(Animator animation) { } @Override public void onAnimationCancel(Animator animation } @Override public void onAnimationRepeat(Animator animation } }); valueAnimator.start(); -
有时候我们不想实现 Animator.AnimatorListener接口的全部方法,只想监听onAnimationStart,会如下写:
ValueAnimator valueAnimator = ValueAnimator.ofInt(0,100); valueAnimator.addListener(new AnimatorListenerAdapter() { @Override public void onAnimationStart(Animator animation) { //xxxx具体实现 } }); valueAnimator.start(); -
AnimatorListenerAdapter类,就是一个接口适配器,它空实现了Animator.AnimatorListener类(src)的所有方法.
-
AnimatorListener是一个接口
如图:
package com.yk.__p63_063__接口适配器_电压问题_;
public interface Interface4 {
void m1();
void m2();
void m3();
void m4();
}
package com.yk.__p63_063__接口适配器_电压问题_;
//在 AbsAdapter我们将 Interface4的方法进行默认实现
public abstract class AbsAdapter implements Interface4 {
@Override
public void m1() {
}
@Override
public void m2() {
}
@Override
public void m3() {
}
@Override
public void m4() {
}
}
package com.yk.__p63_063__接口适配器_电压问题_;
public class Client {
public static void main(String[] args) {
AbsAdapter absAdapter = new AbsAdapter() {
@Override
public void m1() {
super.m1();
System.out.println("我只重写了m1");
}
};
}
}
64-064适配器模式-Dispatcher源码
JDK适配器源码
package com.yk.__p64_064__适配器模式_Dispatcher源码_;
import java.io.*;
public class Demo1 {
public static void main(String[] args) throws IOException {
//source
FileInputStream fileInputStream = new FileInputStream("/tmp/11.txt");
//适配器
InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream);
//dist
BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
String s = bufferedReader.readLine();
System.out.println(s);
}
}
首先因为要逐行解析字符串,,我们需要使用字符流,对文件内容进行处理,所以使用Reader输入流下面的BufferedReader,但是BufferedReader并不能直接处理文件,它需要传入一个Reader类型的参数,Reader下面能处理文件的类:InputStreamReader,以及其子类FileReader。
这2个类都需要一个InputStream来读取文件中的内容并转换, 这2个类其实就是适配器,可以把字节流转换成字符流, 然后使用Reader来解析其中的内容。这里的情况就是, 我们需要使用Reader字符流来解析,但是只有InputStream字节流能直接读取文件内容所以我们需要一个适配器InputStreamReader,这个类继承了Reader,并且持有InputStream的引用, 这是对象适配器的一种。
public abstract class Reader implements Readable, Closeable {
//...
}
public abstract class InputStream implements Closeable {
//...
}
public class FileInputStream extends InputStream{
//....
}
dist:接口就对应了BufferedReader;
source:对应到我们的InputStream;
Adapter:就是 InputStreamReader;
client:Demo1类;
适配器模式在 SpringMVc框架应用的源码剖析- SpringMvc中的 Handler Adapter,就使用了适配器模式
- SpringMVC处理请求的流程回顾
3)使用 HandlerAdapter的原因分析
看到处理器的类型不同,有多重实现方式,那么调用方式就不是确定的,如果需要直接调用Controller方法,需要调用的时侯就得不断是使用 if else来进行判断是哪一种子类然后执行。那么
如果后面要扩展 Controller,就得修改原来的代码,这样违背了OCP原则
// 通过handlermapping来映射controller mappedHandler = getHandler(processedRequest); // 获取适配器 HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler()); // 调用并且controller 返回modelandview mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
HandlerAdapteF的实现子类,
使得每一种 Controller自一种对应的话配器实现类.
每一种 Controller有不同的实现方式
package com.yk.__p64_064__适配器模式_Dispatcher源码_.springmvc;
//多种Controller实现
public interface Controller {
}
class HttpController implements Controller {
public void doHttpHandler() {
System.out.println("http...");
}
}
class SimpleController implements Controller {
public void doSimplerHandler() {
System.out.println("simple...");
}
}
class AnnotationController implements Controller {
public void doAnnotationHandler() {
System.out.println("annotation...");
}
}
package com.yk.__p64_064__适配器模式_Dispatcher源码_.springmvc;
import java.util.ArrayList;
import java.util.List;
public class DispatchServlet {
public static List handlerAdapters = new ArrayList();
public DispatchServlet() {
handlerAdapters.add(new AnnotationHandlerAdapter());
handlerAdapters.add(new HttpHandlerAdapter());
handlerAdapters.add(new SimpleHandlerAdapter());
}
public void doDispatch() {
// 此处模拟SpringMVC从request取handler的对象,
// 适配器可以获取到希望的Controller
HttpController controller = new HttpController();
// AnnotationController controller = new AnnotationController();
//SimpleController controller = new SimpleController();
// 得到对应适配器
HandlerAdapter adapter = getHandler(controller);
// 通过适配器执行对应的controller对应方法
adapter.handle(controller);
}
public HandlerAdapter getHandler(Controller controller) {
//遍历:根据得到的controller(handler), 返回对应适配器
for (HandlerAdapter adapter : handlerAdapters) {
if (adapter.supports(controller)) {
return adapter;
}
}
return null;
}
public static void main(String[] args) {
new DispatchServlet().doDispatch(); // http...
}
}
package com.yk.__p64_064__适配器模式_Dispatcher源码_.springmvc;
///定义一个Adapter接口
public interface HandlerAdapter {
boolean supports(Object handler);
void handle(Object handler);
}
// 多种适配器类
class SimpleHandlerAdapter implements HandlerAdapter {
public void handle(Object handler) {
((SimpleController) handler).doSimplerHandler();
}
public boolean supports(Object handler) {
return (handler instanceof SimpleController);
}
}
class HttpHandlerAdapter implements HandlerAdapter {
public void handle(Object handler) {
((HttpController) handler).doHttpHandler();
}
public boolean supports(Object handler) {
return (handler instanceof HttpController);
}
}
class AnnotationHandlerAdapter implements HandlerAdapter {
public void handle(Object handler) {
((AnnotationController) handler).doAnnotationHandler();
}
public boolean supports(Object handler) {
return (handler instanceof AnnotationController);
}
}
65-065适配器模式-内容梳理
适配器模式的注意事项和细节
- 三种命名方式,是根据 src是以怎样的形式给到Adapter(在Adapter里的形式)来 命名的。
- 类适配器:以类给到,在Adapter里,就是将src当做类,继承 对象适配器:以对象给到,在Adapter里,将src作为一个对象,持有 接口适配器:以接口给到,在Adapter里,将src作为一个接口,实现
- Adapter模式最大的作用还是将原本不兼容的接口融合在一起工作。
- 实际开发中,实现起来不拘泥于上面三种经典形式
手机操作问题 现在对不同手机类型的不同品牌实现操作编程(比如:开机、关机、上网,打电话等),
传统方案解决手机使用问题(类图):
结构类图:
传统方案解决手机操作问题分析
- 扩展性问题(类爆炸), 如果我们再增加手机的样式(旋转式),就需要增加各个品 牌手机的类,同样如果我们增加一个手机品牌,也要在各个手机样式类下增加。
- 违反了单一职责原则,当我们增加手机样式时,要同时增加所有品牌的手机,这 样增加了代码维护成本.
- 解决方案-使用桥接模式
- 桥接模式(Bridge模式)是指:将实现与抽象放在两个不同的类层次中,使两个层次可以独立改变。
- 是一种结构型设计模式
- Bridge模式基于类的最小设计原则,通过使用封装、聚合及继承等行为让不同的类承担不同的职责。它的主要特点是把抽象(Abstraction)与行为实现(Implementation)分离开来,从而可以保持各部分的独立性以及应对他们的功能扩展
桥接模式核心要点: 处理多层继承结构,处理多维度变化的场景,将各个维度设计成独立的继承结构,使各个维度可以独立的扩展在抽象层建立关联。 上面对于具体的手机而言,有两个维度,一个是款式,一个是品牌,这两个维度可以相互组合成一个具体的手机。如果让它们从一个维度扩展,然后再向下扩展,则会如上图所示,类爆炸。 可以将这两个维度分开扩展,并且每个维度最好有一个抽象类,然后这两个维度聚合的时候,使用父类聚合,这样就不会出现一个维度A在扩展的时候,另一个维度B对应的所有值都需要扩展这个维度A的变化
桥接模式解决手机问题
桥接模式原理图:
68-068桥接模式(3)-手机问题解决不同样式不同品牌.新增样式品泡的问题
代码实现:
//接口
public interface Brand {
void open();
void close();
void call();
}
public class Vivo implements Brand {
@Override
public void open() {
// TODO Auto-generated method stub
System.out.println(" Vivo手机开机 ");
}
@Override
public void close() {
// TODO Auto-generated method stub
System.out.println(" Vivo手机关机 ");
}
@Override
public void call() {
// TODO Auto-generated method stub
System.out.println(" Vivo手机打电话 ");
}
}
public class XiaoMi implements Brand {
@Override
public void open() {
// TODO Auto-generated method stub
System.out.println(" 小米手机开机 ");
}
@Override
public void close() {
// TODO Auto-generated method stub
System.out.println(" 小米手机关机 ");
}
@Override
public void call() {
// TODO Auto-generated method stub
System.out.println(" 小米手机打电话 ");
}
}
public abstract class Phone {
//组合品牌
private final Brand brand;
//构造器
public Phone(Brand brand) {
super();
this.brand = brand;
}
protected void open() {
this.brand.open();
}
protected void close() {
brand.close();
}
protected void call() {
brand.call();
}
}
//折叠式手机类,继承 抽象类 Phone
public class FoldedPhone extends Phone {
//构造器
public FoldedPhone(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(" 折叠样式手机 ");
}
}
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(" 直立样式手机 ");
}
}
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();
}
}
从代码可以看到,有两个抽象类:Phone和Brand,分别表示手机款式和手机品牌,然后将Brand类作为属性聚合在Phone的类中。现在如果需要添加一个手机款式,直接写一个子类继承Phone即可,不用考虑品牌;同样的,如果需要添加一个手机品牌,直接写一个子类继承Brand即可,不用考虑手机款式。
把品牌组合到手机里面,这就是桥接模式 69-069桥接模式(4)-JDBC源码Jdbc 的 Driver接口,如果从桥接模式来看, Driver就是一个接口,下面可以有MySQL的Driver, Oracle的Driver,这些就可以当做实现接口类 在Java中通过Connection提供给各个数据库一样的操作接口,Connection可以看作抽象类。可以说用来操作不同数据库的方法都是相同的,不过MySQL有自己的ConnectionImpl类,同样Oracle也有对应的实现类。这里Driver和Connection之间是通过DriverManager类进行桥接的
70-070桥接模式(5)-内容梳理 桥接模式的注意事项和细节- 实现了抽象和实现部分的分离,从而极大的提供了系统的灵活性,让抽象部分和实现部分独立开来, 这有助于系统进行分层设计,从而产生更好的结构化系统。
- 对于系统的高层部分,只需要知道抽象部分和实现部分的接口就可以了,其它的部分由具体业务来完成。
- 桥接模式替代多层继承方案,可以减少子类的个数,降低系统的管理和维护成本。
- 桥接模式的引入增加了系统的理解和设计难度,由于聚合关联关系建立在抽象层,要求开发者针对抽象进行设计和编程
- 桥接模式要求正确识别出系统中两个独立变化的维度,因此其使用范围有一定的局限性,即需要有这样的应用场景。
- 对于那些不希望使用继承或因为多层次继承导致系统类的个数急剧增加的系统,桥接模式尤为适用
传统方法对应的类图:
桥接模式类图
解决了传统的类图庞大臃肿的问题
- 常见的应用场景:
- JDBC驱动程序
- 银行转账系统 转账分类: 网上转账,柜台转账, AMT转账 转账用户类型:普通用户,银卡用户,金卡用户…
- 消息管理 消息类型:即时消息,延时消息 消息分类: 手机短信,邮件消息, QQ消息
星巴克咖啡订单项目(咖啡馆):
- 咖啡种类/单品咖啡: Espresso(意大利浓咖啡)、 ShortBlack、 LongBlack(美式咖啡)、 Decaf(无因咖啡)
- 调料: Milk、 Soy(豆浆)、 Chocolate
- 要求在扩展新的咖啡种类时,具有良好的扩展性、改动方便、维护方便
- 使用OO的来计算不同种类咖啡的费用: 客户可以点单品咖啡,也可以单品咖啡+调料组合。
方案1-解决星巴克咖啡订单项目(较差的方案)
先定义个Drink抽象类,然后让所有的饮品都继承该类,并实现cost()方法和desc()方法,如果有饮品组合,也定义一个组合的新类。。。
方案1-解决星巴克咖啡订单问题分析
- Drink 是一个抽象类,表示饮料
- desc就是对咖啡的描述, 比如咖啡的名字
- cost() 方法就是计算费用, Drink 类中做成一个抽象方法.
- Decaf 就是单品咖啡, 继承Drink, 并实现cost
- Espress && Milk 就是单品咖啡+调料, 这个组合很多
- 问题:这样设计,会有很多类,当我们增加一个单品咖啡,或者一个新的调料,类的数量就会倍增,就会出现类爆炸。这近乎排列组合的形式编写类是不可行的方法
方案2-解决星巴克咖啡订单(好点)
- 前面分析到方案1因为咖啡单品+调料组合会造成类的倍增,因此可以做改进,将调料内置到Drink类,这样就不会造成类数量过多。从而提高项目的维护性
- 方案二就是将饮料和调料分开,然后让调料称为饮品的属性,就不会发生因排列组合而产生很多类
- 说明: milk,soy,chocolate 可以设计为Boolean,表示是否要添加相应的调料
方案2-的问题分析
- 方案2可以控制类的数量,不至于造成很多的类
- 考虑到用户可以添加多份 调料时,可以将调料的有无修改为调料的份数
- 在增加或者删除调料种类时,代码的维护量很大
- 调料价格改变时,需要改动现有代码
- 以后可能会开发出新饮料。对这些饮料而言(例如:冰茶),某些调料可能并不适合
- 一旦出现新的调料,我们就需要加上新的方法,并改变超类中的cost()方法。
- 装饰者模式: 动态的将新功能附加到对象上。在对象功能扩展方面,它比继承更有弹性,装饰者模式也体现了开闭原则(ocp)
- 装饰者模式就像打包一个快递 主体: 比如:陶瓷、衣服 (Component) // 被装饰者 包装:比如:报纸填充、塑料泡沫、纸板、木板(Decorator)
- Component 主体:比如类似前面的Drink
- ConcreteComponent和Decorator ConcreteComponent:具体的主体,比如前面的各个单品咖啡 Decorator: 装饰者,比如各调料.
- 在如图的Component与ConcreteComponent之间,如果ConcreteComponent类很多,还可以设计一个缓冲层,将共有的部分提取出来,抽象层一个类
类结构图
实际操作图示:
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();
}
public class Coffee extends Drink {
@Override
public float cost() {
return super.getPrice();
}
}
public class DeCaf extends Coffee {
public DeCaf() {
setDes(" 无因咖啡 ");
setPrice(1.0f);
}
}
public class Espresso extends Coffee {
public Espresso() {
setDes(" 意大利咖啡 ");
setPrice(6.0f);
}
}
public class Decorator extends Drink {
private final Drink obj;
public Decorator(Drink obj) { //组合
this.obj = obj;
}
@Override
public float cost() {
// getPrice 自己价格
return super.getPrice() + obj.cost();
}
@Override
public String getDes() {
// obj.getDes() 输出被装饰者的信息
return des + " " + getPrice() + " && " + obj.getDes();
}
}
//具体的Decorator, 这里就是调味品
public class Chocolate extends Decorator {
public Chocolate(Drink obj) {
super(obj);
setDes(" 巧克力 ");
setPrice(3.0f); // 调味品 的价格
}
}
public class Milk extends Decorator {
public Milk(Drink obj) {
super(obj);
setDes(" 牛奶 ");
setPrice(2.0f);
}
}
public class Soy extends Decorator {
public Soy(Drink obj) {
super(obj);
setDes(" 豆浆 ");
setPrice(1.5f);
}
}
public class CoffeeBar {
public static void main(String[] args) {
// 装饰者模式下的订单:2份巧克力+一份牛奶的无因咖啡
// 1. 点一份 无因咖啡
Drink order = new DeCaf();
System.out.println("order 无因咖啡 费用 =" + order2.cost());
System.out.println("order 无因咖啡 描述 = " + order2.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());
// 3. order 加入一份巧克力
order = new Chocolate(order);
System.out.println("order 加入一份牛奶 加入2份巧克力 费用 =" + order.cost());
System.out.println("order 加入一份牛奶 加入2份巧克力 描述 = " + order.getDes());
}
}
从上面的代码可以看出:
- 装饰者和被装饰对象有相同的超类型。
- 可以用一个或多个装饰者包装一个对象。
- 既然装饰者和被装饰对象有相同的超类型,所以在任何需要原始对象(被包装的)的场合,可以用装饰过的对象代替它。
- 装饰者可以在所委托被装饰者的行为之前与 / 或之后,加上自己的行为,以达到特定的目的。 对象可以在任何时候被装饰,所以可以在运行时动态地、不限量地用你喜欢的装饰者来装饰对象。
Java的IO结构, FilterInputStream就是一个装饰者
package java.io;
public class FilterInputStream extends InputStream {
protected volatile InputStream in;
protected FilterInputStream(InputStream in) {
this.in = in;
}
public int read() throws IOException {
return in.read();
}
public int read(byte[] b) throws IOException {
return read(b, 0, b.length);
}
public int read(byte[] b, int off, int len) throws IOException {
return in.read(b, off, len);
}
public long skip(long n) throws IOException {
return in.skip(n);
}
public int available() throws IOException {
return in.available();
}
public void close() throws IOException {
in.close();
}
public synchronized void mark(int readlimit) {
in.mark(readlimit);
}
public synchronized void reset() throws IOException {
in.reset();
}
public boolean markSupported() {
return in.markSupported();
}
}
从代码可以看出,这个类的写法就是一个装饰者
- //说明
- //1. Inputstream是抽象类,类似我们前面讲的 Drink
- //2.FileInputstream是 Inputstream子类,类似我们前面的 DeCaf, LongBlack
- //3. FilterInputstream是 Inputstream子类:类俱我们前面的 Decorator修饰者
- //4. DataInputstream是 FilterInputstream子类,具体的修饰者,类似前面的Milk,soy等
- //5.FilterInputstream类有 protected volatile Inputstream in;即含被装饰者
- //6.分析得出在jdk的io体系中,就是使用装饰者模式
看一个学校院系展示需求 编写程序展示一个学校院系结构:需求是这样,要在一个页面中展示出学校的院系 组成,一个学校有多个学院,一个学院有多个系
--------------清华大学-------------- --------------计算机学院-------------- 软件工程 网络工程 计算机科学与技术 --------------信息工程学院-------------- 通信工程 信息工程 --------------信息工程学院-------------- 通信工程 信息工程
传统方案解决学校院系展示 学校–> 学院–> 系
传统方案解决学校院系展示存在的问题分析
- 将学院看做是学校的子类,系是学院的子类,这样实际上是站在组织大小来进行分层次的
- 实际上我们的要求是 : 在一个页面中展示出学校的院系组成,一个学校有多个学院,一个学院有多个系, 因此这种方案,不能很好实现的管理的操作,比如对学院、系的添加,删除,遍历等
- 解决方案:把学校、院、系都看做是组织结构,他们之间没有继承的关系,而是一个树形结构,可以更好的实现管理操作。 => 组合模式
对原理结构图的说明-即(组合模式的角色及职责)
- Component:这是组合中对象声明接口,在适当情况下,实现所有类共有的接
口默认行为,用于访问和管理 Component子部件, Component可以是抽象类或者接口. - Leaf:在组合中表示叶子节点.没有子节点了(学院下面有系 系下面没有了)
- Composite:非叶子节点,用于存储部件.在Component实现子部件的操作.比如增加,删除.
1)组合模式解决这样的问题,当我们的要处理的对象可以生成一颗树形结构,而
我们要对树上的节点和叶子进行操作时,它能够提供一致的方式,而不用考虑
它是节点还是叶子
2)对应的示意图
78-078组合模式(2)-院校展示 组合模式基本介绍- 组合模式(Composite Pattern),又叫部分整体模式,它创建了对象组的树形结构,将对象组合成树状结构以表示“整体-部分”的层次关系。
- 组合模式依据树形结构来组合对象,用来表示部分以及整体层次。
- 这种类型的设计模式属于结构型模式。
- 组合模式使得用户对单个对象和组合对象的访问具有一致性, 即:组合能让客户以一致的方式处理个别对象以及组合对象
组合模式解决的问题
组合模式解决这样的问题,当我们的要处理的对象可以生成一颗树形结构,而 我们要对树上的节点和叶子进行操作时,它能够提供一致的方式,而不用考虑 它是节点还是叶子
组合模式解决学校院系展示的 应用实例
- 应用实例要求 编写程序展示一个学校院系结构:需求是这样,要在一个页面中展示出学校的院系组成,一个学校有多个学院,一个学院有多个系。
public abstract class OrganizationComponent {
private String name; // 名字
private String des; // 说明
protected void add(OrganizationComponent organizationComponent) {
//默认实现 叶子节点不支持添加的
throw new UnsupportedOperationException();
}
protected void remove(OrganizationComponent organizationComponent) {
//默认实现
throw new UnsupportedOperationException();
}
//构造器
public OrganizationComponent(String name, String des) {
super();
this.name = name;
this.des = des;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getDes() {
return des;
}
public void setDes(String des) {
this.des = des;
}
//方法print, 做成抽象的, 子类都需要实现
protected abstract void print();
}
import java.util.ArrayList;
import java.util.List;
public class University extends OrganizationComponent {
List organizationComponents = new ArrayList<>();
public University(String name, String des) {
super(name, des);
}
@Override
protected void add(OrganizationComponent organizationComponent) {
organizationComponents.add(organizationComponent);
}
@Override
protected void remove(OrganizationComponent organizationComponent) {
organizationComponents.remove(organizationComponent);
}
@Override
protected void print() {
System.out.println("--------------" + getName() + "------------");
//便利打印
organizationComponents.forEach(OrganizationComponent::print);
}
}
import java.util.ArrayList;
import java.util.List;
public class College extends OrganizationComponent {
//List 中 存放的Department
List organizationComponents = new ArrayList();
// 构造器
public College(String name, String des) {
super(name, des);
}
// 重写add
@Override
protected void add(OrganizationComponent organizationComponent) {
// 将来实际业务中,Colleage 的 add 和 University add 不一定完全一样
organizationComponents.add(organizationComponent);
}
// 重写remove
@Override
protected void remove(OrganizationComponent organizationComponent) {
organizationComponents.remove(organizationComponent);
}
@Override
public String getName() {
return super.getName();
}
@Override
public String getDes() {
return super.getDes();
}
// print方法,就是输出University 包含的学院
@Override
protected void print() {
System.out.println("--------------" + getName() + "--------------");
organizationComponents.forEach(OrganizationComponent::print);
}
}
public class Department extends OrganizationComponent {
//没有集合
public Department(String name, String des) {
super(name, des);
}
//add , remove 就不用写了,因为他是叶子节点
@Override
public String getName() {
return super.getName();
}
@Override
public String getDes() {
return super.getDes();
}
@Override
protected void print() {
System.out.println(getName());
}
}
public class Client {
public static void main(String[] args) {
//从大到小创建对象 学校
OrganizationComponent university = new University("清华大学", " 中国顶级大学 ");
//创建 学院
OrganizationComponent computerCollege = new College("计算机学院", " 计算机学院 ");
OrganizationComponent infoEngineercollege = new College("信息工程学院", " 信息工程学院 ");
//创建各个学院下面的系(专业)
computerCollege.add(new Department("软件工程", " 软件工程不错 "));
computerCollege.add(new Department("网络工程", " 网络工程不错 "));
computerCollege.add(new Department("计算机科学与技术", " 计算机科学与技术是老牌的专业 "));
//
infoEngineercollege.add(new Department("通信工程", " 通信工程不好学 "));
infoEngineercollege.add(new Department("信息工程", " 信息工程好学 "));
//将学院加入到 学校
university.add(computerCollege);
university.add(infoEngineercollege);
university.print();
//
// university.print();
// infoEngineercollege.print();
}
}
79-079组合模式(3)-HashMap源码
import cn.hutool.json.JSONUtil;
import java.util.HashMap;
import java.util.Map;
public class Main {
public static void main(String[] args) {
Map map = new HashMap<>();
map.put(1, "西游记");
Map map1 = new HashMap<>();
map1.put(2, "红楼梦");
map1.put(3, "三国志");
map.putAll(map1);
System.out.println(JSONUtil.toJsonStr(map));
}
}
80-080组合模式(4)-内容梳理
组合模式的注意事项和细节
- 简化客户端操作。客户端只需要面对一致的对象而不用考虑整体部分或者节点叶子 的问题。
- 具有较强的扩展性。当我们要更改组合对象时,我们只需要调整内部的层次关系, 客户端不用做出任何改动.
- 方便创建出复杂的层次结构。客户端不用理会组合里面的组成细节,容易添加节点 或者叶子从而创建出复杂的树形结构
- 需要遍历组织机构,或者处理的对象具有树形结构时, 非常适合使用组合模式.
- 要求较高的抽象性,如果节点和叶子有很多差异性的话,比如很多方法和属性都不一样, 不适合使用组合模式
影院管理项目,组建一个家庭影院: DVD播放器、投影仪、自动屏幕、环绕立体声、爆米花机,要求完成使用家庭影院的功能,其过程为:
- 直接用遥控器:统筹各设备开关
- 开爆米花机
- 放下屏幕
- 开投影仪
- 开音响
- 开DVD,选dvd
- 去拿爆米花
- 调暗灯光
- 播放
- 观影结束后,关闭各种设备
传统方式解决影院管理
(每个设备都有遥控器,没个都要点一下很累,需要一件开关)
ClientTest {
public static void main() {
//1. 创建相关的对象
//2. 调用创建的各个对象的一系列方法
// 3. 调用DVDPlayer 对象的play方法
}
}
传统方式解决影院管理问题分析
- 在ClientTest 的main方法中,创建各个子系统的对象,并直接去调用子系统(对象)相关方法,会造成调用过程混乱,没有清晰的过程
- 不利于在ClientTest 中,去维护对子系统的操作
- 解决思路: 定义一个高层接口,给子系统中的一组接口提供一个一致的界面(比如在高层接口提供四个方法 ready, play, pause, end ),用来访问子系统中的一群接口
- 也就是说 就是通过定义一个一致的接口(界面类), 用以屏蔽内部子系统的细节,使得调用端只需跟这个接口发生调用,而无需关心这个子系统的内部细节 => 外观模式.
- 外观模式(Facade), 也叫“过程模式:外观模式为子系统中的一组接口提供一个一致的界面,此模式定义了一个高层接口,这个接口使得这一子系统更加容易使用
- 外观模式通过定义一个一致的接口,用以屏蔽内部子系统的细节,使得调用端只需跟这个接口发生调用,而无需关心这个子系统的内部细节
- 外观类(Facade): 为调用端提供统一的调用接口, 外观类知道哪些子系统负责处理请求,从而将调用端的请求理给适当子系统对象
- 调用者(Client): 外观接口的调用者
- 子系统的集合:指模块或者子系统,处理Facade 对象指派的任务,他是功能的实际提供者
- 外观模式可以理解为转换一群接口,客户只要调用一个接口,而不用调用多个接口才能达到目的。 比如:在pc上安装软件的时候经常有一键安装选项(省去选择安装目录、安装的组件等等),还有就是手机的重启功能(把关机和启动合为一个操作)。
- 外观模式就是解决多个复杂接口带来的使用困难,起到简化用户操作的作用
外观模式应用实例
- 应用实例要求 使用外观模式来完成家庭影院项目
public class DVDPlayer {
//使用单例模式, 使用饿汉式
private static final DVDPlayer instance = new DVDPlayer();
public static DVDPlayer getInstance() {
return instance;
}
public void on() {
System.out.println(" dvd on ");
}
public void off() {
System.out.println(" dvd off ");
}
public void play() {
System.out.println(" dvd is playing ");
}
public void pause() {
System.out.println(" dvd pause ..");
}
}
public class Popcorn {
private static final Popcorn instance = new Popcorn();
public static Popcorn getInstance() {
return instance;
}
public void on() {
System.out.println(" popcorn on ");
}
public void off() {
System.out.println(" popcorn ff ");
}
public void pop() {
System.out.println(" popcorn is poping ");
}
}
public class Projector {
private static final Projector instance = new Projector();
public static Projector getInstance() {
return instance;
}
public void on() {
System.out.println(" Projector on ");
}
public void off() {
System.out.println(" Projector ff ");
}
public void focus() {
System.out.println(" Projector is Projector ");
}
//...
}
public class Screen {
private static final Screen instance = new Screen();
public static Screen getInstance() {
return instance;
}
public void up() {
System.out.println(" Screen up ");
}
public void down() {
System.out.println(" Screen down ");
}
}
public class Stereo {
private static final Stereo instance = new Stereo();
public static Stereo getInstance() {
return instance;
}
public void on() {
System.out.println(" Stereo on ");
}
public void off() {
System.out.println(" Screen off ");
}
public void up() {
System.out.println(" Screen up.. ");
}
}
public class TheaterLight {
private static final TheaterLight instance = new TheaterLight();
public static TheaterLight getInstance() {
return instance;
}
public void on() {
System.out.println(" TheaterLight on ");
}
public void off() {
System.out.println(" TheaterLight off ");
}
public void dim() {
System.out.println(" TheaterLight dim.. ");
}
public void bright() {
System.out.println(" TheaterLight bright.. ");
}
}
public class HomeTheaterFacade {
//定义各个子系统对象
private final TheaterLight theaterLight;
private final Popcorn popcorn;
private final Stereo stereo;
private final Projector projector;
private final Screen screen;
private final DVDPlayer dVDPlayer;
//构造器
public HomeTheaterFacade() {
super();
this.theaterLight = TheaterLight.getInstance();
this.popcorn = Popcorn.getInstance();
this.stereo = Stereo.getInstance();
this.projector = Projector.getInstance();
this.screen = Screen.getInstance();
this.dVDPlayer = DVDPlayer.getInstance();
}
//操作分成 4 步
public void ready() {
popcorn.on();
popcorn.pop();
screen.down();
projector.on();
stereo.on();
dVDPlayer.on();
theaterLight.dim();
}
public void play() {
dVDPlayer.play();
}
public void pause() {
dVDPlayer.pause();
}
public void end() {
popcorn.off();
theaterLight.bright();
screen.up();
projector.off();
stereo.off();
dVDPlayer.off();
}
}
public class Client {
public static void main(String[] args) {
// TODO Auto-generated method stub
//这里直接调用。。 很麻烦
HomeTheaterFacade homeTheaterFacade = new HomeTheaterFacade();
homeTheaterFacade.ready();
homeTheaterFacade.play();
homeTheaterFacade.end();
}
}
84-084外观模式(4)-MyBatis源码
外观模式在MyBatis框架应用的源码分析
- MyBatis 中的Configuration 去创建MetaObject 对象使用到外观模式
- 外观模式对外屏蔽了子系统的细节,因此外观模式降低了客户端对子系统使用的复杂性
- 外观模式对客户端与子系统的耦合关系,让子系统内部的模块更易维护和扩展
- 通过合理的使用外观模式,可以帮我们更好的划分访问的层次
- 当系统需要进行分层设计时, 可以考虑使用Facade模式
- 在维护一个遗留的大型系统时,可能这个系统已经变得非常难以维护和扩展,此时可以考虑为新系统开发一个Facade类,来提供遗留系统的比较清晰简单的接口,让新系统与Facade类交互, 提高复用性
- 不能过多的或者不合理的使用外观模式,使用外观模式好, 还是直接调用模块好。要以让系统有层次,利于维护为目的。
展示网站项目需求 小型的外包项目,给客户A做一个产品展示网站, 客户A的朋友感觉效果不错,也希 望做这样的产品展示网站,但是要求都有些不同:
- 有客户要求以新闻的形式发布
- 有客户人要求以博客的形式发布
- 有客户希望以微信公众号的形式发布
传统方案解决网站展现项目
- 直接复制粘贴一份,然后根据客户不同要求,进行定制修改
- 给每个网站租用一个空间
传统方案解决网站展现项目-问题分析
- 需要的网站结构相似度很高,而且都不是高访问量网站,如果分成多个虚拟空间来处理,相当于一个相同网站的实例对象很多,造成服务器的资源浪费
- 解决思路:整合到一个网站中,共享其相关的代码和数据,对于硬盘、内存、 CPU、数据库空间等服务器资源都可以达成共享,减少服务器资源
- 对于代码来说, 由于是一份实例,维护和扩展都更加容易
- 上面的解决思路就可以使用 享元模式 来解决
- 享元模式(Flyweight Pattern) 也叫 蝇量模式: 运用共享技术有效地支持大量细粒度的对象
- 常用于系统底层开发,解决系统的性能问题。像数据库连接池,里面都是创建好的连接对象,在这些连接对象中有我们需要的则直接拿来用,避免重新创建, 如果没有我们需要的,则创建一个
- 享元模式能够解决重复对象的内存浪费的问题,当系统中有大量相似对象,需要缓冲池时。 不需总是创建新对象,可以从缓冲池里拿。这样可以降低系统内存,同时提高效率
- 享元模式经典的应用场景就是池技术了, String常量池、数据库连接池、缓冲池等等都是享元模式的应用,享元模式是池技术的重要实现方式
对原理图的说明-即(模式的角色及职责)
- FlyWeight是抽象的享元角色,他是产品的抽象类,同时定义出对象的外部状态和内部状态(后面介绍)的接口 或实现
- ConcreteFlyWeight是具体的享元角色,是具体的产品类,实现抽象角色定义相关业务
- UnSharedConcreteFlyWeight是不可共享的角色,一般不会出现在享元工厂。
- FlyWeightFactory享元工厂类,使用内置一个池容器(集合),同时提供从池中获取对象方法
比如围棋、五子棋、跳棋,它们都有大量的棋子对象,围棋和五子棋只有黑白两色,跳棋颜色多一 点,所以棋子颜色就是棋子的内部状态;而各个棋子之间的差别就是位置的不同,当我们落子后, 落子颜色是定的,但位置是变化的,所以棋子坐标就是棋子的外部状态(能共享的就是颜色,不能共享的就是位置)
- 享元模式提出了两个要求:细粒度和共享对象。这里就涉及到内部状态和外部状态了,即将对象的信息分为两个部分: 内部状态和外部状态
- 内部状态指对象共享出来的信息,存储在享元对象内部且不会随环境的改变而改变
- 外部状态指对象得以依赖的一个标记,是随环境改变而改变的、不可共享的状态。
- 举个例子:围棋理论上有361个空位可以放棋子,每盘棋都有可能有两三百个棋子对象产生,因为内存空间有限,一台服务器很难支持更多的玩家玩围棋游戏,如果用享元模式来处理棋子,那么棋子对象就可以减少到只有两个实例,这样就很好的解决了对象的开销问题.
享元模式应用实例
- 应用实例要求 使用享元模式完成, 前面提出的网站外包问题
- 代码实现
public abstract class WebSite {
public abstract void use(User user);//抽象方法
}
//具体网站
public class ConcreteWebSite extends WebSite {
//共享的部分,内部状态
private String type = ""; //网站发布的形式(类型)
//构造器
public ConcreteWebSite(String type) {
this.type = type;
}
@Override
public void use(User user) {
System.out.println("网站的发布形式为:" + type + " 在使用中 .. 使用者是" + user.getName());
}
}
import java.util.HashMap;
// 网站工厂类,根据需要返回压一个网站
public class WebSiteFactory {
//集合, 充当池的作用
private final HashMap pool = new HashMap<>();
//根据网站的类型,返回一个网站, 如果没有就创建一个网站,并放入到池中,并返回
public WebSite getWebSiteCategory(String type) {
if (!pool.containsKey(type)) {
//就创建一个网站,并放入到池中
pool.put(type, new ConcreteWebSite(type));
}
return (WebSite) pool.get(type);
}
//获取网站分类的总数 (池中有多少个网站类型)
public int getWebSiteCount() {
return pool.size();
}
}
public class User {
private String name;
public User(String name) {
super();
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
public class Client {
public static void main(String[] args) {
// 创建一个工厂类
WebSiteFactory factory = new WebSiteFactory();
// 客户要一个以新闻形式发布的网站
WebSite webSite1 = factory.getWebSiteCategory("新闻");
webSite1.use(new User("tom"));
// 客户要一个以博客形式发布的网站
WebSite webSite2 = factory.getWebSiteCategory("博客");
webSite2.use(new User("jack"));
// 客户要一个以博客形式发布的网站
WebSite webSite3 = factory.getWebSiteCategory("博客");
webSite3.use(new User("smith"));
// 客户要一个以博客形式发布的网站
WebSite webSite4 = factory.getWebSiteCategory("博客");
webSite4.use(new User("king"));
System.out.println("网站的分类共=" + factory.getWebSiteCount());
}
}
89-089享元模式(4)-Integer源码
享元模式在Integer的应用
Integer将0-127之间的数据进行了缓存,将这些数据共享
//如果Integer.valueOf(x)x在-128–127直接,就是使用享元模式返回,如果不在范围内,则仍然new
90-090享元模式(5)-内容梳理 享元模式的注意事项和细节- 在享元模式这样理解,“享”就表示共享,“元”表示对象
- 系统中有大量对象, 这些对象消耗大量内存, 并且对象的状态大部分可以外部化时,我们就可以考虑选用享元模式
- 用唯一标识码判断,如果在内存中有,则返回这个唯一标识码所标识的对象,用HashMap/HashTable存储
- 享元模式大大减少了对象的创建,降低了程序内存的占用,提高效率
- 享元模式提高了系统的复杂度。需要分离出内部状态和外部状态,而外部状态具有固化特性,不应该随着内部状态的改变而改变,这是我们使用享元模式需要注意的地方
- 使用享元模式时,注意划分内部状态和外部状态,并且需要有一个工厂类加以控制。
- 享元模式经典的应用场景是需要缓冲池的场景,比如 String常量池、 数据库连接池
- 代理模式:为一个对象提供一个替身,以控制对这个对象的访问。 即通过代理对象访问目标对象.这样做的好处是:可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能。
- 被代理的对象可以是远程对象、 创建开销大的对象或需要安全控制的对象
- 代理模式有不同的形式, 主要有三种 静态代理、 动态代理 (JDK代理、接口代理)和 Cglib代理 (可以在内存动态的创建对象,而不需要实现接口, 他是属于动态代理的范畴) 。
静态代理在使用时,需要定义接口或者父类,被代理对象(即目标对象)与代理对象一起实现相同的接口或者是继承相同父类
应用实例
- 定义一个被代理类的父接口Person
- 目标对象Student实现接口Person
- 使用静态代理方式,就需要在代理对象StudentProxy中也实现Person
- 调用的时候通过调用代理对象的方法来调用目标对象
- 特别提醒:代理对象与目标对象要实现相同的接口,然后通过调用相同的方法来 调用目标对象的方法。
代码实现
package com.yk.__p92_092_尚硅谷_代理模式_2__静态代理_;
public class ProxyTest {
public static void main(String[] args) {
TeacherDao target = new TeacherDao();
TeacherDaoProxy teacherDaoProxy = new TeacherDaoProxy(target);
teacherDaoProxy.teach();
}
}
interface ITeacherDao{
void teach();
}
class TeacherDao implements ITeacherDao{
@Override
public void teach() {
System.out.println("老师正在上课");
}
}
//代理对象,静态代理
class TeacherDaoProxy implements ITeacherDao{
ITeacherDao target; //目标对象,通过接口来聚合
public TeacherDaoProxy(ITeacherDao target) {
this.target = target;
}
@Override
public void teach() {
System.out.println("代理开始");
target.teach();
System.out.println("代理结束");
}
}
静态代理优缺点
- 优点:在不修改目标对象的功能前提下, 能通过代理对象对目标功能扩展
- 缺点:因为代理对象需要与目标对象实现一样的接口,所以会有很多代理类
- 缺点: 一旦接口增加方法,目标对象与代理对象都要维护
动态代理模式的基本介绍
- 代理对象,不需要实现接口, 但是目标对象要实现接口, 否则不能用动态代理
- 代理对象的生成, 是利用JDK的API,动态的在内存中构建代理对象
- 动态代理也叫做: JDK代理、 接口代理
-
代理类所在包:java.lang.reflect.Proxy
-
JDK实现代理只需要使用newProxyInstance方法,但是该方法需要接收三个参数,完整的写法是:
static Object newProxyInstance(ClassLoader loader, Class>[] interfaces,InvocationHandler h )
- ClassLoader loader:指定当前目标对象使用的类加载器, 获取加载器的方法固定
- Class>[] interfaces:目标对象实现的接口类型,使用泛型方法确认类型
- InvocationHandler h:事情处理,执行目标对象的方法时,会触发事情处理器方法, 会把当前执行的目标对象方法作为参数传入
package com.yk.__p93_093_尚硅谷_代理模式_3__动态代理_;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class ProxyTest {
public static void main(String[] args) {
TeacherDao teacherDao = new TeacherDao();
ProxyFactory proxyFactory = new ProxyFactory(teacherDao);
ITeacherDao proxyInstance = (ITeacherDao) proxyFactory.getProxyInstance();
System.out.println("proxyInstance = " + proxyInstance.getClass());
proxyInstance.teach();
}
}
interface ITeacherDao{
void teach();
}
class TeacherDao implements ITeacherDao{
@Override
public void teach() {
System.out.println("老师正在授课");
}
}
class ProxyFactory {
//维护一个目标对象
Object target;
public ProxyFactory(Object target) {
this.target = target;
}
// 给目标对象生成代理对象
public Object getProxyInstance() {
//1.classLoader loader:指定当前目标对象使用的类加载器,获取加载器的方法固定
// 2.C1ass[] interfaces:目标对象实现的接口类型,使用泛型方法确认类型
//3. InvpcationHandler h:事情处理,执行目标对象的方法时,会触发事情处理器方法
return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("动态代理开始");
Object invoke = method.invoke(target, args);
System.out.println("动态代理结束");
return invoke;
}
});
}
}
94-094代理模式(4)-Cglib代理
cglib代理模式的基本介绍
- 静态代理和JDK代理模式都要求目标对象是实现一个接口,但是有时候目标对象只是一个单独的对象,**并没有实现任何的接口,**这个时候可使用目标对象子类来实现代理-这就是cglib代理
- cglib代理也叫作子类代理,它是在内存中构建一个子类对象从而实现对目标对象功能扩展, 有些书也将cglib代理归属到动态代理。
- cglib是一个强大的高性能的代码生成包,它可以在运行期扩展java类与实现java接口。它广泛的被许多AOP的框架使用,例如Spring AOP, 实现方法拦截
- 在AOP编程中如何选择代理模式:
- 目标对象需要实现接口, 用JDK代理
- 目标对象不需要实现接口, 用Cglib代理
- cglib包的底层是通过使用字节码处理框架ASM来转换字节码并生成新的类
cglib代理模式实现步骤
- 需要引入cglib的jar文件
- 在内存中动态构建子类, 注意代理的类不能为final,否则报错java.lang.IllegalArgumentException
- 目标对象的方法如果为final/static,那么就不会被拦截,即不会执行目标对象额外的业务方法
cglib代理模式应用实例
导入maven
cglib cglib 3.3.0
package com.yk.__p94_094_尚硅谷_代理模式_4__Cglib代理_;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class ProxyTest {
public static void main(String[] args) {
TeacherDao teacherDao = new TeacherDao();
ProxyFactory proxyFactory = new ProxyFactory(teacherDao);
TeacherDao proxyInstance = (TeacherDao) proxyFactory.getProxyInstance();
proxyInstance.teach();
}
}
interface ITeacherDao {
void teach();
}
class TeacherDao implements ITeacherDao {
@Override
public void teach() {
System.out.println("cglib老师正在授课");
}
}
class ProxyFactory implements MethodInterceptor {
Object target;
public ProxyFactory(Object target) {
this.target = target;
}
public Object getProxyInstance() {
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(target.getClass());
//设置回调函数
enhancer.setCallback(this);
return enhancer.create();
}
@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
System.out.println("cglib开始");
Object invoke = method.invoke(target, args);
System.out.println("cglib结束");
return invoke;
}
}
95-095代理模式(5)-几种变体
代理模式(Proxy)的变体
- 防火墙代理 内网通过代理穿透防火墙,实现对公网的访问。
- 缓存代理 比如:当请求图片文件等资源时,先到缓存代理取,如果取到资源则ok,如果取不到资源,再到公网或者数据库取,然后缓存。
- 远程代理 远程对象的本地代表,通过它可以把远程对象当本地对象来调用。远程代理通过网络和真正的远程对象沟通信息。
- 同步代理: 主要使用在多线程编程中,完成多线程间同步工作
编写制作豆浆的程序,说明如下:
- 制作豆浆的流程 选材—>添加配料—>浸泡—>放到豆浆机打碎
- 通过添加不同的配料,可以制作出不同口味的豆浆
- 选材、浸泡和放到豆浆机打碎这几个步骤对于制作每种口味的豆浆都是一样的
- 请使用 模板方法模式 完成 (说明: 因为模板方法模式,比较简单, 很容易就 想到这个方案,因此就直接使用, 不再使用传统的方案来引出模板方法模式 )
- 模板方法模式(Template Method Pattern),又叫模板模式(Template Pattern),在一个抽象类公开定义了执行它的方法的模板。它的子类可以按需要重写方法实现,但调用将以抽象类中定义的方式进行。
- 简单说, 模板方法模式 定义一个操作中的算法的骨架,而将一些步骤延迟到子 类中,使得子类可以不改变一个算法的结构,就可以重定义该算法的某些特定 步骤
- 这种类型的设计模式属于行为型模式。
模板方法模式的原理类图 对原理类图的说明-即(模板方法模式的角色及职责)
- AbstractClass 抽象类, 类中实现了模板方法(template),定义了算法的骨架,具体子类需要去实现 其它的抽象方法operationr2,3,4
- ConcreteClass 实现抽象方法operationr2,3,4, 以完成算法中特点子类的步骤
模板方法模式解决豆浆制作问题
package com.yk.__p97_097_尚硅谷_模板模式_2__豆浆制作_;
//抽象类,表示豆浆
public abstract class SoyaMilk {
//模板方法, make , 模板方法可以做成final , 不让子类去覆盖.
final void make() {
select();
addCondiments();
soak();
beat();
}
//选材料
void select() {
System.out.println("第一步:选择好的新鲜黄豆 ");
}
//添加不同的配料, 抽象方法, 子类具体实现
abstract void addCondiments();
//浸泡
void soak() {
System.out.println("第三步, 黄豆和配料开始浸泡, 需要3小时 ");
}
void beat() {
System.out.println("第四步:黄豆和配料放到豆浆机去打碎 ");
}
}
package com.yk.__p97_097_尚硅谷_模板模式_2__豆浆制作_;
public class RedBeanSoyaMilk extends SoyaMilk {
@Override
void addCondiments() {
System.out.println(" 加入上好的红豆 ");
}
}
package com.yk.__p97_097_尚硅谷_模板模式_2__豆浆制作_;
public class PeanutSoyaMilk extends SoyaMilk {
@Override
void addCondiments() {
System.out.println(" 加入上好的花生 ");
}
}
package com.yk.__p97_097_尚硅谷_模板模式_2__豆浆制作_;
public class Client {
public static void main(String[] args) {
//制作红豆豆浆
System.out.println("----制作红豆豆浆----");
SoyaMilk redBeanSoyaMilk = new RedBeanSoyaMilk();
redBeanSoyaMilk.make();
System.out.println("----制作花生豆浆----");
SoyaMilk peanutSoyaMilk = new PeanutSoyaMilk();
peanutSoyaMilk.make();
}
}
98-098模板模式(3)-钩子方法
模板方法模式的钩子方法
1)在模板方法模式的父类中,我们可以定义一个方法,它默认不做任何事,子类可以视情况要覆盖它,该方法称为“钩子”
2)还是用上面做豆浆的例子来讲解,比如,我们还希望制作纯豆浆,不添加任何的配料,请使用钩子方法对前面的模板方法进行改造
package com.yk.__p98_098_尚硅谷_模板模式_3__钩子方法_;
//抽象类,表示豆浆
public abstract class SoyaMilk {
//模板方法, make , 模板方法可以做成final , 不让子类去覆盖.
final void make() {
select();
if (hasCondiments()) {
addCondiments();
}
soak();
beat();
}
//选材料
void select() {
System.out.println("第一步:选择好的新鲜黄豆 ");
}
//添加不同的配料, 抽象方法, 子类具体实现
abstract void addCondiments();
//浸泡
void soak() {
System.out.println("第三步, 黄豆和配料开始浸泡, 需要3小时 ");
}
void beat() {
System.out.println("第四步:黄豆和配料放到豆浆机去打碎 ");
}
//钩子方法
boolean hasCondiments() {
return true;
}
}
package com.yk.__p98_098_尚硅谷_模板模式_3__钩子方法_;
public class PureSoyaMilk extends SoyaMilk{
@Override
void addCondiments() {
}
@Override
boolean hasCondiments() {
return false;
}
}
package com.yk.__p98_098_尚硅谷_模板模式_3__钩子方法_;
public class Client {
public static void main(String[] args) {
//制作红豆豆浆
System.out.println("----制作红豆豆浆----");
SoyaMilk redBeanSoyaMilk = new RedBeanSoyaMilk();
redBeanSoyaMilk.make();
System.out.println("----制作花生豆浆----");
SoyaMilk peanutSoyaMilk = new PeanutSoyaMilk();
peanutSoyaMilk.make();
System.out.println("----制作纯豆浆----");
PureSoyaMilk pureSoyaMilk = new PureSoyaMilk();
pureSoyaMilk.make();
}
}
99-099模板模式(4)-IOC源码
Spring IOC实现的AbstractApplicationContext中实现了许多空方法
AbstractApplicationContext.refresh方法里面很多
100-100模板模式(5)-细节说明 模板方法模式的注意事项和细节- 基本思想是: **算法只存在于一个地方,也就是在父类中,**容易修改。 需要修改算法时,只要修改父类的模板方法或者已经实现的某些步骤,子类就会继承这些修改
- 实现了最大化代码复用。 父类的模板方法和已实现的某些步骤会被子类继承而直接使用。
- 既统一了算法,也提供了很大的灵活性。 父类的模板方法确保了算法的结构保持不变,同时由子类提供部分步骤的实现。
- 该模式的不足之处:每一个不同的实现都需要一个子类实现,导致类的个数增加,使得系统更加庞大
- 一般模板方法都加上final关键字, 防止子类重写模板方法
- 模板方法模式使用场景: 当要完成在某个过程,该过程要执行一系列步骤,这一系列的步骤基本相同,但其个别步骤在实现时可能不同,通常考虑用模板方法模式来处理



