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;
public interface Boss {
Boolean doCheck(Info info );//里面是个信息，进行过滤
}
然后我们再写一个类，继承这个接口，并且重写方法，写出约束的条件
package com.zrl.dao;
import com.zrl.pojo.Info;
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;
import java.util.ArrayList;
import java.util.List;
import com.zrl.pojo.Info;
public class ShiLi {
private ShiLi() {};
public static List list=new ArrayList();
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;
public abstract class Yuan {
protected Object sum;
public Object getSum() {
return this.sum;
}
}
2.然后我们在写一个具体的某一件事，
package com.gcz.dao;
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 list=new ArrayList();
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();
}
}
最后是运行结果：
今天的代码到这里就结束啦！ 咱们下期见
今天也要记得微笑呀.
