常见的设计模式（下）

hello，家人们好，今天给大家带来上节课未讲完的 常见的设计模式

目录

一.🥘🥘抽象工厂

二.🍟🍟责任链模式

责任链模式的概念

责任链模式的使用场景

三.🍕🍕观察者模式

观察者模式的概念

---

一.🥘🥘抽象工厂

工厂分为两种，一种是普通工厂，一种是抽象工厂，

抽象工厂用于生成指定产品族。一个产品族中包括多种产品.

我们先来建一个总父类，叫Boss，

package com.zking.dao;
 
public abstract class Boss {
	
	public abstract One a();
	
	public abstract Tow b();
	
	public  static APhone aphone=new APhone();
	public  static SunPhone sumphone=new SunPhone();
	
	public final static int Aone=1;
	public final static int Stow=2;
	
	
	public static Boss getType(int type) {
	switch (type) {
	case 1:
		return aphone;
	case 2:
		return sumphone;
	default:
		return null;
	
	}	
	
}
	
	
 
}

One

package com.zking.dao;
 
public abstract class One {
	
	abstract String price();
 
}

然后指定两个规则，如果你的产品需要交易的话，就必须有我这两个东西

Tow

package com.zking.dao;
 
public abstract class Tow {
 
	abstract String name();
}

然后这边模拟两个公司，里面需要有我规定的那两个规则

package com.zking.dao;
 
public class APhone extends Boss{
 
	@Override
	public One a() {
		return new AOnePrice();
	}
 
	@Override
	public Tow b() {
		return new ATowName();
	}
	
 
}

第二家公司

package com.zking.dao;
 
public class SunPhone extends Boss{
 
	@Override
	public One a() {
		return new SunOnePrice();
	}
 
	@Override
	public Tow b() {
		return new SumTowName();
	}
 
}

第一家公司的两条规则详情

package com.zking.dao;
 
public class AOnePrice extends One{
 
	@Override
	String price() {
	 return "这件衣服345元";
		
	}
	
	
 
	
}

package com.zking.dao;
 
public class ATowName extends Tow{
 
	@Override
	String name() {
		return "这件是连衣裙";
	}
 
}

第二家公司对于产品生成的详情

package com.zking.dao;
 
public  class SunOnePrice extends One{
 
	@Override
	String price() {
	return "这个是888元";
	}
	
	
	
 
}

package com.zking.dao;
 
public class SumTowName extends Tow{
 
	@Override
	String name() {
		return "这个手机是三星";
	}
 
}

最后我们来测试一下

package com.zking.dao;
 
public class Test {
	
	public static void main(String[] args) {
//		Boss aphone=Boss.getType(Boss.Aone);
//		One one=aphone.a();
//		Tow tow=aphone.b();
//		System.out.println(one.price());
//		System.out.println(tow.name());
	
	
		Boss aphone=Boss.getType(Boss.Stow);
		One one=aphone.a();
		Tow tow=aphone.b();
		System.out.println(one.price());
		System.out.println(tow.name());
	
	}
 
}

最后运行结果是：

 

二.🍟🍟责任链模式

• 责任链模式的概念

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

• 责任链模式的使用场景

web容器中的过滤器算是责任链模式的一个经典场景

另外举个例子：当在论坛上提交内容时，论坛系统需要对一些关键词进行处理，看看有没有包含一些敏敢词汇，而这些敏感词汇我们可以使用责任链模式进行处理.

eg:

我们先写一个实体类，并且写出它的无参构造和有参构造，还有toString打印方法，还有get/set方法

package com.zrl.pojo;
 
public class Info {
	
	private String Info;
	
	public Info() {
		// TODO Auto-generated constructor stub
	}
 
	public Info(String info) {
		super();
		Info = info;
	}
 
	@Override
	public String toString() {
		return "Info [Info=" + Info + "]";
	}
 
	public String getInfo() {
		return Info;
	}
 
	public void setInfo(String info) {
		Info = info;
	}
	
	
	
 
}

然后我们定义一个接口，进行一个约束

package com.zrl.dao;
 
import com.zrl.pojo.Info;
 
/**
 * 责任链模式，一个接口，进行约束
 * @author zjjt
 *
 */
public interface Boss {
	
	Boolean doCheck(Info info );//里面是个信息，进行过滤
}

然后我们再写一个类，继承这个接口，并且重写方法，写出约束的条件

package com.zrl.dao;
 
import com.zrl.pojo.Info;
 
/**
 * 实现这个接口，需要重写这个方法,同时写约束条件
 * @author zjjt
 *
 */
public class Eg implements Boss{
 
	
	public Boolean doCheck(Info info) {
		String in=info.getInfo();
		
		if(!in.contains("sb")&&!in.contains("￥")) {
			return true;
		}
		
		in=in.replace("sb", "可爱");//不允许出现sb，出现了就替换成可爱
		in=in.replace("￥","~");
		info.setInfo(in);
		return false;
	}
 
	
}

然后写一个单例，里面还写方法

package com.zrl.dao;
/**
 * 将Filter组织成一个链条
 */
import java.util.ArrayList;
import java.util.List;
 
import com.zrl.pojo.Info;
 
public class ShiLi {
	
	private ShiLi() {};
	
	public static List<Boss> list=new ArrayList<Boss>();
	
	public static ShiLi test=new ShiLi();
	
	
	public static ShiLi getTest() {
		return test;
	}
	
	
	public ShiLi addList( Boss b) {
		list.add(b);
		return this;
	}
	
	
	public Info doChecks(final Info a) {
		for(Boss b:list) {
			Boolean o=b.doCheck(a);
			if(!o) {
				return a;
			}
		}
		return a;
	}
 
}

最后是测试环节

package com.zrl.dao;
 
import com.zrl.pojo.Info;
 
public class Test {
	
	public static void main(String[] args) {
		Info f=new Info();
		f.setInfo("sb,哈哈,你爱￥吗，我爱￥");
		
		ShiLi s=ShiLi.getTest();
		
		s.addList(new Eg()).doChecks(f);
		
		
		System.out.println(f.getInfo());
	}
 
}

最后的运行结果如下：

 

三.🍕🍕观察者模式

• 观察者模式的概念

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

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

eg:

1.首先，我们先写一个事件源

package com.gcz.dao;
/**
 * 事件源
 * @author zjjt
 *
 */
public abstract class Yuan {
	
	protected  Object sum;
 
	public Object getSum() {
		return this.sum;
	}
	
	
	
 
}
 

2.然后我们在写一个具体的某一件事，

package com.gcz.dao;
/**
 * 某一个具体的事件
 * @author zjjt
 *
 */
public class ShiJian extends Yuan{
	
	long timestamp;
	
	
	public ShiJian(Object sum) {
		this.timestamp=System.currentTimeMillis();
		this.sum=sum;
	}
 
}

3.定义一个接口

package com.gcz.dao;
 
public interface Boss {
	
	void doSoS(ShiJian p);
 
}

4.写两个人物和对应的事件

package com.gcz.dao;
 
public class One implements Boss{
 
	@Override
	public void doSoS(ShiJian p) {
		System.out.println("我是经理，请问发生什么事了吗？");
		
	}
	
	
 
}

package com.gcz.dao;
 
public class Two implements Boss{
 
	@Override
	public void doSoS(ShiJian p) {
		System.out.println("我是导购员，请问有什么可以帮到你吗？");
	}
	
	
 
}

5.使用单例

package com.gcz.dao;
 
import java.util.ArrayList;
import java.util.List;
 
public class ShiLi {
	
	
	public static  ShiLi s=new ShiLi();
 
	
	private List<Boss> list=new ArrayList<Boss>();
	
	
	public void addBoss( Boss b) {
		list.add(b);
	}
	
	
	public void ringSoS() {
		ShiJian j=new ShiJian(this);
		
		for (Boss boss : list) {
			boss.doSoS(j);
		}
		
	}
    
}

6.最后我们来测试一下

package com.gcz.dao;
 
public class Test {
	
	public static void main(String[] args) {
		ShiLi s= new ShiLi();
		
		s.addBoss(new One());
		s.addBoss(new Two());
		s.ringSoS();
		
	}
 
}

最后是运行结果：

 

今天的代码到这里就结束啦！ 咱们下期见

今天也要记得微笑呀.