java常见设置模式2

最新推荐文章于 2024-07-12 19:11:36 发布

liwangdeng

最新推荐文章于 2024-07-12 19:11:36 发布

阅读量187

点赞数

文章标签： java 开发语言

本文链接：https://blog.csdn.net/liwangdeng/article/details/125397948

版权

本文介绍了三种重要的设计模式：抽象工厂模式用于创建一系列相关或相互依赖的对象；责任链模式通过对象之间的链式处理请求，实现请求的透明传递；观察者模式定义了一对多的依赖关系，使得当一个对象状态改变时，其依赖者也会被通知并自动更新。这些模式在软件开发中提供了灵活性和可扩展性。

摘要由CSDN通过智能技术生成

一.抽象工厂

先定义抽象类

1.鼠标的抽象类（相当于给鼠标定义一个规范或方法）

package aa;

public abstract class Mouse {
	abstract String getInfo();

}

2.键盘的抽象类（同上）

package aa;

public abstract class Keyboard {
	abstract String getIofo();
	//键盘抽象类定义规范，所有键盘都要遵循这个规范

}

3.定义抽象工厂（就是定义完成制造键盘，鼠标工作的方法，和对象）

package aa;
/**
 * 
 * @author zjjt
 *工厂类，有制造鼠标和键盘的方法，得到工厂的方法，有工厂实现这个类
 */
public abstract class PcFactory {
	//这两个方法最重要，简单来说一个工厂需要有制造鼠标，键盘的方法，由子类实现
	public abstract Mouse makeMouse();
	public abstract Keyboard makeKeyboard();
	//两个实现制造的工厂
	private static HpFactory hpFactory = new HpFactory();
	private static LogicFactory logicFactory = new LogicFactory();
	//定义编号，1代表hp，2代表lg
	public final static int PC_TYPE_HP = 1;
	public final static int PC_TYPE_LG = 2;
	public static PcFactory getPcFactory(int pcType) {
		switch (pcType) {
		case 1:
			return hpFactory;
		case 2:
			return logicFactory;

		default:
			return null;
		}
	}
	 

}

注：常量要用public

再写子类

1.创建子类工厂（子类工厂需要继承工厂抽象类，实现抽象方法，返回一个new的制造的该品牌键盘类和该品牌鼠标类）

hp工厂

package aa;

public class HpFactory extends PcFactory{

	@Override
	public Mouse makeMouse() {
		// TODO Auto-generated method stub
		return new HpMouse();
	}

	@Override
	public Keyboard makeKeyboard() {
		// TODO Auto-generated method stub
		return new HpKeyboard();
	}


}

lg工厂

package aa;

public class LogicFactory extends PcFactory{
	//继承工厂抽象类，实现制造方法

	@Override
	public Mouse makeMouse() {
		
		return new LogicMouse();
	}

	@Override
	public Keyboard makeKeyboard() {
		
		return new LogicKeyboard();
	}

}

2.使工厂完成自己品牌的制造（继承制造鼠标，键盘的抽象类，实现制造方法）

hp的鼠标

package aa;

public class HpMouse extends Mouse{

	@Override
	//品牌产品继承规范调用方法实现制造，完成自己的品牌产品
	String getInfo() {
		return "HP mouse";
	}

}

hp的键盘

package aa;

public class HpKeyboard extends Keyboard{

	@Override
	String getIofo() {
	
		return "HP keyboard";
	}

}

lg的鼠标

package aa;

public class LogicMouse extends Mouse{

	@Override
	String getInfo() {
		
		return "logic mouse";
	}

}

lg的键盘

package aa;

public class LogicKeyboard extends Keyboard{

	@Override
	String getIofo() {
		
		return "logic keyboard";
	}

}

创建mian类（用于测试）

package aa;

public class Main {
	public static void main(String[] args) {
		//调用PcFactory内的方法，填入品牌编号
		PcFactory HpFactory = PcFactory.getPcFactory(PcFactory.PC_TYPE_HP);
		//调用该编号的工厂，拿到该工厂下的生产类
        Keyboard keyboard = HpFactory.makeKeyboard();
        Mouse mouse = HpFactory.makeMouse();
        //生产类调用制造方法，完成生产
        System.out.println(keyboard.getIofo());
        System.out.println(mouse.getInfo());
	}

}

理解和运用抽象类将会让我们的项目更加灵活。

二.责任链模式

概念：责任链模式是一个对象的行为模式，很多对象之间形成一条链条，处理请求在这个链条上进行传递，直到责任链的上的某个对象决定处理请求（也可扩展为几个对象处理），这个过程对于用户来说是透明的，也就是说用户并不需要知道是责任链上的哪个对象处理的请求，对请求是否处理由链条上的对象自己决定。（例如击鼓传花）

使用场景：web容器中的过滤器算是责任链模式的一个经典场景。另外举个例子：当在论坛上提交内容时，论坛系统需要对一些关键词进行处理，看看有没有包含一些敏感词汇，而这些敏感词汇我们可以使用责任链模式进行处理。

类族：多个类实现一个抽象类或接口这几个类叫类族（多个类具有相同的行为规范）

1.先创建一个实体类（用于存放信息）

package bb;
/**
 * 
 * @author zjjt
 *实体类用于存放信息
 */
public class Message {
	private String content;

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    @Override
    public String toString() {
        return "Message{" +
                "content='" + content + '\'' +
                '}';
    }
    

}

2.创建一个接口（写一个传入限制信息的方法）

package bb;

public interface Filter {
	//创建接口 传入限制规范的信息
	void doFilter(Message message);

}

3.写个替换敏感词的类（实现接口）

package bb;

public class ChackSyntaxFilter implements Filter{

	@Override
	public void doFilter(Message message) {
		//拿到实体类的信息
		String content=message.getContent();
		//将信息替换
		content =content.replace("<","#");
		content =content.replace(">","#");
		//再存入实体类
		message.setContent(content);
	}

}

package bb;

public class WordFilter implements Filter{

	@Override
	public void doFilter(Message message) {
		String content=message.getContent();
		content =content.replace("哈哈哈", "***");
		content =content.replace("是是是", "***");
		message.setContent(content);
		
	}

}

4.写一个过滤器链类

package bb;

import java.util.ArrayList;
import java.util.List;
/**
 * 
 * @author zjjt
 *过滤器链
 */
public class FilterChain {
	//私有化构造
	private FilterChain() {
		// TODO Auto-generated constructor stub
	}
	//链的容器
	private static List<Filter> filters=new ArrayList<Filter>();
	//new一个过滤器链（和上面构造形成单例模式的饥饿模式）
	private static FilterChain instance=new FilterChain();
	//获得一条链
	public static FilterChain getInstance() {
		return instance;
	}
	//将链条加入容器
	public FilterChain add(Filter filter) {
		filters.add(filter);
		return this;
	}
	public Message dofilters(final Message message) {
		//将信息放入链条逐一匹配
		for (Filter f : filters) {
			f.doFilter(message);
		}
	    //将信息返回，便于重复加入方法
		return message;
	}

}

5.验证类

package bb;

public class Main {
public static void main(String[] args) {
	Message msg=new Message();
	//传入值
	msg.setContent("hello,<abc>,哈哈哈");
	//调用方法
	FilterChain fc=FilterChain.getInstance();
	//重复增加
	fc.add(new ChackSyntaxFilter())
	.add(new WordFilter())
	.dofilters(msg);
	System.out.println(msg.getContent());
}
}

三.观察者模式

概念：

观察者模式是对象的行为模式，有时也称为“发布/订阅模式”或者“监听器模式”。

观察者模式定义了观察者和被观察者之间的一对多的关系，让多个观察者对象可以响应一个被观察者对象。

使用场景：比较经典的使用场景，比如：java中的swing包中对事件的处理。浏览器对鼠标，键盘等事件的处理等， spring中的事件发布机制也是使用该模式。