[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"\u002Fresource\u002Fdocument\u002Flist?undefined":3,"\u002Fresource\u002Fdocument\u002Fquery\u002Fi1msql1k8y70etey?undefined":462,"\u002Fresource\u002Fadvertise\u002Flist?type=all?undefined":465},{"data":4,"status":460,"success":461},[5,148,202,291,332,370,420],{"books":6,"desc":145,"id":8,"image":146,"title":147},[7,40,63,78,93,105,117],{"cateId":8,"chapters":9,"desc":36,"id":11,"time":37,"title":38,"video":39},1,[10,15,18,21,24,27,30,33],{"bookId":11,"id":12,"indexOrder":13,"name":14},24,"8egfulw98v3h680j",0,"JavaSE 笔记（一）走进Java语言",{"bookId":11,"id":16,"indexOrder":13,"name":17},"pew6po6wrou23pk3","JavaSE 笔记（二）面向过程编程",{"bookId":11,"id":19,"indexOrder":13,"name":20},"eldst1fgrbdkmfs7","JavaSE 笔记（三）面向对象基础",{"bookId":11,"id":22,"indexOrder":13,"name":23},"48zphgkpjto8cath","JavaSE 笔记（四）面向对象高级篇",{"bookId":11,"id":25,"indexOrder":13,"name":26},"6r4llai92yc15j98","JavaSE 笔记（五）泛型程序设计",{"bookId":11,"id":28,"indexOrder":13,"name":29},"k6fmxd6qabgkwm9i","JavaSE 笔记（六）集合类与IO",{"bookId":11,"id":31,"indexOrder":13,"name":32},"qrd0xfttsz32gpqg","JavaSE 笔记（七）多线程与反射",{"bookId":11,"id":34,"indexOrder":13,"name":35},"td5tgn04nqmkrryt","JavaSE 笔记（八）GUI程序开发","基于Java25全新录制的SE课程",2025,"JavaSE 核心内容","https:\u002F\u002Fwww.bilibili.com\u002Fvideo\u002FBV163GGz2E8c",{"cateId":8,"chapters":41,"desc":59,"id":8,"time":60,"title":61,"video":62},[42,44,46,49,51,53,55,57],{"bookId":8,"id":43,"indexOrder":13,"name":14},"ibeeuwsbbi00undq",{"bookId":8,"id":45,"indexOrder":13,"name":17},"dncxjecdv4wciqcp",{"bookId":8,"id":47,"indexOrder":13,"name":48},"jviyz2hsht9ete5k","JavaSE 笔记（三）面向对象基础篇",{"bookId":8,"id":50,"indexOrder":13,"name":23},"qb9i6q9fap7bg1cc",{"bookId":8,"id":52,"indexOrder":13,"name":26},"hnkrjrkm3hjzeq6s",{"bookId":8,"id":54,"indexOrder":13,"name":29},"erpm32wduoaaqmrx",{"bookId":8,"id":56,"indexOrder":13,"name":32},"lfqtvxr7azumcwja",{"bookId":8,"id":58,"indexOrder":13,"name":35},"qs7gqok56gzc6idr","2022年制作的JavaSE版本",2022,"JavaSE 22年旧版","https:\u002F\u002Fwww.bilibili.com\u002Fvideo\u002FBV1YP4y1o75f\u002F",{"cateId":8,"chapters":64,"desc":75,"id":66,"time":60,"title":76,"video":77},[65,69,72],{"bookId":66,"id":67,"indexOrder":13,"name":68},2,"g96k66kczovvbm1i","JVM 笔记（一）走进JVM",{"bookId":66,"id":70,"indexOrder":13,"name":71},"ydd7n3jg8unc3clg","JVM 笔记（二）内存管理",{"bookId":66,"id":73,"indexOrder":13,"name":74},"r9dq37de0kaeauoi","JVM 笔记（三）类与类加载","了解Java的底层运作机制","Java JVM 虚拟机","https:\u002F\u002Fwww.bilibili.com\u002Fvideo\u002FBV1Er4y1r7as\u002F",{"cateId":8,"chapters":79,"desc":90,"id":81,"time":60,"title":91,"video":92},[80,84,87],{"bookId":81,"id":82,"indexOrder":13,"name":83},3,"asncyye9ya18gfar","JUC 笔记（一）再谈多线程",{"bookId":81,"id":85,"indexOrder":13,"name":86},"5tr1sm4ho6ygpt9q","JUC 笔记（二）并发编程核心",{"bookId":81,"id":88,"indexOrder":13,"name":89},"1scf51z5300mzxkh","JUC 笔记（三）并发编程进阶","你也可以成为多线程的主宰者","Java JUC 并发编程","https:\u002F\u002Fwww.bilibili.com\u002Fvideo\u002FBV1JT4y1S7K8\u002F",{"cateId":8,"chapters":94,"desc":102,"id":96,"time":60,"title":103,"video":104},[95,99],{"bookId":96,"id":97,"indexOrder":13,"name":98},4,"eedesc445ygiqhil","NIO 笔记（一）基础内容",{"bookId":96,"id":100,"indexOrder":13,"name":101},"ndz9t0uunrmfmv4n","NIO 笔记（二）Netty框架专题","编写畅快的高性能网络服务器","Java NIO 网络编程","https:\u002F\u002Fwww.bilibili.com\u002Fvideo\u002FBV1ar4y1J7mC\u002F",{"cateId":8,"chapters":106,"desc":114,"id":108,"time":60,"title":115,"video":116},[107,111],{"bookId":108,"id":109,"indexOrder":13,"name":110},5,"9890i8ofuadpwy2b","[扩展篇] Java 9-17新特性介绍",{"bookId":108,"id":112,"indexOrder":13,"name":113},"tsrkqvb6zpmtwh0n","[扩展篇] JavaSE关键字总结 笔记","精彩仍在继续，不要停止脚步","其他内容","https:\u002F\u002Fwww.bilibili.com\u002Fvideo\u002FBV1tU4y1y7Fg\u002F",{"cateId":8,"chapters":118,"desc":141,"id":120,"time":142,"title":143,"video":144},[119,123,126,129,132,135,138],{"bookId":120,"id":121,"indexOrder":13,"name":122},6,"4db9h32opv7imszh","JavaSE 笔记（一）面向过程编程",{"bookId":120,"id":124,"indexOrder":13,"name":125},"c93u3v37br7hgn1q","JavaSE 笔记（二）面向对象基础篇",{"bookId":120,"id":127,"indexOrder":13,"name":128},"yglsjde9gi1jxkcb","JavaSE 笔记（三）泛型与集合类",{"bookId":120,"id":130,"indexOrder":13,"name":131},"ilhi987n986rmvo3","JavaSE 笔记（四）异常机制",{"bookId":120,"id":133,"indexOrder":13,"name":134},"pqv38vexmenglk4k","JavaSE 笔记（五）IO",{"bookId":120,"id":136,"indexOrder":13,"name":137},"jiq41n87i9ia7ilw","JavaSE 笔记（六）多线程",{"bookId":120,"id":139,"indexOrder":13,"name":140},"wn7x2mge9ws79zps","JavaSE 笔记（七）反射","此版本为早期录制的旧版本",2021,"JavaSE 21年旧版","https:\u002F\u002Fwww.bilibili.com\u002Fvideo\u002FBV1Gv411T7pi\u002F","包含JavaSE基础路线全部教程笔记，打下坚实的基础","https:\u002F\u002Fpic2.zhimg.com\u002F80\u002Fv2-bf1a927f037a79f4d57d9ae543430a0d_1440w.webp","JavaSE 系列笔记 ☕️",{"books":149,"desc":199,"id":66,"image":200,"title":201},[150,166,178],{"cateId":66,"chapters":151,"desc":162,"id":153,"time":163,"title":164,"video":165},[152,156,159],{"bookId":153,"id":154,"indexOrder":13,"name":155},21,"iqbc2haub31bwqtz","Lombok 极速上手",{"bookId":153,"id":157,"indexOrder":13,"name":158},"ijay2hay19kn1k031","Mybatis 快速上手",{"bookId":153,"id":160,"indexOrder":13,"name":161},"ru4ogh2waocpn4jo","Maven 快速上手","JavaWeb阶段必须扩展知识点",2024,"常用知识讲解","https:\u002F\u002Fwww.bilibili.com\u002Fvideo\u002FBV1gb421J7ok\u002F",{"cateId":66,"chapters":167,"desc":175,"id":169,"time":163,"title":176,"video":177},[168,172],{"bookId":169,"id":170,"indexOrder":13,"name":171},22,"ek20yvb6huhxizx7","JavaWeb 笔记（一）计算机网络基础",{"bookId":169,"id":173,"indexOrder":13,"name":174},"pgevws6w2krkffa4","JavaWeb笔记（二）Java与数据库","全面升级的JavaWeb课程","JavaWeb 网站开发","https:\u002F\u002Fwww.bilibili.com\u002Fvideo\u002FBV1kS421X7rq\u002F",{"cateId":66,"chapters":179,"desc":196,"id":181,"time":142,"title":197,"video":198},[180,184,187,190,193],{"bookId":181,"id":182,"indexOrder":13,"name":183},7,"ggwwj09j2vkfftvd","JavaWeb 笔记（一）Java网络编程",{"bookId":181,"id":185,"indexOrder":13,"name":186},"sauvq105istskjaz","JavaWeb 笔记（二）数据库基础",{"bookId":181,"id":188,"indexOrder":13,"name":189},"xgbeasmvrhxx9tn4","JavaWeb 笔记（三）Java与数据库",{"bookId":181,"id":191,"indexOrder":13,"name":192},"k7dfwua3bsezvw9q","JavaWeb 笔记（四）前端基础",{"bookId":181,"id":194,"indexOrder":13,"name":195},"ycpagby2v7j4p728","JavaWeb 笔记（五）后端开发","搭建属于自己的Web网站","JavaWeb 旧版","https:\u002F\u002Fwww.bilibili.com\u002Fvideo\u002FBV1CL4y1i7qR\u002F","包含JavaWeb路线全套笔记，从零开始搭建自己的网站！","https:\u002F\u002Fpic3.zhimg.com\u002F80\u002Fv2-df3b38e3012258ed70c23b586309e3f6_1440w.webp","JavaWeb 系列笔记 🚛",{"books":203,"desc":288,"id":81,"image":289,"title":290},[204,220,235,255,273],{"cateId":81,"chapters":205,"desc":216,"id":207,"time":217,"title":218,"video":219},[206,210,213],{"bookId":207,"id":208,"indexOrder":13,"name":209},8,"h7sjo5oy0l03607e","SSM笔记（一）Spring基础",{"bookId":207,"id":211,"indexOrder":13,"name":212},"eve8gq72qmdb46sg","SSM笔记（二）SpringMvc基础",{"bookId":207,"id":214,"indexOrder":13,"name":215},"63v73g0zh1qlr6fk","SSM笔记（三）SpringSecurity基础","Spring的探索之路从这里开始",2023,"JavaSSM 基础部分","[\"https:\u002F\u002Fwww.bilibili.com\u002Fvideo\u002FBV1Kv4y1x7is\u002F\", \"https:\u002F\u002Fwww.bilibili.com\u002Fvideo\u002FBV1Lh4y1M7kx\u002F\", \"https:\u002F\u002Fwww.bilibili.com\u002Fvideo\u002FBV1fV411M7aS\u002F\"]",{"cateId":81,"chapters":221,"desc":232,"id":223,"time":217,"title":233,"video":234},[222,226,229],{"bookId":223,"id":224,"indexOrder":13,"name":225},16,"0k66v5r6slsfuog4","SpringBoot笔记（一）核心内容",{"bookId":223,"id":227,"indexOrder":13,"name":228},"bqlrnc2yvkaxo8s1","SpringBoot笔记（二）数据交互",{"bookId":223,"id":230,"indexOrder":13,"name":231},"wci9lb9tgea866jt","SpringBoot笔记（三）前后端分离","SpringBoot全新重制版","SpringBoot 新版","https:\u002F\u002Fwww.bilibili.com\u002Fvideo\u002FBV1xu4y1m7UP\u002F",{"cateId":81,"chapters":236,"desc":252,"id":238,"time":60,"title":253,"video":254},[237,240,243,246,249],{"bookId":238,"id":239,"indexOrder":13,"name":225},9,"e43gl1ilygps032v",{"bookId":238,"id":241,"indexOrder":13,"name":242},"emnmd8nzfdb3hr50","SpringBoot笔记（二）Git版本控制",{"bookId":238,"id":244,"indexOrder":13,"name":245},"jjlolj5igvttvyhv","SpringBoot笔记（三）Redis数据库",{"bookId":238,"id":247,"indexOrder":13,"name":248},"skgr4ivb5curdoux","SpringBoot笔记（四）其他框架介绍",{"bookId":238,"id":250,"indexOrder":13,"name":251},"le91fqhu4dqui1k4","SpringBoot笔记（五）Linux系统","逐步走向企业级开发","SpringBoot 旧版","https:\u002F\u002Fwww.bilibili.com\u002Fvideo\u002FBV1UL411V7f3\u002F",{"cateId":81,"chapters":256,"desc":270,"id":258,"time":60,"title":271,"video":272},[257,261,264,267],{"bookId":258,"id":259,"indexOrder":13,"name":260},10,"oejzo0l77zeb6a7e","SpringCloud笔记（一）微服务基础",{"bookId":258,"id":262,"indexOrder":13,"name":263},"f6eya9taaelsl35p","SpringCloud笔记（二）微服务进阶",{"bookId":258,"id":265,"indexOrder":13,"name":266},"35v1hbsfcdgagdnw","SpringCloud笔记（三）微服务应用",{"bookId":258,"id":268,"indexOrder":13,"name":269},"a782u84512tyuo1m","SpringCloud笔记（四）消息队列","体验微服务架构带来的魅力","SpringCloud 进阶","https:\u002F\u002Fwww.bilibili.com\u002Fvideo\u002FBV1AL4y1j7RY\u002F",{"cateId":81,"chapters":274,"desc":285,"id":276,"time":142,"title":286,"video":287},[275,278,280,282],{"bookId":276,"id":277,"indexOrder":13,"name":209},11,"efjw75u8a251qxk5",{"bookId":276,"id":279,"indexOrder":13,"name":212},"guc134xb7sl78vju",{"bookId":276,"id":281,"indexOrder":13,"name":215},"u8ekxxucowr2b1tm",{"bookId":276,"id":283,"indexOrder":13,"name":284},"vkpmw9wbej21nei6","SSM笔记（四）MySQL进阶","此教程为2021年旧版教程","JavaSSM 旧版","https:\u002F\u002Fwww.bilibili.com\u002Fvideo\u002FBV1xL4y1H7Tq\u002F","包含Spring全套框架笔记，从开始到Spring Boot，以及众多运维小知识。","https:\u002F\u002Fpic4.zhimg.com\u002F80\u002Fv2-28c3144421220d7c048703281bc34f63_1440w.webp","Spring 系列笔记 🍏",{"books":292,"desc":329,"id":96,"image":330,"title":331},[293,308],{"cateId":96,"chapters":294,"desc":305,"id":296,"time":60,"title":306,"video":307},[295,299,302],{"bookId":296,"id":297,"indexOrder":13,"name":298},12,"jd3e8u5cmvx5gco6","C语言（一）计算机思维导论",{"bookId":296,"id":300,"indexOrder":13,"name":301},"lqv77apvx82nkkio","C语言（二）基础语法",{"bookId":296,"id":303,"indexOrder":13,"name":304},"xb0b9t37gyv96xns","C语言（三）高级特性","包含高等院校需要教授的全部内容","C语言程序设计","https:\u002F\u002Fwww.bilibili.com\u002Fvideo\u002FBV1Cr4y137os\u002F",{"cateId":96,"chapters":309,"desc":326,"id":311,"time":60,"title":327,"video":328},[310,314,317,320,323],{"bookId":311,"id":312,"indexOrder":13,"name":313},13,"8a046ps2e4w6k4py","数据结构与算法（一）线性结构篇",{"bookId":311,"id":315,"indexOrder":13,"name":316},"3ma8db91f9zrnkja","数据结构与算法（二）树形结构篇",{"bookId":311,"id":318,"indexOrder":13,"name":319},"0lsjm59k7cgu4tpr","数据结构与算法（三）散列表篇",{"bookId":311,"id":321,"indexOrder":13,"name":322},"0qzy7bogo0g2pusa","数据结构与算法（四）图结构篇",{"bookId":311,"id":324,"indexOrder":13,"name":325},"6gmcxcikcilyxblj","数据结构与算法（五）排序算法篇","虽然很难，但是它是考研必学科目","数据结构与算法","https:\u002F\u002Fwww.bilibili.com\u002Fvideo\u002FBV13W4y127Ey\u002F","你的内心一直有一个坚定的声音在告诉你，一定要考上一名研究生，向着未来前进吧！","https:\u002F\u002Fpic2.zhimg.com\u002F80\u002Fv2-ac128404efb29ce1c9d1ccc61024f1d1_1440w.webp","C语言 系列笔记 🥬",{"books":333,"desc":367,"id":108,"image":368,"title":369},[334,349,358],{"cateId":108,"chapters":335,"desc":346,"id":337,"time":163,"title":347,"video":348},[336,340,343],{"bookId":337,"id":338,"indexOrder":13,"name":339},17,"urw2e6gg1lprv65w","Kotlin（一）基础语法",{"bookId":337,"id":341,"indexOrder":13,"name":342},"t7lnl87f74f3v1ju","Kotlin（二）类与对象",{"bookId":337,"id":344,"indexOrder":13,"name":345},"v1zzvki0knb1xvml","Kotlin（三）高级特性","包含Kotlin语言完整基础部分","Kotlin程序设计基础","https:\u002F\u002Fwww.bilibili.com\u002Fvideo\u002FBV1P94y1c7tV\u002F",{"cateId":108,"chapters":350,"desc":355,"id":352,"time":163,"title":356,"video":357},[351],{"bookId":352,"id":353,"indexOrder":13,"name":354},18,"ovbzpe7065bye1st","Kotlin扩展（一）","包含Kotlin额外扩展知识","Kotlin扩展篇","https:\u002F\u002Fwww.bilibili.com\u002Fvideo\u002FBV1Hg4y1m7Ca\u002F",{"cateId":108,"chapters":359,"desc":364,"id":361,"time":163,"title":365,"video":366},[360],{"bookId":361,"id":362,"indexOrder":13,"name":363},19,"3at7ybv04dmjc0wp","Gradle基础教程","Gradle配置教程（Kotlin）","Gradle教程","https:\u002F\u002Fwww.bilibili.com\u002Fvideo\u002FBV1Fc411x7xF\u002F","Kotlin让JVM平台焕发新的生机，让语言的表达更加优美","https:\u002F\u002Fpic2.zhimg.com\u002F80\u002Fv2-be815568f7c79c64cdaa171b0409786d_1440w.webp","Kotlin 系列笔记 ☘️",{"books":371,"desc":418,"id":120,"title":419},[372,391,403],{"cateId":120,"chapters":373,"desc":387,"id":375,"time":388,"title":389,"video":390},[374,378,381,384],{"bookId":375,"id":376,"indexOrder":13,"name":377},26,"zjf5qapwqtqiohcn","JavaScript笔记（一）基础语法",{"bookId":375,"id":379,"indexOrder":13,"name":380},"95jc6sjyjwcp9pvp","JavaScript笔记（二）核心知识",{"bookId":375,"id":382,"indexOrder":13,"name":383},"j35cdc1qz8dzq7pn","JavaScript笔记（三）进阶知识",{"bookId":375,"id":385,"indexOrder":13,"name":386},"sdhodlihphnpcg37","JavaScript笔记（四）前端基础","包含JavaScript最新语法规范讲解",2026,"JavaScript教程","https:\u002F\u002Fwww.bilibili.com\u002Fvideo\u002FBV1xq6gBgESU",{"cateId":120,"chapters":392,"desc":400,"id":394,"time":37,"title":401,"video":402},[393,397],{"bookId":394,"id":395,"indexOrder":13,"name":396},23,"bsisgazdftiz3o9c","HTML5笔记（一）基础内容",{"bookId":394,"id":398,"indexOrder":13,"name":399},"njol93fs34gfwuzf","HTML5笔记（二）高级内容","包含HTML基础内容和相关知识点","HTML5核心教程","https:\u002F\u002Fwww.bilibili.com\u002Fvideo\u002FBV1BrBiYNEWg",{"cateId":120,"chapters":404,"desc":415,"id":406,"time":37,"title":416,"video":417},[405,409,412],{"bookId":406,"id":407,"indexOrder":13,"name":408},25,"jo74ciirtg8wh90y","CSS笔记（一）基础入门",{"bookId":406,"id":410,"indexOrder":13,"name":411},"ap5ixyomoejuw4ue","CSS笔记（二）盒模型和布局",{"bookId":406,"id":413,"indexOrder":13,"name":414},"4djgk5xy1lzpiuf2","CSS笔记（三）变换和过渡","包含CSS3基础内容和相关知识点","CSS3核心教程","https:\u002F\u002Fwww.bilibili.com\u002Fvideo\u002FBV1sQeEzFEKi","包含Web前端学习路径全部教程笔记，打下坚实的基础","Web前端 系列笔记",{"books":421,"desc":458,"id":423,"image":368,"title":459},[422,432,450],{"cateId":423,"chapters":424,"desc":429,"id":426,"time":163,"title":430,"video":431},100,[425],{"bookId":426,"id":427,"indexOrder":13,"name":428},20,"o0ab271mkdsas87","Markdown基础语法","编写简洁而又优美的文档","Markdown教程","https:\u002F\u002Fwww.bilibili.com\u002Fvideo\u002FBV1eJ4m157kC",{"cateId":423,"chapters":433,"desc":447,"id":435,"time":60,"title":448,"video":449},[434,438,441,444],{"bookId":435,"id":436,"indexOrder":13,"name":437},14,"6386mh7anqt4tzyv","设计模式（一）面向对象设计原则",{"bookId":435,"id":439,"indexOrder":13,"name":440},"8ftkb38wfn6ox0ug","设计模式（二）创建型",{"bookId":435,"id":442,"indexOrder":13,"name":443},"i1msql1k8y70etey","设计模式（三）结构型",{"bookId":435,"id":445,"indexOrder":13,"name":446},"5434a3cyyjvwhs8s","设计模式（四）行为型","使你的编码水平得到质的飞跃","设计模式系列","https:\u002F\u002Fwww.bilibili.com\u002Fvideo\u002FBV1u3411P7Na\u002F",{"cateId":423,"chapters":451,"desc":456,"id":453,"time":60,"title":457},[452],{"bookId":453,"id":454,"indexOrder":13,"name":455},15,"zj9uvg0sp3b0sok8","Docker 容器技术 笔记","这里包含其他中间件课程笔记","其他中间件笔记","我们对知识的探索从未停止，只有不断地学习，才能走向美好的未来！","其他笔记分类 🌽",200,true,{"data":463,"status":460,"success":461},{"bookId":435,"content":464,"id":442,"indexOrder":81,"name":443},"![image-20230301111823966](https:\u002F\u002Fs2.loli.net\u002F2023\u002F03\u002F01\u002FzsQt38PgRYnXcjH.png)\n\n# 设计模式（结构型）\n\n结构型设计模式关注如何将现有的类或对象组织在一起形成更加强大的结构。并且根据我们前面学习的合成复用原则，我们该如何尽可能地使用关联关系来代替继承关系是我们本版块需要重点学习的内容。\n\n## 类\u002F对象适配器模式\n\n在生活中，我们经常遇到这样的一个问题：笔记本太轻薄了，以至于没有RJ45网口和USB A口（比如Macbook为了轻薄甚至全是type-c形式的雷电口）但是现在我们因为工作需要，又得使用这些接口来连接线缆，这时我们想到的第一个解决方案，就是去买一个转接口（扩展坞），扩展坞可以将type-c口转换为其他类型的接口供我们使用，实际上这就是一种适配模式。\n\n![image-20230301111837481](https:\u002F\u002Fs2.loli.net\u002F2023\u002F03\u002F01\u002F5HkWt8fhwIZCxPE.png)\n\n由于我们的电脑没有这些接口，但是提供了type-c类型的接口，虽然接口类型不一样，但是同样可以做其他接口能做的事情，比如USB文件传输、有线网络连接等，所以，这个时候，我们只需要添加一个中间人来帮我们转换一下接口形态即可。包括我们常用的充电头，为什么叫电源适配器呢？我们知道传统的供电是220V交流电，但是我们的手机可能只需要5V的电压进行充电，虽然现在有电，但是不能直接充，我们也不可能让电力公司专门为我们提供一个5V的直流电使用。这时电源适配器就开始发挥作用了，比如苹果的祖传5V1A充电头，实际上就是将220V交流电转换为5V的直流电进行传输，这样就相当于在220V交流电和我们的手机之前，做了一个适配器的角色。\n\n在我们的Java程序中，也会经常遇到这样的问题，比如：\n\n```java\npublic class TestSupplier {   \u002F\u002F手机供应商\n\n    public String doSupply(){\n        return \"iPhone 14 Pro\";\n    }\n}\n```\n\n```java\npublic class Main {\n    public static void main(String[] args) {\n        TestSupplier supplier = new TestSupplier();\n      \ttest( ? );   \u002F\u002F我们没有Target类型的手机供应商，只有其他的，那这里该填个啥\n    }\n\n    public static void test(Target target){   \u002F\u002F现在我们需要调用test方法，但是test方法需要Target类型的手机供应商\n        System.out.println(\"成功得到：\"+target.supply());\n    }\n}\n```\n\n```java\npublic interface Target {    \u002F\u002F现在的手机供应商，并不是test方法所需要的那种类型\n\n    String supply();\n}\n```\n\n这个时候，我们就可以使用适配器模式了，适配器模式分为类适配器和对象适配器，我们首先来看看如何使用类适配器解决这种问题，我们直接创建一个适配器类：\n\n```java\npublic class TestAdapter extends TestSupplier implements Target {  \n  \u002F\u002F让我们的适配器继承TestSupplier并且实现Target接口\n    @Override\n    public String supply() {   \u002F\u002F接着实现supply方法，直接使用TestSupplier提供的实现\n        return super.doSupply();\n    }\n}\n```\n\n这样，我们就得到了一个Target类型的实现类，并且同时采用的是TestSupplier提供的实现。\n\n```java\npublic static void main(String[] args) {\n    TestAdapter adapter = new TestAdapter();\n    test(adapter);\n}\n\npublic static void test(Target target){\n    System.out.println(\"成功得到：\"+target.supply());\n}\n```\n\n不过，这种实现方式需要占用一个继承坑位，如果此时Target不是接口而是抽像类的话，由于Java不支持多继承，那么就无法实现了。同时根据合成复用原则，我们应该更多的通过合成的方式去实现功能，所以我们来看看第二种，也是用的比较多的一种模式，对象适配器：\n\n```java\npublic class TestAdapter implements Target{   \u002F\u002F现在不再继承TestSupplier，仅实现Target\n\n    TestSupplier supplier;\n    \n    public TestAdapter(TestSupplier supplier){\n        this.supplier = supplier;\n    }\n    \n    @Override\n    public String supply() {\n        return supplier.doSupply();\n    }\n}\n```\n\n现在，我们就将对象以组合的形式存放在TestAdapter中，依然是通过存放的对象调用具体实现。\n\n## 桥接模式\n\n相信各位都去奶茶店买过奶茶，在购买奶茶的时候，店员首先会问我们，您需要什么类型的奶茶，比如我们此时点了一杯啵啵芋圆奶茶，接着店员会直接问我们需要大杯、中杯还是小杯，最后还会询问我们需要加什么配料，比如椰果、珍珠等，最后才会给我们制作奶茶。\n\n![image-20230301111852891](https:\u002F\u002Fs2.loli.net\u002F2023\u002F03\u002F01\u002FZAjo69kfFUuIJ52.png)\n\n那么现在让你来设计一下这种模式的Java类，该怎么做呢？首先我们要明确，一杯奶茶除了类型之外，还分大中小杯，甚至可能还分加什么配料，这个时候，如果我们按照接口实现的写法：\n\n```java\npublic interface Tea {   \u002F\u002F由具体类型的奶茶实现\n    String getType();   \u002F\u002F不同的奶茶返回的类型不同\n}\n```\n\n```java\npublic interface Size {   \u002F\u002F分大杯小杯中杯\n    String getSize();\n}\n```\n\n比如现在我们创建一个新的类型：\n\n```java\n\u002F**\n * 大杯芋圆啵啵奶茶\n *\u002F\npublic class LargeKissTea implements Tea, Size{\n\n    @Override\n    public String getSize() {\n        return \"大杯\";\n    }\n\n    @Override\n    public String getType() {\n        return \"芋圆啵啵奶茶\";\n    }\n}\n```\n\n虽然这样设计起来还挺合理的，但是如果现在我们的奶茶品种多起来了，并且每种奶茶都有大中小杯，现在一共有两个维度需要考虑，那么我们岂不是得一个一个去创建这些类？甚至如果还要考虑配料，那么光创建类就得创建不知道多少个了。显然这种设计不太好，我们得换个方式。\n\n这时，就可以使用我们的桥接模式了，现在我们面临的问题是，维度太多，不可能各种类型各种尺寸的奶茶都去创建一个类，那么我们就还是单独对这些接口进行简单的扩展，单独对不同的维度进行控制，但是如何实现呢？我们不妨将奶茶的类型作为最基本的抽象类，然后对尺寸、配料等属性进行桥接：\n\n```java\npublic abstract class AbstractTea {\n    \n    protected Size size;   \u002F\u002F尺寸作为桥接属性存放在类中\n    \n    protected AbstractTea(Size size){   \u002F\u002F在构造时需要知道尺寸属性\n        this.size = size;\n    }\n    \n    public abstract String getType();   \u002F\u002F具体类型依然是由子类决定\n}\n```\n\n不过这个抽象类提供的方法还不全面，仅仅只有Tea的getType方法，我们还需要添加其他维度的方法，所以继续编写一个子类：\n\n```java\npublic abstract class RefinedAbstractTea extends AbstractTea{\n    protected RefinedAbstractTea(Size size) {\n        super(size);\n    }\n    \n    public String getSize(){   \u002F\u002F添加尺寸维度获取方式\n        return size.getSize();\n    }\n}\n```\n\n现在我们只需要单独为Size创建子类即可：\n\n```java\npublic class Large implements Size{\n\n    @Override\n    public String getSize() {\n        return \"大杯\";\n    }\n}\n```\n\n现在我们如果需要一个大杯的啵啵芋圆奶茶，只需要：\n\n```java\npublic class KissTea extends RefinedAbstractTea{   \u002F\u002F创建一个啵啵芋圆奶茶的子类\n    protected KissTea(Size size) {   \u002F\u002F在构造时需要指定具体的大小实现\n        super(size);\n    }\n\n    @Override\n    public String getType() {\n        return \"啵啵芋圆奶茶\";   \u002F\u002F返回奶茶类型\n    }\n}\n```\n\n现在我们就将两个维度拆开，可以分别进行配置了：\n\n```java\npublic static void main(String[] args) {\n    KissTea tea = new KissTea(new Large());\n    System.out.println(tea.getType());\n    System.out.println(tea.getSize());\n}\n```\n\n通过桥接模式，使得抽象和实现可以沿着各自的维度来进行变化，不再是固定的绑定关系。\n\n## 组合模式\n\n组合模式实际上就是将多个组件进行组合，让用户可以对它们进行一致性处理。比如我们的文件夹，一个文件夹中可以有很多个子文件夹或是文件：\n\n![image-20230301111907078](https:\u002F\u002Fs2.loli.net\u002F2023\u002F03\u002F01\u002FMYPyj9edEOmNWwU.png)\n\n它就像是一个树形结构一样，有分支有叶子，而组合模式则是可以对整个树形结构上的所有节点进行递归处理，比如我们现在希望将所有文件夹中的文件的名称前面都添加一个前缀，那么就可以使用组合模式。\n\n![image-20230301111916996](https:\u002F\u002Fs2.loli.net\u002F2023\u002F03\u002F01\u002FFzeBOp53ojM4Sui.png)\n\n组合模式的示例如下，这里我们就用文件和文件夹的例子来讲解：\n\n```java\n\u002F**\n * 首先创建一个组件抽象，组件可以包含组件，组件有自己的业务方法\n *\u002F\npublic abstract class Component {\n    public abstract void addComponent(Component component);    \u002F\u002F添加子组件\n    public abstract void removeComponent(Component component);   \u002F\u002F删除子组件\n    public abstract Component getChild(int index);   \u002F\u002F获取子组件\n    public abstract void test();   \u002F\u002F执行对应的业务方法，比如修改文件名称\n}\n```\n\n接着我们来编写两种实现类：\n\n```java\npublic class Directory extends Component{   \u002F\u002F目录可以包含多个文件或目录\n\n    List\u003CComponent> child = new ArrayList\u003C>();   \u002F\u002F这里我们使用List来存放目录中的子组件\n\n    @Override\n    public void addComponent(Component component) {\n        child.add(component);\n    }\n\n    @Override\n    public void removeComponent(Component component) {\n        child.remove(component);\n    }\n\n    @Override\n    public Component getChild(int index) {\n        return child.get(index);\n    }\n\n    @Override\n    public void test() {\n        child.forEach(Component::test);   \u002F\u002F将继续调用所有子组件的test方法执行业务\n    }\n}\n```\n\n```java\npublic class File extends Component{   \u002F\u002F文件就相当于是树叶，无法再继续添加子组件了\n\n    @Override\n    public void addComponent(Component component) {\n        throw new UnsupportedOperationException();   \u002F\u002F不支持这些操作了\n    }\n\n    @Override\n    public void removeComponent(Component component) {\n        throw new UnsupportedOperationException();\n    }\n\n    @Override\n    public Component getChild(int index) {\n        throw new UnsupportedOperationException();\n    }\n\n    @Override\n    public void test() {\n        System.out.println(\"文件名称修改成功！\"+this);   \u002F\u002F具体的名称修改操作\n    }\n}\n```\n\n最后，我们来测试一下：\n\n```java\npublic static void main(String[] args) {\n    Directory outer = new Directory();   \u002F\u002F新建一个外层目录\n    Directory inner = new Directory();   \u002F\u002F新建一个内层目录\n    outer.addComponent(inner);\n    outer.addComponent(new File());   \u002F\u002F在内层目录和外层目录都添加点文件，注意别导错包了\n    inner.addComponent(new File());\n    inner.addComponent(new File());\n    outer.test();    \u002F\u002F开始执行文件名称修改操作\n}\n```\n\n可以看到我们对最外层目录进行操作后，会递归向下处理当前目录和子目录中所有的文件。\n\n## 装饰模式\n\n装饰模式就像其名字一样，为了对现有的类进行装饰。比如一张相片就一张纸，如果直接贴在墙上，总感觉少了点什么，但是我们给其添加一个好看的相框，就会变得非常对味。装饰模式的核心就在于不改变一个对象本身功能的基础上，给对象添加额外的行为，并且它是通过组合的形式完成的，而不是传统的继承关系。\n\n比如我们现在有一个普通的功能类：\n\n```java\npublic abstract class Base {   \u002F\u002F顶层抽象类，定义了一个test方法执行业务\n    public abstract void test();\n}\n```\n\n```java\npublic class BaseImpl extends Base{\n    @Override\n    public void test() {\n        System.out.println(\"我是业务方法\");   \u002F\u002F具体的业务方法\n    }\n}\n```\n\n不过现在的实现类太单调了，我们来添加一点装饰上去：\n\n```java\npublic class Decorator extends Base{   \u002F\u002F装饰者需要将装饰目标组合到类中\n\n    protected Base base;\n\n    public Decorator(Base base) {\n        this.base = base;\n    }\n\n    @Override\n    public void test() {\n        base.test();    \u002F\u002F这里暂时还是使用目标的原本方法实现\n    }\n}\n```\n\n```java\npublic class DecoratorImpl extends Decorator{   \u002F\u002F装饰实现\n\n    public DecoratorImpl(Base base) {\n        super(base);\n    }\n\n    @Override\n    public void test() {    \u002F\u002F对原本的方法进行装饰，我们可以在前后都去添加额外操作\n        System.out.println(\"装饰方法：我是操作前逻辑\");\n        super.test();\n        System.out.println(\"装饰方法：我是操作后逻辑\");\n    }\n}\n```\n\n这样，我们就通过装饰模式对类的功能进行了扩展：\n\n```java\npublic static void main(String[] args) {\n    Base base = new BaseImpl();\n    Decorator decorator = new DecoratorImpl(base);  \u002F\u002F将Base实现装饰一下\n    Decorator outer = new DecoratorImpl(decorator);  \u002F\u002F装饰者还可以嵌套\n\n    decorator.test();\n\n    outer.test();\n}\n```\n\n这样我们就实现了装饰模式。\n\n## 代理模式\n\n代理模式和装饰模式很像，初学者很容易搞混，所以这里我们得紧接着来讲解一下。首先请记住，当无法直接访问某个对象或访问某个对象存在困难时，我们就可以通过一个代理对象来间接访问。\n\n实际上代理在我们生活中处处都存在，比如手机厂商要去销售手机，但是手机厂商本身没有什么渠道可以大规模地进行售卖，很难与这些消费者进行对接，这时就得交给代理商去进行出售，比如Apple在中国的直营店很少，但是在中国的授权经销商却很多，手机厂商通过交给旗下代理商的形式来进行更大规模的出售。比如我们经常要访问Github，但是直接连接会发现很难连的上，这时我们加了一个代理就可以轻松访问，也是在体现代理的作用。\n\n![image-20230301111934493](https:\u002F\u002Fs2.loli.net\u002F2023\u002F03\u002F01\u002F4yRZix1FfvaYboj.png)\n\n同时，代理类需要保证客户端使用的透明性，也就是说操作起来需要与原本的真实对象相同，比如我们访问Github只需要输入网址即可访问，而添加代理之后，也是使用同样的方式去访问Github，所以操作起来是一样的。包括Spring框架其实也是依靠代理模式去实现的AOP记录日志等。\n\n比如现在有一个目标类，但是我们现在需要通过代理来使用它：\n\n```java\npublic abstract class Subject {\n    public abstract void test();\n}\n```\n\n```java\npublic class SubjectImpl extends Subject{  \u002F\u002F此类无法直接使用，需要我们进行代理\n\n    @Override\n    public void test() {\n        System.out.println(\"我是测试方法！\");\n    }\n}\n```\n\n现在我们为其建立一个代理类：\n\n```java\npublic class Proxy extends Subject{   \u002F\u002F为了保证和Subject操作方式一样，保证透明性，也得继承\n\n    Subject target;   \u002F\u002F被代理的对象（甚至可以多重代理）\n\n    public Proxy(Subject subject){\n        this.target = subject;\n    }\n\n    @Override\n    public void test() {   \u002F\u002F由代理去执行被代理对象的方法，并且我们还可以在前后添油加醋\n        System.out.println(\"代理前绕方法\");\n        target.test();\n        System.out.println(\"代理后绕方法\");\n    }\n}\n```\n\n乍一看，这不跟之前的装饰模式一模一样吗？\n\n对装饰器模式来说，装饰者和被装饰者都实现同一个接口\u002F抽象类。对代理模式来说，代理类和被代理的类都实现同一个接口\u002F抽象类，在结构上确实没有啥区别。但是他们的作用不同，装饰器模式强调的是增强自身，在被装饰之后你能够在被增强的类上使用增强后的功能，增强后你还是你，只不过被强化了而已；代理模式强调要让别人帮你去做事情，以及添加一些本身与你业务没有太多关系的事情（记录日志、设置缓存等）重点在于让别人帮你做。\n\n装饰模式和代理模式的不同之处在于思想。\n\n当然实现代理模式除了我们上面所说的这种方式之外，我们还可以使用JDK为我们提供的动态代理机制，我们不再需要手动编写继承关系创建代理类，它能够在运行时通过反射机制为我们自动生成代理类：\n\n```java\npublic interface Subject {  \u002F\u002FJDK提供的动态代理只支持接口\n    void test();\n}\n```\n\n```java\npublic class SubjectImpl implements Subject{\n\n    @Override\n    public void test() {\n        System.out.println(\"我是测试方法！\");\n    }\n}\n```\n\n接着我们需要创建一个动态代理的处理逻辑：\n\n```java\npublic class TestProxy implements InvocationHandler {    \u002F\u002F代理类，需要实现InvocationHandler接口\n\n    private final Object object;   \u002F\u002F这里需要保存一下被代理的对象，下面需要用到\n\n    public TestProxy(Object object) {\n        this.object = object;\n    }\n\n    @Override   \u002F\u002F此方法就是调用代理对象的对应方法时会进入，这里我们就需要编写如何进行代理了\n    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {\n     \t\t\u002F\u002Fmethod就是调用的代理对象的哪一个方法，args是实参数组\n        System.out.println(\"代理的对象：\"+proxy.getClass());   \u002F\u002Fproxy就是生成的代理对象了，我们看看是什么类型的\n        Object res = method.invoke(object, args);   \u002F\u002F在代理中调用被代理对象原本的方法，因为你是代理，还是得执行一下别人的业务，当然也可以不执行，但是这样就失去代理的意义了，注意要用上面的object\n        System.out.println(\"方法调用完成，返回值为：\"+res);   \u002F\u002F看看返回值是什么\n        return res;   \u002F\u002F返回返回值\n    }\n}\n```\n\n最后我们来看看如何创建一个代理类：\n\n```java\npublic static void main(String[] args) {\n    SubjectImpl subject = new SubjectImpl();   \u002F\u002F被代理的大冤种\n    InvocationHandler handler = new TestProxy(subject);\n    Subject proxy = (Subject) Proxy.newProxyInstance(\n            subject.getClass().getClassLoader(),    \u002F\u002F需要传入被代理的类的类加载器\n            subject.getClass().getInterfaces(),    \u002F\u002F需要传入被代理的类的接口列表\n            handler);    \u002F\u002F最后传入我们实现的代理处理逻辑实现类\n    proxy.test();    \u002F\u002F比如现在我们调用代理类的test方法，那么就会进入到我们上面TestProxy中invoke方法，走我们的代理逻辑\n}\n```\n\n运行一次，可以看到调用代理类的方法，最终会走到我们的invoke方法中进行：\n\n![image-20230301112001604](https:\u002F\u002Fs2.loli.net\u002F2023\u002F03\u002F01\u002FRipPFu3Q6Y5Idel.png)\n\n根据接口，代理对象是`com.sun.proxy.$Proxy0`类（看名字就知道不对劲），这个类是动态生成的，我们也找不到具体的源代码。\n\n不过JDK提供的动态代理只能使用接口，如果换成我们一开始的抽象类，就没办法了，这时我们可以使用一些第三方框架来实现更多方式的动态代理，比如Spring都在使用的CGLib框架，Maven依赖如下：\n\n```xml\n\u003Cdependency>\n    \u003CgroupId>cglib\u003C\u002FgroupId>\n    \u003CartifactId>cglib\u003C\u002FartifactId>\n    \u003Cversion>3.1\u003C\u002Fversion>\n\u003C\u002Fdependency>\n```\n\n由于CGlib底层使用ASM框架（JVM篇视频教程有介绍）进行字节码编辑，所以能够实现不仅仅局限于对接口的代理：\n\n```java\npublic class TestProxy implements MethodInterceptor {  \u002F\u002F首先还是编写我们的代理逻辑\n\n    private final Object target;   \u002F\u002F这些和之前JDK动态代理写法是一样的\n\n    public TestProxy(Object target) {\n        this.target = target;\n    }\n\n    @Override   \u002F\u002F我们也是需要在这里去编写我们的代理逻辑\n    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {\n        System.out.println(\"现在是由CGLib进行代理操作！\"+o.getClass());\n        return method.invoke(target, objects);   \u002F\u002F也是直接调用代理对象的方法即可\n    }\n}\n```\n\n接着我们来创建一下代理类：\n\n```java\npublic static void main(String[] args) {\n    SubjectImpl subject = new SubjectImpl();\n\n    Enhancer enhancer = new Enhancer();   \u002F\u002F增强器，一会就需要依靠增强器来为我们生成动态代理对象\n    enhancer.setSuperclass(SubjectImpl.class);    \u002F\u002F直接选择我们需要代理的类型，直接不需要接口或是抽象类，SuperClass作为代理类的父类存在，这样我们就可以按照指定类型的方式去操作代理类了\n    enhancer.setCallback(new TestProxy(subject));  \u002F\u002F设定我们刚刚编写好的代理逻辑\n\n    SubjectImpl proxy = (SubjectImpl) enhancer.create();   \u002F\u002F直接创建代理类\n\n    proxy.test();   \u002F\u002F调用代理类的test方法\n}\n```\n\n可以看到，效果其实是差不多的：\n\n![image-20230301112013486](https:\u002F\u002Fs2.loli.net\u002F2023\u002F03\u002F01\u002FY1bHtnZTIoq8pBu.png)\n\n可以看到代理类是`包名.SubjectImpl$$EnhancerByCGLIB$$47f6ed3a`，也是动态生成的一个类，所以我们无法去查看源码，不过此类是继承自我们指定的类型的。\n\n## 外观模式\n\n你是否经历过类似的情况：今年计算机学院的奖学金评定工作开始了，由于你去年一不小心拿了个ACM的区域赛金牌，觉得自己又行了，于是也想参与到奖学金的争夺中，首先你的辅导员会通知你去打印你的获奖材料，然后你高高兴兴拿给辅导员之后，辅导员又给了你一张表，让你打印了之后填写一下，包括你的个人信息还有一些个人介绍，完成后，你本以为可以坐等发奖了，结果辅导员又跟你说我们评定还要去某某地方盖章，盖完章还要去找谁谁谁签字，最后还要参加一下答辩... 看着如此复杂的流程，你瞬间不想搞了。\n\n![image-20230301112039165](https:\u002F\u002Fs2.loli.net\u002F2023\u002F03\u002F01\u002Fy2wzFh1UWYmpgJX.png)\n\n实际上我们生活中很多时候都是这样，可能在办一件事情的时候，由于部门职能的不同，你得各个部门到处跑，你肯定会抱怨一句，就不能有个人来统一一下吗，就不能在一个地方一起把事情都办了吗？这时，我们就可以用到外观模式了。\n\n外观模式充分体现了迪米特法则。可能我们的整个项目有很多个子系统，但是我们可以在这些子系统的上面加一个门面（Facade）当我们外部需要与各个子系统交互时，无需再去直接使用各个子系统，而是与门面进行交互，再由门面与后面的各个子系统操作，这样，我们以后需要办什么事情，就统一找门面就行了。这样的好处是，首先肯定方便了代码的编写，统一找门面就行，不需要去详细了解子系统，并且，当子系统需要修改时，也只需要修改门面中的逻辑，不需要大面积的变动，遵循迪米特法则尽可能少的交互。\n\n![image-20230301112103676](https:\u002F\u002Fs2.loli.net\u002F2023\u002F03\u002F01\u002FBylhOfcFtni29uQ.png)\n\n比如现在我们设计了三个子系统，分别是排队、结婚、领证，正常情况下我们是需要分别去找这三个部门去完成的，但是现在我们通过门面统一来完成：\n\n```java\npublic class SubSystemA {\n    public void test1(){\n        System.out.println(\"排队\");\n    }\n}\n```\n\n```java\npublic class SubSystemB {\n    public void test2(){\n        System.out.println(\"结婚\");\n    }\n}\n```\n\n```java\npublic class SubSystemC {\n    public void test3(){\n        System.out.println(\"领证\");\n    }\n}\n```\n\n现在三个系统太复杂了，我们添加一个门面：\n\n```java\npublic class Facade {\n\n    SubSystemA a = new SubSystemA();\n    SubSystemB b = new SubSystemB();\n    SubSystemC c = new SubSystemC();\n\n    public void marry(){   \u002F\u002F红白喜事一条龙服务\n        a.test1();\n        b.test2();\n        c.test3();\n    }\n}\n```\n\n现在我们只需要一个门面就能直接把事情办完了：\n\n```java\npublic static void main(String[] args) {\n    Facade facade = new Facade();\n    facade.marry();\n}\n```\n\n通过使用外观模式，我们就大大降低了类与类直接的关联程度，并且简化了流程。\n\n## 享元模式\n\n最后我们来看看享元模式（Flyweight），那么这个\"享元\"代表什么意思呢？我们先来看看下面的问题：\n\n```java\npublic static void main(String[] args) {\n    String str1 = \"abcdefg\";\n    String str2 = \"abcd\";\n}\n```\n\n我们发现上面的例子中，两个字符串虽然长短不同，但是却包含了一段相同的部分，那么现在我们如果要对内存进行优化：\n\n```java\npublic static void main(String[] args) {\n    String str1 = \"efg\";   \u002F\u002F由于str1包含str2，所以我们可以去掉重复的部分，当需要原本的str1时，再合在一起\n    String str2 = \"abcd\";\n    System.out.println(\"str1 = \"+str2+str1);\n}\n```\n\n而享元模式就是这个思想，我们可以将那些重复出现的内容作为共享部分取出，这样当我们拥有大量对象时，我们把其中共同的部分抽取出来，由于提取的部分是多个对象共享只有一份，那么就可以减轻内存的压力。包括我们的围棋，实际上我们只需要知道棋盘上的各个位置是黑棋还是白棋，实际上没有毕业创建很多个棋子对象，我们只需要去复用一个黑棋和一个白棋子对象即可。\n\n比如现在我们有两个服务，但是他们都需要使用数据库工具类来操作，实际上这个工具类没必要创建多个，我们这时就可以使用享元模式，让数据库工具类作为享元类，通过享元工厂来提供一个共享的数据库工具类：\n\n```java\npublic class DBUtil {\n    public void selectDB(){\n        System.out.println(\"我是数据库操作...\");\n    }\n}\n```\n\n```java\npublic class DBUtilFactory {\n    private static final DBUtil UTIL = new DBUtil();   \u002F\u002F享元对象被存放在工厂中\n\n    public static DBUtil getFlyweight(){   \u002F\u002F获取享元对象\n        return UTIL;\n    }\n}\n```\n\n最后当我们需要使用享元对象时，直接找享元工厂要就行了：\n\n```java\npublic class UserService {   \u002F\u002F用户服务\n\n    public void service(){\n        DBUtil util = DBUtilFactory.getFlyweight();   \u002F\u002F通过享元工厂拿到DBUtil对象\n        util.selectDB();    \u002F\u002F该干嘛干嘛\n    }\n}\n```\n\n当然，这只是简单的享元模式实现，实际上我们一开始举例的String类，也在使用享元模式进行优化，比如下面的代码：\n\n```java\npublic static void main(String[] args) {\n    String str1 = \"abcd\";\n    String str2 = \"abcd\";\n    String str3 = \"ab\" + \"cd\";\n    System.out.println(str1 == str2);\n    System.out.println(str1 == str3);   \u002F\u002F猜猜这三个对象是不是都是同一个？\n}\n```\n\n虽然我们这里定义了三个字符串，但是我们发现，这三个对象指向的都是同一个对象，这是为什么呢？实际上这正是Java语言实现了数据的共享，想要了解具体实现请前往JVM篇视频教程。\n",{"data":466,"status":460,"success":461},[467,472],{"id":8,"image":468,"link":469,"name":470,"type":471},"\u002Fimage\u002Fadv\u002Frainyun-2025-06.webp","https:\u002F\u002Fwww.rainyun.com\u002Fitbaima_","雨云优惠购","cloud",{"id":66,"image":473,"link":474,"name":475,"type":476},"\u002Fimage\u002Fadv\u002Fsimcard-2025-11.webp","https:\u002F\u002Fmall.itbaima.cn","号卡优惠","simcard"]