状态模式的具体实现 情景三

这篇中，我们将看到一种不同于前两篇的状态模式设计方法。

状态切换器中自己维护了一张状态切换列表，而且不同的状态所执行的操作是一样的。

我们假设商品有多种不同的分类，每一种分类都会有不同的税收，例如商品包括食品、衣服、书等等，奢侈品会征收奢侈品税，香烟征收烟草税等等

代码结构：



商品Goods类：

package com.anvien.practice.state_one;

import java.util.HashSet;
import java.util.Set;
/**
* 商品
*/
public class Goods {
/** 名称 */
private String name;
/** 单价 */
private double price;
/** 分类集合，一种商品在不同的分类标准下，可能会属于多种分类  */
Set<Category> categories = new HashSet<Category>();

/**
* 构造方法
* @param name
* 		名称
* @param price
* 		单价
*/
public Goods(String name, double price)
{
this.name = name;
this.price = price;
}

/**
* 获取商品名称
* @return
* 		商品名称
*/
public String getName() {
return name;
}

/**
* 设置商品名称
* @param name
* 		商品名称
*/
public void setName(String name) {
this.name = name;
}

/**
* 获取商品单价
* @return
* 		商品单价
*/
public double getPrice() {
return price;
}

/**
* 设置商品单价
* @param price
* 		商品单价
*/
public void setPrice(double price) {
this.price = price;
}

/**
* 为商品添加新的分类
* @param category
* 		新的分类
* @return
* 		返回添加成功与否
*/
public boolean addCategory(Category category)
{
return this.categories.add(category);
}

/**
* 获取商品的分类集合
* @return
* 		商品的分类集合
*/
public Set<Category> getCategories()
{
return this.categories;
}
}

税收Tax类：

package com.anvien.practice.state_one;

/**
* 税务
*
*/
public class Tax {
/** 名称 */
private String name;
/** 税率 */
private double rate;

public Tax(String name, double rate)
{
this.name = name;
this.rate = rate;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public double getRate() {
return rate;
}

public void setRate(double rate) {
this.rate = rate;
}

@Override
public String toString() {
return "Tax [name=" + name + ", rate=" + rate + "]";
}

@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((name == null) ? 0 : name.hashCode());
long temp;
temp = Double.doubleToLongBits(rate);
result = prime * result + (int) (temp ^ (temp >>> 32));
return result;
}

@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Tax other = (Tax) obj;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
if (Double.doubleToLongBits(rate) != Double
.doubleToLongBits(other.rate))
return false;
return true;
}

}

分类：

package com.anvien.practice.state_one;

import java.util.HashSet;
import java.util.Set;

/**
* 商品类别
*
*/
public class Category {

/** 当前类别所包含的商品关键字集合，即商品中包含列表中的某一项关键字的话，商品就属于这种类别的。*/
protected Set<String> contentSet = new HashSet<String>();
/** 当前类别所包含的税收集合。*/
protected Set<Tax> taxSet = new HashSet<Tax>();
/**
* 商品执行分类操作的启动方法
* @param classifier
* 		将要对商品进行分类的分类器
*/
public void classify(Classifier classifier)
{
if(contentSet.contains(classifier.getGoods().getName()) || classifier.isLastCategory())
{
classifier.getGoods().addCategory(classifier.getCurrentCategory());
}
else
{
classifier.classify();
}
}

/**
* 设置当前类别的内容关键字列表
* @param list
* 		内容关键字列表
*/
public void setContentSet(Set<String> set)
{
this.contentSet = set;
}

/**
* 获取当前类别的内容关键字列表
* @return
* 		内容关键字列表
*/
public Set<String> getContentSet()
{
return this.contentSet;
}

/**
* 向当前税收集合中添加一种新的税收
* @param tax
* 		新的税收
* @return
* 		返回税收添加成功与否
*/
public boolean addTax(Tax tax)
{
return this.taxSet.add(tax);
}

/**
* 获取当前类别的税收集合
* @return
* 		税收集和
*/
public Set<Tax> getTaxSet() {
return taxSet;
}
}

分类器：

package com.anvien.practice.state_one;

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

/**
* 分类器, 用于检查当前商品在指定分类集合中的所属情况
*
*/
public class Classifier {
private Goods goods;
private List<Category> categoryList;
int indicator = -1;
/**
* 构造方法
* @param categoryList
* 		分类集合
* 		注意集合中的最后一项分类为默认分类，
* 		即商品都不属于集合中的前面分类时，会被归纳为最后一个分类
*/
public Classifier(List<Category> categoryList) {
this.categoryList = categoryList;
}
/**
* 构造方法
* @param categorys
* 		分类集合
* 		注意集合中的最后一项分类为默认分类，
* 		即商品都不属于集合中的前面分类时，会被归纳为最后一个分类
*/
public Classifier(Category... categorys)
{
this.categoryList = new ArrayList<Category>();
for(Category c : categorys)
{
this.categoryList.add(c);
}
}
/**
* 返回分类器正在处理的商品
* @return
* 		返回分类器当前执行分类的商品
*/
public Goods getGoods() {
return goods;
}
/**
* 设置分类器将要执行分类的商品
* @param goods
* 		将要执行分类的商品
*/
public void setGoods(Goods goods) {
this.goods = goods;
this.indicator = -1;
}
/**
* 获取分类集合
* @return
* 		分类集合
*/
public List<Category> getCategoryList() {
return categoryList;
}
/**
* 设置分类集合
* @param categoryList
* 		分类集合
*/
public void setCategoryList(List<Category> categoryList) {
this.categoryList = categoryList;
}
/**
* 返回分类器当前得到的类别
* @return
* 		当前得到的类别
*/
public Category getCurrentCategory()
{
if(this.categoryList == null || this.indicator > this.categoryList.size()-1)
{
return null;
}
return this.categoryList.get(this.indicator);
}

/**
* 返回分类器是否已经在检查最后一种类别
* @return
* 		是否已经在检查最后一种类别
*/
public boolean isLastCategory()
{
if(this.categoryList == null || this.categoryList.size() < 1
|| this.indicator >= this.categoryList.size()-1)
{
return true;
}
return false;
}

/**
* 分类器执行类别检查的启动方法
*/
public void classify()
{
this.indicator++;
getCurrentCategory().classify(this);
}
}

测试：

package com.anvien.practice.state_one;

public class Main {

public static void main(String[] args) {
Goods book = new Goods("notebook", 5.0);
Goods food = new Goods("food", 12);

Tax foodTax = new Tax("food tax", 0.1);
Category foodCategory = new Category();
foodCategory.addTax(foodTax);

Tax bookTax = new Tax("book tax", 0.2);
Category bookCategory = new Category();
bookCategory.addTax(bookTax);

Category otherCategory = new Category();

Classifier clsfr = new Classifier(foodCategory, bookCategory, otherCategory);
clsfr.setGoods(food);
clsfr.classify();
clsfr.setGoods(book);
clsfr.classify();

}
}

这种方法看起来不像是状态模式的，但其实思想还是最基本的状态模式思想。