Java设计模式--适配器模式

适配器模式(别名:包装类)

将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

Adapter Pattern(Another Name: wrapper)

Convert the interface of a class into another interface clients expect. Adapter lets classes work together that couldn’t otherwise because of incompatible interface.

类图

模式的结构与使用

由于Java不支持多重继承,即一个类只能有一个父类,所以本节给出适配器模式的类图按着GOF著作的分类属于对象适配器模式的类图,不是类适配器模式的类图。
对象适配器模式的结构中包括三个角色。

  • 目标(Target):目标是一个接口,该接口是客户想使用的接口。
  • 被适配者(Adaptee):被适配者是一个已经存在的接口或抽象类,这个接口或抽象类需要适配。
  • 适配器(Adapter):适配器是一个类,该类实现了目标接口并包含有被适配者的引用,即适配器的职责是对被适配者接口或是抽象类于目标接口进行适配。

简单的例子

Target的抽象类ThreeElectricOutlet.java

1
2
3
4
5
package Adapter;
public interface ThreeElectricOutlet {
public abstract void connectElectricCurrent();
}

Adaptee的接口类TwoElectriOutlet.java

1
2
3
4
5
package Adapter;
public interface TwoElectricOutlet {
public abstract void connectElectricCurrent();
}

Adapter的实现类ThreeElectricAdapter.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package Adapter;
public class ThreeElectricAdapter implements ThreeElectricOutlet {
TwoElectricOutlet outlet;
public ThreeElectricAdapter(TwoElectricOutlet outlet) {
this.outlet = outlet;
}
@Override
public void connectElectricCurrent() {
outlet.connectElectricCurrent();
}
}

测试类Application.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
package Adapter;
public class Application {
public static void main(String[] args) {
ThreeElectricOutlet outlet;
Wash wash = new Wash();
outlet = wash;
System.out.println("使用三相插座接通电源:");
outlet.connectElectricCurrent();
TV tv = new TV();
ThreeElectricAdapter adapter = new ThreeElectricAdapter(tv);
outlet = adapter;
System.out.println("使用三相插座接通电源:");
outlet.connectElectricCurrent();
}
}
class Wash implements ThreeElectricOutlet {
String name;
public Wash() {
name = "黄河洗衣机";
}
public Wash(String s) {
name = s;
}
@Override
public void connectElectricCurrent() {
turnOn();
}
private void turnOn() {
System.out.println(name + "开始洗衣服");
}
}
class TV implements TwoElectricOutlet {
String name;
public TV() {
name = "长江电视机";
}
public TV(String s) {
name = s;
}
@Override
public void connectElectricCurrent() {
turnOn();
}
private void turnOn() {
System.out.println(name + "开始放节目");
}
}

适配器的适配程度

1.完全适配

如果目标(Target)接口中的方法数目与配适配者(Adaptee)接口的方法数目相等,那么适配器(Adapter)可将被适配者接口(抽象类)与目标接口进行完全适配。

2.不完全匹配

如果目标(Target)接口中的方法数目少于配适配者(Adaptee)接口的方法数目,那么适配器只能将被适配者接口与目标接口进行部分适配。

3.剩余适配

如果目标(Target)接口中的方法数目大于配适配者(Adaptee)接口的方法数目,那么适配器(Adapter)可将被适配者接口(抽象类)与目标接口进行完全适配,但必须将目标多余的方法给出用户允许的默认实现。

适配器模式的优点

  • 目标(Target)和被适配者(Adaptee)是完全解耦的关系。
  • 适配器模式满足“开-闭原则”。当添加一个实现Adaptee接口的新类时,不必修改Adapter,Adapter就能对这个新类的实例进行适配。

试用适配器模式的情景

  • 用户需要一个类的子类的实例,但不希望与该类的子类形成耦合。
  • 用户需要一个类的子类的实例,但用户不知道该类有哪些子类可用。

下载源码请到

MyGitHub

Java设计模式--观察者模式

观察者模式(别名:依赖,发布-订阅)

定义对象间的一种一对多的依赖关系,当一个对象的状态发生变化时,所有依赖它的对象都得到通知并被自动更新。

Observer Pattern(Another Name: Dependents, Publish-Subscribe)

Define a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.

类图

模式的结构与使用

观察者模式的结构中包括四个角色。

  • 主题(Subject):主题是一个接口,该接口规定了具体主题需要实现的方法,比如,添加、删除观察者以及通知观察者更新数据的方法。
  • 具体主题(Concrete Subject):具体主题是实现主题接口类的一个实例,该实例包含有可以经常发生变化的数据。具体主题需使用一个集合,比如ArrayList,存放观察者的引用,以便数据变化时通知具体观察者。
  • 观察者(Observer):观察者一个接口或者抽象类,该接口规定了具体观察者用来更新数据的方法。
  • 具体观察者(Concrete Observer):具体观察者是实现观察者接口类的一个实例。具体观察者包含有可以存放具体主题引用的主题接口变量,以便具体观察者让具体主题将自己的引用添加到具体主题中,使自己成为它的观察者,或让这个具体主题将自己从具体主题的集合中删除,使自己不再是它的观察者。

简单的例子(推数据)

Subject接口类Subject.java

1
2
3
4
5
6
7
package Observer;
public interface Subject {
public void addObserver(Observer o);
public void deleteObserver(Observer o);
public void notifyObservers();
}

ConcreteSubject的实现类SeekJobCenter.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
package Observer;
import java.util.ArrayList;
public class SeekJobCenter implements Subject {
String mess;
ArrayList<Observer> personList;
boolean changed;
public SeekJobCenter() {
personList = new ArrayList<Observer>();
mess = "";
changed = false;
}
@Override
public void addObserver(Observer o) {
if (!personList.contains(o)) {
personList.add(o);
}
}
@Override
public void deleteObserver(Observer o) {
if (personList.contains(o)) {
personList.remove(o);
}
}
@Override
public void notifyObservers() {
if (changed) {
for (int i = 0; i < personList.size(); i++) {
Observer o = personList.get(i);
o.hearTelephone(this.mess);
}
changed = false;
}
}
public void giveNewMessage(String str) {
if (str.equals(mess)) {
System.out.println("重复信息");
changed = false;
} else {
this.mess = str;
changed = true;
}
}
}

Observer的接口类Observer.java

1
2
3
4
5
package Observer;
public interface Observer {
public void hearTelephone(String mess);
}

ConcreteObserver的实现类UniversityStudent.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package Observer;
public class UniversityStudent implements Observer {
Subject subject;
public UniversityStudent(Subject subject) {
this.subject = subject;
subject.addObserver(this);
}
@Override
public void hearTelephone(String mess) {
System.out.println("我是一个大学生");
System.out.println(mess);
}
}

ConcreteObserver的实现类MiddleSchoolStudent.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package Observer;
public class MiddleSchoolStudent implements Observer {
Subject subject;
public MiddleSchoolStudent(Subject subject) {
this.subject = subject;
subject.addObserver(this);
}
@Override
public void hearTelephone(String mess) {
System.out.println("我是一名中学生");
if (mess.contains("中学生")) {
System.out.println(mess);
} else {
System.out.println("我是中学生,这次信息中没有我需要的信息");
}
}
}

测试类Application.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package Observer;
public class Application {
public static void main(String[] args) {
SeekJobCenter center = new SeekJobCenter();
new UniversityStudent(center);
new MiddleSchoolStudent(center);
center.giveNewMessage("大学生工作");
center.notifyObservers();
center.giveNewMessage("大学生工作");
center.notifyObservers();
center.giveNewMessage("中学生工作");
center.notifyObservers();
}
}

观察者模式中的“推”数据与“拉”数据

1.推数据方式

推数据方式是指具体主题将变化后的数据全部交给具体观察者,即将变化后的数据传给具体观察者用于更新数据方法的参数。当具体主题认为具体观察者需要这些变化后的全部数据时往往采用推数据方式。

2.拉数据方式

拉数据方式是指具体主题不将变化后的数据交给具体观察者,而是提供了获得这些数据的方法,具体观察者在得到通知后,可以调用具体主题提供的方法得到数据(观察者自己数据“拉”过来),但需要自己判断数据是否发生变化。当具体主题不知道具体观察者是需要这些变换后的数据时往往采用拉数据的方式。

简单的例子(拉数据)

Subject接口类Subject.java

1
2
3
4
5
6
7
package ObserverPull;
public interface Subject {
public void addObserver(Observer o);
public void deleteObserver(Observer o);
public void notifyObserver();
}

ConcreteSubject的实现类ShopSubject.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
package ObserverPull;
import java.util.ArrayList;
public class ShopSubject implements Subject {
String goodsName;
double oldPrice, newPrice;
public String getGoodsName() {
return goodsName;
}
public double getOldPrice() {
return oldPrice;
}
public double getNewPrice() {
return newPrice;
}
public ArrayList<Observer> getCustomerList() {
return customerList;
}
ArrayList<Observer> customerList;
public ShopSubject() {
customerList = new ArrayList<Observer>();
}
@Override
public void addObserver(Observer o) {
if (!customerList.contains(o)) {
customerList.add(o);
}
}
@Override
public void deleteObserver(Observer o) {
if (customerList.contains(o)) {
customerList.remove(o);
}
}
@Override
public void notifyObserver() {
for (int i = 0; i < customerList.size(); i++) {
customerList.get(i).update();
}
}
public void setDiscountGoods(String name, double oldP, double newP) {
goodsName = name;
oldPrice = oldP;
newPrice = newP;
notifyObserver();
}
}

Observer的接口类Observer.java

1
2
3
4
5
package ObserverPull;
public interface Observer {
public abstract void update();
}

ConcreteObserver的实现类CustomerOne.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package ObserverPull;
public class CustomerOne implements Observer {
Subject subject;
String goodsName,personName;
public CustomerOne(Subject subject, String personName) {
this.subject = subject;
this.personName = personName;
subject.addObserver(this);
}
@Override
public void update() {
if (subject instanceof ShopSubject) {
goodsName = ((ShopSubject) subject).getGoodsName();
System.out.println(personName + "只对打折商品的名字感兴趣");
System.out.println("打折商品是:" + goodsName);
}
}
}

ConcreteObserver的实现类CustomerTwo.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package ObserverPull;
public class CustomerTwo implements Observer {
Subject subject;
String personName;
double oldP,newP;
public CustomerTwo(Subject subject, String personName) {
this.subject = subject;
this.personName = personName;
subject.addObserver(this);
}
@Override
public void update() {
if (subject instanceof ShopSubject) {
oldP = ((ShopSubject) subject).getOldPrice();
newP = ((ShopSubject) subject).getNewPrice();
System.out.println(personName + "只对商品的新旧价格感兴趣");
System.out.println("商品旧价格是:" + oldP);
System.out.println("商品新价格是:" + newP);
}
}
}

测试类Application.java

1
2
3
4
5
6
7
8
9
10
11
12
package ObserverPull;
public class Application {
public static void main(String[] args) {
ShopSubject shop = new ShopSubject();
new CustomerOne(shop, "yxx");
new CustomerTwo(shop, "yn");
shop.setDiscountGoods("pen", 20, 10);
shop.setDiscountGoods("相机", 1000, 800);
}
}

观察者与多主体

一个具体观察者可以依赖于多个主题,当所有依赖的任何具体主题的数据发生变化时,该观察者都能得到通知。多主题所涉及的主要问题是观察者如何处理主题中变化后的数据,因为,不同的具体主题所包含有的数据结构可能很大不同。
在处理多主题时,主题应当采用拉数据方式,观察者接口可以将更新数据方法的参数类型设置为主题接口类型,比如update(Subject subject),即具体主题数据放生变化时将自己的引用传递给具体的观察者,然后具体观察者让这个具体主题调用有关的方法返回该具体主题中的数据。

观察者模式的优点

  • 具体主题和具体观察者是松耦合关系。由于主题接口仅仅依赖于观察者接口,因此具体主题只是知道它的观察者是实现观察者接口的某个类的实例,但不需要知道具体哪个类。同样,由于观察者仅仅依赖于主题接口,因此具体观察者只是知道它依赖的主题是实现主题接口的某个类的实例,但不需要知道具体是哪一个类。
  • 观察模式满足“开-闭原则”。主题接口仅仅依赖于观察者接口,这样,就可以让创建具体主题的类也仅仅是依赖于观察者接口,因此如果增加新的实现观察者接口的类,不必修改创建具体主题的类的代码。同样,创建具体观察者的类仅仅依赖于主题接口,如果增加新的实现主题接口的类,也不必修改创建具体观察者类的代码。

适用观察者模式的情景

  • 当一个对象的数据更新时需要通过其他对象,但这个对象又不希望和被通知的那些对象形成紧耦合。
  • 当一个对象的数据更新时,这个对象需要让其他对象也各自更新自己的数据,但这个对象不知道具体有多少对象需要更新数据。

下载源码请到

MyGitHub

Java设计模式--装饰模式

装饰模式(别名:包装类)

动态地给对象添加一些额外的职责。就功能来说装饰模式相比生成子类更为灵活。

Decorator Pattern(Another Name: Wrapper)

Attach additional responsibilities to an object dynamically。Decorators provide a flexible alternative to subclassing for extending functionality.

类图

模式的结构与使用

装饰模式的结构中包括四个角色。

  • 抽象组件(Component):抽象组件是一个抽象类或者接口。抽象组件定义了“被装饰者”需要进行“装饰”的方法。
  • 具体产品(ConcreteComponent):具体组件是抽象组件的一个子类,具体组件的实例称为“被装饰者”。
  • 装饰(Decorator):装饰也是抽象组件的一个子类,但装饰还包含一个抽象组件声明的变量以保存“被装饰者”的引用。装饰可以是抽象类也可以是一个非抽象类,如果是非抽象类,那么该类的实例称作“装饰者”。
  • 具体装饰(ConcreteDecorator):具体装饰是装饰的一个非抽象子类,具体装饰的实例称作“装饰者”。

简单的例子

Component的接口类Bird.java

1
2
3
4
5
package Decorator;
public interface Bird {
public abstract int fly();
}

ConcreteComponent的实现类Sparrow.java

1
2
3
4
5
6
7
8
9
10
11
package Decorator;
public class Sparrow implements Bird {
private final int DISTANCE = 100;
@Override
public int fly() {
return DISTANCE;
}
}

Decorator的接口类Decorator.java

1
2
3
4
5
6
7
8
9
package Decorator;
public abstract class Decorator implements Bird {
public Bird bird;
public Decorator(Bird bird) {
this.bird = bird;
}
}

ConcreteDecorator的实现类SparrowDecorator.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package Decorator;
public class SparrowDecorator extends Decorator {
private final int DISTANCE = 50;
public SparrowDecorator(Bird bird) {
super(bird);
}
@Override
public int fly() {
return bird.fly() + elefly();
}
public int elefly() {
return DISTANCE;
}
}

测试类Application.java

1
2
3
4
5
6
7
8
9
10
11
package Decorator;
public class Application {
public static void main(String[] args) {
Bird sparrow = new Sparrow();
System.out.println(sparrow.fly());
Bird sparrowDecorator = new SparrowDecorator(sparrow);
System.out.println(sparrowDecorator.fly());
}
}

装饰模式的优点

  • 被装饰者和装饰者是松耦合关系。由于装饰(Decorator)仅仅依赖于抽象组件(Component),因此具体装饰只知道它要装饰的对象是抽象组件某一个子类的实例,但不需要知道是哪一个具体子类。
  • 装饰模式满足“开-闭原则”。不必修改具体组件,就可以增加新的针对该具体组件的具体装饰。
  • 可以使用多个具体装饰来装饰具体组件的实例。

适用装饰模式的情景

  • 程序希望动态地增强类的某个对象的功能,而又不影响到该类的其他对象。
  • 采用继承来增强对象功能不利于系统的扩展和维护。

下载源码请到

MyGitHub

Java设计模式--抽象工厂模式

抽象工厂模式(别名:配套)

提供一个创建一系列或相互依赖对象的接口,而无需指定它们具体的类。

Abstract Factory Pattern(Another Name: Kit)

Provide an interface for creating an families of related or dependent objects without specifying their concrete classes。

类图

模式的结构与使用

工厂方法模式的结构中包括四个角色。

  • 抽象产品(Product):抽象类或接口,负责定义具体产品必须实现的方法。
  • 具体产品(Concrete Product):具体产品是一个类,如果Product是一个抽象类,那么具体产品是Product的子类;如果Product是一个接口,那么具体产品去实现接口。
  • 构造者(Creator):一个接口或者抽象类。构造者负责定义一个称作工厂方法的抽象方法,该方法返回具体产品类的实例。
  • 具体构造者(Concrete Creator):具体构造者重写工厂方法使该方法返回具体产品的实例。

简单的例子

Product的接口类Firearms.java

1
2
3
4
5
package Kit;
public interface Firearms {
public abstract void fire();
}

ConcreteProduct的实现类Pistol.java

1
2
3
4
5
6
7
8
9
10
package Kit;
public class Pistol implements Firearms{
@Override
public void fire() {
System.out.println("手枪开火 ");
}
}

ConcreteProduct的实现类MachineGun.java

1
2
3
4
5
6
7
8
9
10
package Kit;
public class MachineGun implements Firearms {
@Override
public void fire() {
System.out.println("机关枪开火");
}
}

Product的接口类Bullet.java

1
2
3
4
5
package Kit;
public interface Bullet {
public abstract String getName();
}

ConcreteProduct的实现类PistolBullet.java

1
2
3
4
5
6
7
8
9
10
11
package Kit;
public class PistolBullet implements Bullet {
private String name = "手枪子弹";
@Override
public String getName() {
return name;
}
}

ConcreteProduct的实现类MachineGunBullet.java

1
2
3
4
5
6
7
8
9
10
11
package Kit;
public class MachineGunBullet implements Bullet {
private String name = "机关枪子弹";
@Override
public String getName() {
return name;
}
}

Creator的接口类Armory.java

1
2
3
4
5
6
package Kit;
public interface Armory {
public abstract Firearms getFirearms();
public abstract Bullet getBullet();
}

ConcreteCreator的实现类PistolFactory.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package Kit;
public class PistolFactory implements Armory{
@Override
public Firearms getFirearms() {
return new Pistol();
}
@Override
public Bullet getBullet() {
return new PistolBullet();
}
}

ConcreteCreator的实现类MachineGunFactory.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package Kit;
public class MachineGunFactory implements Armory {
@Override
public Firearms getFirearms() {
return new MachineGun();
}
@Override
public Bullet getBullet() {
return new MachineGunBullet();
}
}

测试类Kit.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package Kit;
public class Kit {
public static void main(String[] args) {
PistolFactory pf = new PistolFactory();
System.out.println(pf.getBullet().getName());
pf.getFirearms().fire();
MachineGunFactory mgf = new MachineGunFactory();
System.out.println(mgf.getBullet().getName());
mgf.getFirearms().fire();
}
}

抽象工厂模式的优点

  • 抽象工厂模式可以为用户创建一系列相关的对象,使用户和创建这些对象的类脱耦。
  • 使用抽象工厂模式可以方便的为用户配置一系列对象。用户使用不同的具体工厂就能得到一组相关的对象,同时也能避免用户混到不同系列的对象中。
  • 在抽象工厂模式中,可以随时增加“具体工厂”为用户提供一组相关的对象。

适用抽象工厂模式的情景

  • 系统需要为用户提供多个对象,但不希望用户直接使用new运算符实例化这些对象,即希望用户和创建对象的类脱耦。
  • 系统需要为用户提供多个相关的对象,以便用户联合使用它们,但又不希望用户来决定这些对象是如何关联的。
  • 系统需要为用户提供一系列对象,但只需要用户知道这些对象有哪些方法可用,不需要用户知道这些对象的创建过程。

下载源码请到

MyGitHub

Java设计模式--工厂模式

简单工厂方法模式(别名:虚拟构造)

定义一个用于创建对象的接口,让子类决定实例化哪一个类。Factory Method使一个类的实例化延迟到其子类。

Mediator Pattern(Another Name: Virtual Constructor)

Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.

类图

模式的结构与使用

工厂方法模式的结构中包括四个角色。

  • 抽象产品(Product):抽象类或接口,负责定义具体产品必须实现的方法。
  • 具体产品(Concrete Product):具体产品是一个类,如果Product是一个抽象类,那么具体产品是Product的子类;如果Product是一个接口,那么具体产品去实现接口。
  • 构造者(Creator):一个接口或者抽象类。构造者负责定义一个称作工厂方法的抽象方法,该方法返回具体产品类的实例。
  • 具体构造者(Concrete Creator):具体构造者重写工厂方法使该方法返回具体产品的实例。

简单的例子

Product的抽象类Animals.java

1
2
3
4
5
6
package virtualconstructor;
public abstract class Animals {
String name;
public abstract void move();
}

ConcreteProduct的实现类Dog.java

1
2
3
4
5
6
7
8
9
10
11
12
package virtualconstructor;
public class Dog extends Animals{
public Dog() {
name = "狗";
}
public void move () {
System.out.println(name + "是走");
}
}

ConcreteProduct的实现类Cat.java

1
2
3
4
5
6
7
8
9
10
11
12
13
package virtualconstructor;
public class Cat extends Animals {
public Cat() {
name = "猫";
}
@Override
public void move() {
System.out.println(name + "是飞");
}
}

Creator的抽象类Creator.java

1
2
3
4
5
6
package virtualconstructor;
public abstract class Creator {
Animals animal;
public abstract Animals getAnimal();
}

ConcreteCreator的实现类DogCreator.java

1
2
3
4
5
6
7
8
9
package virtualconstructor;
public class DogCreator extends Creator {
@Override
public Animals getAnimal() {
return new Dog();
}
}

ConcreteCreator的实现类CatCreator.java

1
2
3
4
5
6
7
8
9
package virtualconstructor;
public class CatCreator extends Creator {
@Override
public Animals getAnimal() {
return new Cat();
}
}

测试类Application.java

1
2
3
4
5
6
7
8
9
10
11
package virtualconstructor;
public class Application {
public static void main(String[] args) {
DogCreator dog = new DogCreator();
dog.getAnimal().move();
CatCreator cat = new CatCreator();
cat.getAnimal().move();
}
}

工厂模式的优点

  • 使用工厂模式可以让用户的代码和某个特定类的子类的代码解耦。
  • 工厂方法的使用用户不必知道它所使用的对象是怎么被创建的,只需要知道该对象有哪些方法即可。

适用工厂模式的情景

  • 用户需要一个类的子类的实例,但不希望与该类的子类形成耦合。
  • 用户需要一个类的子类的实例,但用户不知道该类有哪些子类可用。

下载源码请到

MyGitHub