Java常用的设计模式

最新推荐文章于 2024-07-21 22:23:56 发布

cgmx551

最新推荐文章于 2024-07-21 22:23:56 发布

阅读量198

点赞数

文章标签： java 面试开发语言后端设计模式

本文链接：https://blog.csdn.net/cgmx551/article/details/123337801

版权

设计模式是编程解决实际问题或类似问题的最佳实践，Java编程中处处都是对象，对象需要创建，对象间需要相互调用，对象的模板是类，类与类需要相互关联引用，如何通用解决上述问题，经过长时间的编程实践总结出来的统筹方法就是设计模式，可以理解设计模式就是如何写出高效程序解决某类问题。

设计模式分为三大类：
创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

设计模式的六大原则
1、开闭原则（Open Close Principle）
开闭原则就是对功能扩展开放，对修改代码关闭。系统扩展功能是，不需要修改原来的代码，只需新增代码便可。想学习交流HashMap,nginx、dubbo、Spring MVC,分布式、高性能高可用、MySQL，redis、jvm、多线程、netty、kafka、的加尉（同英）：1253431195 扩列获取资料学习，无工作经验不要加哦！

2、里氏代换原则（Liskov Substitution Principle）
里氏代换原则(Liskov Substitution Principle LSP)面向对象设计的基本原则之一。里氏代换原则中说，能使用父类的地方一定可以使用子类替代。 LSP是继承复用的基石，里氏代换原则是对“开-闭”原则的补充。

3、依赖倒转原则（Dependence Inversion Principle）
是开闭原则的基础，具体内容：实现接口编程，依赖于抽象类或接口而不依赖于具体类，系统功能扩展时可以使用具体类扩展。

4、接口隔离原则（Interface Segregation Principle）
使用多个隔离的接口，比使用单个接口要好，原则是：降低依赖，降低耦合。

5、迪米特法则（最少知道原则）（Demeter Principle）
最少知道原则，就是说：一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。

6、合成复用原则（Composite Reuse Principle）
原则是尽量使用合成/聚合的方式，而不是使用继承。

创建类模式
一、简单工厂模式
定义一接口，不同实现类完成不同功能，提供统一构造这些具体类的工厂类。
package com.test.demo;

public interface ISendMsg {
public boolean sendMsg(String msg);
}

package com.test.demo;

public class SmsSendMsg implements ISendMsg{

@Override
public boolean sendMsg(String msg) {
	System.out.println("发送短信...");
	return true;
}

}

package com.test.demo;

public class WeiXinSendMsg implements ISendMsg{

@Override
public boolean sendMsg(String msg) {
	System.out.println("发送微信...");
	return true;
}

}

package com.test.demo;

public class SendMsgFactory {
public static ISendMsg sendMsg(String type,String msg)
{
if(“sms”.equals(type))
{
ISendMsg send = new SmsSendMsg();
return send;
}
if(“weixin”.equals(type))
{
ISendMsg send = new WeiXinSendMsg();
return send;
}
return false;
}

public static void main(String[] args)
{
	ISendMsg send1 = SendMsgFactory.sendMsg("weixin",);
	ISendMsg send2 = SendMsgFactory.sendMsg("sms");
}

}

简单工厂类不能体现开闭原则，如果再增加一个发送邮件的实现类，需要修改工厂类。想学习交流HashMap,nginx、dubbo、Spring MVC,分布式、高性能高可用、MySQL，redis、jvm、多线程、netty、kafka、的加尉（同英）：1253431195 扩列获取资料学习，无工作经验不要加哦！
package com.test.demo;

public class MailSendMsg implements ISendMsg{

@Override
public boolean sendMsg(String msg) {
	System.out.println("发送微信...");
	return true;
}

}

package com.test.demo;

public class SendMsgFactory {
public static boolean sendMsg(String type,String msg)
{
if(“sms”.equals(type))
{
ISendMsg send = new SmsSendMsg();
return send.sendMsg(msg);
}
if(“weixin”.equals(type))
{
ISendMsg send = new WeiXinSendMsg();
return send.sendMsg(msg);
}
if(“mail”.equals(type))
{
ISendMsg send = new MailSendMsg();
return send.sendMsg(msg);
}
return false;
}

public static void main(String[] args)
{
	SendMsgFactory.sendMsg("weixin", "Hello WeiXin");
	SendMsgFactory.sendMsg("sms", "Hello ShortMsg");
}

}

二、抽象工厂模式

通过添加工厂接口，相当于抽象工厂实现，当系统扩展时，需要设计具体实现类和对应的工厂实现
package com.test.demo;

public interface ISendMsg {
public boolean sendMsg(String msg);
}

package com.test.demo;

public interface Provider {
public ISendMsg create();
}

package com.test.demo;

public class SmsSendMsg implements ISendMsg{

@Override
public boolean sendMsg(String msg) {
	System.out.println("发送短信...");
	return true;
}

}

package com.test.demo;

public class SmsFactory implements Provider{

@Override
public ISendMsg create() {
	return new SmsSendMsg();
}

}

package com.test.demo;

public class WeiXinSendMsg implements ISendMsg{

@Override
public boolean sendMsg(String msg) {
	System.out.println("发送微信...");
	return true;
}

}

package com.test.demo;

public class WeiXinFactory implements Provider{

@Override
public ISendMsg create() {
	return new WeiXinSendMsg();
}

}

package com.test.demo;

public class MailSendMsg implements ISendMsg{

@Override
public boolean sendMsg(String msg) {
	System.out.println("发送微信...");
	return true;
}

}

package com.test.demo;

public class MailFactory implements Provider{

@Override
public ISendMsg create() {
	return new MailSendMsg();
}

}

package com.test.demo;

public class Tester {

public static void main(String[] args)
{
	Provider smsPvdr = new SmsFactory();
	smsPvdr.create().sendMsg("短信服务...");
	
	Provider wxPvdr = new WeiXinFactory();
	wxPvdr.create().sendMsg("微信服务...");
}

}

三、单例模式
最安全实现单例模式是使用内部类

package com.test.demo;

public class Singleton {
/* 私有构造方法，防止被实例化 */
private Singleton() {

}

/* 此处使用一个内部类来维护单例 */ 
private static class SingletonFactory {  
	private static Singleton instance = new Singleton();  
}

/* 获取实例 */  
public static Singleton getInstance() {  
	return SingletonFactory.instance;  
}

}

四、Builder模式
将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示

package com.test.demo;

public class HtmlPage {
private String top = null;
private String left = null;
private String main = null;
private String bottom = null;
public String getTop() {
return top;
}
public void setTop(String top) {
this.top = top;
}
public String getLeft() {
return left;
}
public void setLeft(String left) {
this.left = left;
}
public String getMain() {
return main;
}
public void setMain(String main) {
this.main = main;
}
public String getBottom() {
return bottom;
}
public void setBottom(String bottom) {
this.bottom = bottom;
}

}

package com.test.demo;

public interface IHtmlBuilder {
public void buildTopPart();
public void buildLeftPart();
public void buildMainPart();
public void buildBottomPart();

public HtmlPage getPage();

}

package com.test.demo;

public class EasyuiBuilder implements IHtmlBuilder{
private HtmlPage page = null;

public EasyuiBuilder()
{
	page = new HtmlPage();
}

@Override
public void buildTopPart() {
	page.setTop("Easyui top part");
}

@Override
public void buildLeftPart() {
	page.setLeft("Easyui left part");
}

@Override
public void buildMainPart() {
	page.setMain("Easyui main part");
}

@Override
public void buildBottomPart() {
	page.setBottom("Easyui bottom part");
}

@Override
public HtmlPage getPage() {
	return page;
}

}

package com.test.demo;

public class VueBuilder implements IHtmlBuilder{
private HtmlPage page = null;

public VueBuilder()
{
	page = new HtmlPage();
}

@Override
public void buildTopPart() {
	page.setTop("Vue top part");
}

@Override
public void buildLeftPart() {
	page.setLeft("Vue left part");
}

@Override
public void buildMainPart() {
	page.setMain("Vue main part");
}

@Override
public void buildBottomPart() {
	page.setBottom("Vue bottom part");
}

@Override
public HtmlPage getPage() {
	return page;
}

}

package com.test.demo;

public class Director {
private IHtmlBuilder builder = null;

public void setBuilder(IHtmlBuilder builder) {
	this.builder = builder;
}

public void build()
{
	builder.buildTopPart();
	builder.buildLeftPart();
	builder.buildMainPart();
	builder.buildBottomPart();
}

public HtmlPage getPage() {
	return builder.getPage();
}

}

五、原型模式
该模式的思想就是将一个对象作为原型，对其进行复制、克隆，产生一个和原对象类似的新对象。
浅复制：将一个对象复制后，基本数据类型的变量都会重新创建，而引用类型，指向的还是原对象所指向的。
深复制：将一个对象复制后，不论是基本数据类型还有引用类型，都是重新创建的。简单来说，就是深复制进行了完全彻底的复制，而浅复制不彻底。想学习交流HashMap,nginx、dubbo、Spring MVC,分布式、高性能高可用、MySQL，redis、jvm、多线程、netty、kafka、的加尉（同英）：1253431195 扩列获取资料学习，无工作经验不要加哦！

package com.test.demo;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class ProtoType implements Cloneable,Serializable{
private static final long serialVersionUID = 2743227770097456357L;

/* 浅复制 */  
public Object clone() throws CloneNotSupportedException {  
	ProtoType proto = (ProtoType) super.clone();  
	return proto;  
}  

/* 深复制 */  
public Object deepClone() throws IOException, ClassNotFoundException {  
	/* 写入当前对象的二进制流 */  
	ByteArrayOutputStream bos = new ByteArrayOutputStream();  
	ObjectOutputStream oos = new ObjectOutputStream(bos);  
	oos.writeObject(this);  
	
	/* 读出二进制流产生的新对象 */  
	ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());  
	ObjectInputStream ois = new ObjectInputStream(bis);  
	return ois.readObject();  
}

}

结构型模式
适配器模式、装饰模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

[图片上传中…(image.png-821cee-1646642503267-0)]

六、适配器模式
类适配器模式：扩展一个类的功能方法，通过继承这个类再实现一个接口

package com.test.demo;

public class SourceObj {
public void method1()
{
System.out.println(“method1…”);
}
}

package com.test.demo;

public interface Targetable {
public void method1();
public void method2();
}

package com.test.demo;

public class Adapter extends SourceObj implements Targetable{

@Override
public void method2() {
	System.out.println("method2...");
}

}

package com.test.demo;

public class Tester {
public static void main(String[] args) {
Targetable target = new Adapter();
target.method1();
target.method2();
}
}

对象的适配器模式
基本思路和类的适配器模式相同，只是将Adapter类作修改，这次不继承SourceObj类，而是持有Source类的实例，以达到解决兼容性的问题。

package com.test.demo;

public class SourceObj {
public void method1()
{
System.out.println(“method1…”);
}
}

package com.test.demo;

public interface Targetable {
public void method1();
public void method2();
}

package com.test.demo;

public class Adapter implements Targetable{
private SourceObj source;

public Adapter(SourceObj source)
{
	this.source = source;
}

public void method1()
{
	source.method1();
}

@Override
public void method2() {
	System.out.println("method2...");
}

}

七、装饰模式
装饰模式动态地给一个对象增加一些新的功能，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例

package com.test.demo;

public interface ILog {
public void log(String msg);
}

package com.test.demo;

public class UserMng implements ILog{

@Override
public void log(String msg) {
	System.out.println("UserMng log...");
}

}

package com.test.demo;

public class Decorator implements ILog{
private UserMng umng = null;

public Decorator(UserMng umng)
{
	this.umng = umng;
}

@Override
public void log(String msg) {
	System.out.println("before decorator!");  
	umng.log("Hello UserMng");  
	System.out.println("after decorator!"); 
}

}

package com.test.demo;

public class DecoratorTest {

public static void main(String[] args) {
	UserMng umng = new UserMng();
	Decorator deco = new Decorator(umng);
	deco.log("Hello");
}

}

八、代理模式
代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。通俗的来讲代理模式就是我们生活中常见的中介。

package com.test.demo;

public interface Sourceable {
public void method();
}

package com.test.demo;

public class Source implements Sourceable{

@Override
public void method() {
	System.out.println("Source method invoke...");
}

}
package com.test.demo;

package com.test.demo;

public class Proxy implements Sourceable{
private Source source = null;

public Proxy()
{
	super();
	this.source = new Source();
}

@Override
public void method() {
	System.out.println("before invoke");
	source.method();
	System.out.println("after invoke");
	
}

}

package com.test.demo;

public class ProxyTest {

public static void main(String[] args) {
	Sourceable source = new Proxy();  
	source.method();
}

}

代理模式和装饰模式非常类似，甚至代码都类似。二者最主要的区别是：代理模式中，代理类对被代理的对象有控制权，决定其执行或者不执行。而装饰模式中，装饰类对代理对象没有控制权，只能为其增加一层装饰，以加强被装饰对象的功能，仅此而已。

九、Facade模式（门面模式）
隐藏了系统的复杂性，并向客户端提供了一个可以访问系统的接口。这种类型的设计模式属于结构性模式。为子系统中的一组接口提供了一个统一的访问接口，这个接口使得子系统更容易被访问或者使用。

package com.test.demo;

public class CPU {
public void startup(){
System.out.println(“cpu startup!”);
}

public void shutdown(){  
	System.out.println("cpu shutdown!");  
}

}

package com.test.demo;

public class Disk {
public void startup(){
System.out.println(“memory startup!”);
}

public void shutdown(){  
	System.out.println("memory shutdown!");  
}

}

package com.test.demo;

public class Memory {
public void startup(){
System.out.println(“disk startup!”);
}

public void shutdown(){  
	System.out.println("disk shutdown!");  
}

}

package com.test.demo;

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 computer finished!");  
}  

public void shutdown(){  
	System.out.println("begin to close the computer!");  
	cpu.shutdown();  
	memory.shutdown();  
	disk.shutdown();  
	System.out.println("computer closed!");  
}

}

package com.test.demo;

public class Test {

public static void main(String[] args) {
	Computer computer = new Computer();  
	computer.startup();  
	computer.shutdown(); 
}

}

十、桥接模式
桥接模式（Bridge)是一种结构型设计模式。Bridge模式基于类的最小设计原则，通过使用封装、聚合及继承等行为让不同的类承担不同的职责。它的主要特点是把抽象(Abstraction)与行为实现(Implementation)分离开来，从而可以保持各部分的独立性以及应对他们的功能扩展。

package com.test.demo;

import java.sql.Connection;

public interface IGetConn {
public Connection getConnection();
}

package com.test.demo;

import java.sql.Connection;

public abstract class Bridge {
private IGetConn getconn;

public IGetConn getGetconn() {
	return getconn;
}

public void setGetconn(IGetConn getconn) {
	this.getconn = getconn;
}

protected Connection getConnection()
{
	return getconn.getConnection();
}

}

package com.test.demo;

import java.sql.Connection;

public class MySqlConn implements IGetConn{

@Override
public Connection getConnection() {
	return null;
}

}
package com.test.demo;

import java.sql.Connection;

public class OracleConn implements IGetConn{

@Override
public Connection getConnection() {
	return null;
}

}
package com.test.demo;

import java.sql.Connection;

public class DetailBridge extends Bridge{
protected Connection getConnection()
{
return super.getGetconn().getConnection();
}
}

package com.test.demo;

public class BridgeTest {

public static void main(String[] args) {
	Bridge bdg = new DetailBridge();
	
	//调用第一个实现类
	bdg.setGetconn(new MySqlConn());
	bdg.getConnection();
	
	//调用第二个实现类
	bdg.setGetconn(new OracleConn());
	bdg.getConnection();
}

}

十一、组合模式
组合模式允许你将对象组合成树形结构来表现”部分-整体“的层次结构，使得客户以一致的方式处理单个对象以及对象的组合。

package com.test.demo;

import java.util.ArrayList;
import java.util.List;

public class TreeNode {
private Integer id = null;
private String name = null;
private List child = new ArrayList();

public TreeNode(String name)
{
	this.name =name;
}

public Integer getId() {
	return id;
}
public void setId(Integer id) {
	this.id = id;
}
public String getName() {
	return name;
}
public void setName(String name) {
	this.name = name;
}
public List<TreeNode> getChild() {
	return child;
}
public void setChild(List<TreeNode> child) {
	this.child = child;
}
public void remove(TreeNode tn)
{
	this.child.remove(tn);
}
public void add(TreeNode tn)
{
	this.child.add(tn);
}

}

package com.test.demo;

public class Tree {
private String name = null;
private TreeNode root = null;

public Tree(String name)
{
	this.name = name;
	root = new TreeNode(name);
}
public String getName() {
	return name;
}
public void setName(String name) {
	this.name = name;
}
public TreeNode getRoot() {
	return root;
}
public void setRoot(TreeNode root) {
	this.root = root;
}

}

行为模式
十二、观察者模式
在对象之间定义了一对多的依赖，这样一来，当一个对象改变状态，依赖它的对象会收到通知并自动更新。

package com.test.demo;

public interface Observerable {
public void registerObserver(Observer o);
public void removeObserver(Observer o);
public void notifyObserver();
}

package com.test.demo;

public interface Observer {
public void update(String message);
}

package com.test.demo;

import java.util.ArrayList;
import java.util.List;

public class MailServer implements Observerable{
private List list;
private String msg = null;

public MailServer()
{
	list = new ArrayList<Observer>();
}

@Override
public void registerObserver(Observer o) {
	list.add(o);
}

@Override
public void removeObserver(Observer o) {
	list.remove(o);
}

@Override
public void notifyObserver() {
	for(Observer o:list)
		o.update(msg);
}

public void setMsg(String msg)
{
	this.msg = msg;
}

}

package com.test.demo;

public class User implements Observer{
private String name = null;

public User(String name)
{
	this.name = name;
}

@Override
public void update(String message) {
	System.out.println(name + " 收到消息 msg="+message);
}

}

package com.test.demo;

public class Tester {

public static void main(String[] args) {
	MailServer mail = new MailServer();
	
	User u1 = new User("Java");
	mail.registerObserver(u1);
	
	User u2 = new User("Python");
	mail.registerObserver(u2);
	
	mail.setMsg("Hello All");
	mail.notifyObserver();
	
	mail.removeObserver(u2);
	
	mail.setMsg("It is fine day!");
	mail.notifyObserver();
}

}

十三、责任链模式
责任链模式，有多个对象，每个对象持有对下一个对象的引用，这样就会形成一条链，请求在这条链上传递，直到某一对象决定处理该请求。

package com.test.demo;

public interface Handler {
public void operator();
}
package com.test.demo;

public abstract class AbstractHandler {
private Handler handler;

public Handler getHandler() {  
	return handler;  
}  

public void setHandler(Handler handler) {  
	this.handler = handler;  
}

}

package com.test.demo;

public class MyHandler extends AbstractHandler implements Handler{
private String name;

public MyHandler(String name) {  
	this.name = name;  
}  

@Override  
public void operator() {  
	System.out.println(name+"deal!");  
	if(getHandler()!=null){  
		getHandler().operator();  
	}  
}

}

package com.test.demo;

public class Test {
public static void main(String[] args) {
MyHandler h1 = new MyHandler(“h1”);
MyHandler h2 = new MyHandler(“h2”);
MyHandler h3 = new MyHandler(“h3”);

	h1.setHandler(h2);  
	h2.setHandler(h3);  
	
	h1.operator();  
}

}

cgmx551

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java常用的设计模式

设计模式是编程解决实际问题或类似问题的最佳实践，Java编程中处处都是对象，对象需要创建，对象间需要相互调用，对象的模板是类，类与类需要相互关联引用，如何通用解决上述问题，经过长时间的编程实践总结出来的统筹方法就是设计模式，可以理解设计模式就是如何写出高效程序解决某类问题。设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。行为型模式，共十一种：策略模式、模板
复制链接

扫一扫