Java 中 23 种设计模式详解：七大结构型模式详细分析

• Sourceable

public interface Sourceable{

public void method1();

public void method2();

}

• Wrapper-抽象类

public abstract class Wrapper implements Sourceable{

public void method1(){}

public void method2(){}

}

• SourceSub1

public class SourceSub1 extends Wrapper{

public void method1(){

System.out.println(“The sourceable interface’s first Sub”);

}

}

• SourceSub2

public class SourceSub2 extends Wrapper(){

public void method2(){

System.out.println(“The Sourceable interface’s second Sub”);

}

}

• WrapperTest

public class WrapperTest{

public static void main(String[] args){

Sourceable source1=new SourceSub1();

Sourceable source2=new SourceSub2();

source1.method1();

source1.method2();

source2.method1();

source2.method2();

}

}

三种适配器模式的应用场景:

类的适配器模式:

当希望一个类转换成满足另一个新接口的类时,可以使用类的适配器模式

创建一个新类,继承原有的类,实现新的接口即可

对象的适配器模式:

当希望一个对象转换成满足另一个新接口的对象时,可以使用对象的适配器模式

创建一个 Wrapper 类,持有原类的一个实例,在 Wrapper 类的方法中,调用实例的方法即可

接口的适配器模式:

当不希望实现一个接口中所有的方法时,可以使用接口的适配器模式

创建一个抽象类 Wrapper,实现所有方法,写其它类时,只要继承抽象类即可

装饰器模式(Decorator)

装饰器模式: 给一个对象动态地增加一些新的功能

装饰器模式要求装饰对象和被装饰对象实现同一个接口, 装饰对象持有被装饰对象的实例

Source 类时被装饰类 ,Decorator 类是装饰类,可以为 Source 类动态地增加一些功能:

• Sourceable

public interface Sourceable{

public void method();

}

• Source

public class Source implements Sourceable{

@Override

public void method(){

System.out.println(“The original method!”);

}

}

• Decorator

public class Decorator implements Sourceable{

private Sourceable source;

public Decorator(Sourceable source){

super();

this.source=source;

}

@Override

public void method(){

System.out.println(“Before decorator!”);

source.method();

System.out.println(“After decorator!”);

}

}

-Test

public class DecoratorTest{

public static void main(String[] args){

Sourceable source=new Source();

Sourceable obj=new Decorator(source);

obj.method();

}

}

装饰器模式应用场景:

• 需要扩展一个类的功能

• 动态地为一个对象增加功能,而且还能动态地撤销(继承的功能是静态的,不能动态增删)

装饰器模式的缺点: 产生过多类似的对象,不易排错

代理模式(Proxy)

• 代理模式: 创建一个代理类,替原对象进行一些操作

• Sourceable

public interface Sourceable{

public void method();

}

• Source

public class Source implements Sourceable{

@Override

public void method(){

System.out.println(“The original method!”);

}

}

• Proxy

public class Proxy implements Sourceable{

private Source source;

public Proxy(){

super();

this.source=new Source;

}

@Override

public void method(){

before();

source.method();

after();

}

public void before(){

System.out.println(“Before Proxy!”);

}

public void after(){

System.out.println(“After Proxy!”);

}

}

• ProxyTest

public class ProxyTest{

public static void main(String[] args){

Sourceable source=new Proxy();

source.method();

}

}

代理模式的应用场景:

• 已有的方法在使用的时候需要对原有的方法进行改进,有两种方法:

• 修改原有的方法来适应: 这样违反了"对扩展开放,对修改关闭"的原则 .不推荐使用

• 采用一个代理类调用原有的方法,且对产生的结果进行控制. 即代理模式

• 使用代理模式,可以将功能划分的更加清晰,有助于后期维护

外观模式(Facade)

在 Spring 中,可以将类与类之间的关系配置到配置文件中

外观模式: 为了解决类与类之间的依赖关系,将类鱼雷之间的关系放到一个 Facade 类中,降低类与类之间的耦合度,该模式中没有涉及到接口

• CPU

public class CPU{

public void startup(){

System.out.println(“CPU startup!”);

}

public void shutdown(){

System.out.println(“CPU shutdown!”);

}

}

• Memory

public class Memory{

public void startup(){

System.out.println(“Memory startup!”);

}

public void shutdown(){

System.out.println(“Memory shutdown!”);

}

}

• Disk

public class Disk{

public void startup(){

System.out.println(“Disk startup!”);

}

public void shutdown(){

System.out.println(“Disk shutdown!”);

}

}

• Computer

public class Computer{

private CPU cpu;

private Memory memory;

private Disk disk;

public Computer(){

cpu=new CPU();

memory=new Memory();

disk=new Disk();

}

public void startup(){

System.out.println(“Start the computer!”);

cpu.startup();

memory.startup();

disk.startup();

System.out.println(“Start the computer finished!”);

}

public void shutdown(){

System.out.println(“Begin to close the computer!”);

cpu.shutdown();

memory.shutdown();

disk.shutdown();

System.out.println(“Computer closed!”);

}

}

-User

public class User{

public static void main(String[] args){

Computer computer=new Computer();

computer.startup();

computer.shutdown();

}

}

如果没有 Computer 类 ,CPU,Memory,Disk 之间会互相持有实例,产生关系,这样会造成严重依赖

修改一个类,可能会带来其它类的修改

有了 Computer 类,各个类之间的关系就放在类 Computer 类里,这样就起到解耦的作用

桥接模式(Bridge)

桥接模式: 将事物和具体实现分开,二者可以各自独立的变化

将抽象化与实现化解耦,使得二者可以独立变化:

• JDBC 桥 DriverManager:

• JDBC 连接数据库的时候,在各个数据库之间进行切换,基本不需要改动太多的代码,甚至一点不用改动

• 原因在于 JDBC 提供统一接口,每个数据库提供各自实现,用一个叫作数据库驱动的程序来桥接即可

• Sourceable

public interface Sourceable{

public void method();

}

• SourceSub1

public class SourceSub1 implements Sourceable{

@Override

public void method(){

System.out.println(“This is the first sub!”);

}

}

• SourceSub2

public class SourceSub2 implements Sourceable{

@Override

public void method(){

System.out.println(“This is the second sub!”);

}

}

• 定义一个桥,持有Sourceable的一个实例

public abstract class Bridge{

private Sourceable source;

public void method(){

source.method();

}

public Sourceable getSource(){

return source;

}

public void getSource(Sourceable source){

this.source=source;

}

}

• MyBridge

public class MyBridge extends Bridge{

public void method(){

getSource().method();

}

}

• BridgeTest

public class BridgeTest{

public static void main(String[] args){

Bridge bridge=new MyBridge();

/* 调用第一个对象 */

Sourceable source1=new SourceSub1();

bridge.setSource(source1);

bridge.method();

/* 调用第二个对象 */

Sourceable source2=new SourceSub2();

bridge.setSource(source2);

bridge.method();

}

}

通过对 Bridge 类的调用,实现了对接口 Sourceable 的实现类 SourceSub1 和 SourceSub2 的调用

示例: JDBC 连接原理

组合模式(Composite)

组合模式: 部分-整体模式,在处理类似树形结构的问题时比较方便

• TreeNode

public class TreeNode{

private String name;

private TreeNode parent;

private Vector children=new Vector();

public TreeNode(String name){

this.name=name;

}

public String getName(){

return name;

}

public void setName(String name){

this.name=name;

}

public TreeNode getParent(){

return parent;

}

public void setParent(TreeNode parent){

this.parent=parent;

}

/* 添加孩子节点 */

public void add(TreeNode node){

children.add(node);

}

/* 删除孩子节点 */

public void remove(TreeNode node){

children.remove(node);

}

/* 获得孩子节点 */

public Enumeration getChildren(){

return children.elements();

}

}

• Tree

public class Tree{

TreeNode root=null;

public Tree(String name){

root=new TreeNode(name);

}

public void main(String[] args){

Tree tree=new Tree(“A”);

TreeNode nodeB=new TreeNode(“B”);

TreeNode nodeC=new TreeNode(“C”);

nodeB.add(nodeC);

tree.root.add(nodeB);

System.out.println(“Build the tree finished!”);

}

}
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

总结

本文从基础到高级再到实战，由浅入深，把MySQL讲的清清楚楚，明明白白，这应该是我目前为止看到过最好的有关MySQL的学习笔记了，我相信如果你把这份笔记认真看完后，无论是工作中碰到的问题还是被面试官问到的问题都能迎刃而解！

MySQL50道高频面试题整理：

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
}
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。[外链图片转存中…(img-qpG6zrR2-1713391799759)]

[外链图片转存中…(img-YYsFwp3G-1713391799760)]

[外链图片转存中…(img-sMOnPfrw-1713391799760)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

总结

本文从基础到高级再到实战，由浅入深，把MySQL讲的清清楚楚，明明白白，这应该是我目前为止看到过最好的有关MySQL的学习笔记了，我相信如果你把这份笔记认真看完后，无论是工作中碰到的问题还是被面试官问到的问题都能迎刃而解！

MySQL50道高频面试题整理：

[外链图片转存中…(img-zzydB4x4-1713391799761)]

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！