策略模式属于对象的行为模式.其用意是针对一组算法,将每一个算法封装到具有共同接口的独立类中,从而使得它们可以互相替换.策略模式使得算法可以在不影响到客户端的情况下发生变化.
这个模式涉及三个角色:
*环境(Context)角色:持有一个Strategy类的引用.
*抽象策略(Strategy)角色:这是一个抽象角色,通常由一个接口或抽象类实现.此角色给出所以的具体策略类所需的接口.
*具体策略(ConcreteStrategy)角色:包装了相关的算法或行为.
1.比较策略:
环境角色:
|
public class Cat implements Comparable
{
private int age;
private int height;
//持有一个Strategy类的引用
private Comparator comparator = new CatHeightComparator();
//private Comparator comparator = new CatAgeComparator();
public Comparator getComparator()
{
return comparator;
}
public void setComparator(Comparator comparator)
{
this.comparator = comparator;
}
public int getAge()
{
return age;
}
public void setAge(int age)
{
this.age = age;
}
public int getHeight()
{
return height;
}
public void setHeight(int height)
{
this.height = height;
}
public Cat(int age, int height)
{
super();
this.age = age;
this.height = height;
}
@Override
public String toString()
{
return age + "|" + height;
}
@Override
public int compareTo(Object o)
{
return comparator.compare(this, o);
}
}
|
抽象策略(Strategy)角色
|
public interface Comparator
{
int compare(Object o1,Object o2);
}
|
具体策略(ConcreteStrategy)角色1
|
public class CatAgeComparator implements Comparator
{
@Override
public int compare(Object o1, Object o2)
{
Cat c1 = (Cat)o1;
Cat c2 = (Cat)o2;
if (c1.getAge() > c2.getAge())
{
return 1;
}
else if (c1.getAge() < c2.getAge())
{
return -1;
}
return 0;
}
}
|
具体策略(ConcreteStrategy)角色2
|
public class CatHeightComparator implements Comparator
{
@Override
public int compare(Object o1, Object o2)
{
Cat c1 = (Cat)o1;
Cat c2 = (Cat)o2;
if (c1.getHeight() > c2.getHeight())
{
return 1;
}
else if (c1.getHeight() < c2.getHeight())
{
return -1;
}
return 0;
}
}
|
在排序算法中的使用:
|
public class DataSorter
{
public static void sort(Object[] a)
{
for (int i = a.length; i > 0; i--)
{
for (int j = 0; j < i - 1; j++)
{
if (((Comparable)a[j]).compareTo((Comparable)a[j + 1]) == 1)
{
swap(a, j, j + 1);
}
}
}
}
private static void swap(Object[] a, int x, int y)
{
Object temp = a[x];
a[x] = a[y];
a[y] = temp;
}
public static void p(Object[] a)
{
for (int i = 0; i < a.length; i++)
{
System.out.print(a[i] + " ");
}
System.out.println();
}
}
|
Test:
|
public static void main(String[] args)
{
Cat a[] = {new Cat(4,5), new Cat(5,3), new Cat(2,3)};
DataSorter.sort(a);
DataSorter.p(a);
}
|
2.图书打折:
|
public abstract class DiscountStrategy
{
private double singlePrice = 0;
private int copies = 0;
public DiscountStrategy(double singlePrice, int copies)
{
this.singlePrice = singlePrice;
this.copies = copies;
}
public abstract double calculateDiscount();
}
|
策略1：对有些图书没有折扣
|
public class NoDiscountStrategy extends DiscountStrategy
{
private double singlePrice = 0;
private int copies = 0;
public NoDiscountStrategy(double singlePrice, int copies)
{
super(singlePrice, copies);
}
@Override
public double calculateDiscount()
{
return 0;
}
}
|
策略2：对有些图书提供一个固定量值的折扣
|
public class FlatRateStrategy extends DiscountStrategy
{
private double singlePrice = 0;
private int copies = 0;
private Double amount;
public FlatRateStrategy(double singlePrice, int copies)
{
super(singlePrice, copies);
}
public Double getAmount()
{
return amount;
}
public void setAmount(Double amount)
{
this.amount = amount;
}
@Override
public double calculateDiscount()
{
return copies * amount;
}
}
|
策略3：对有些图书提供一个百分比的折扣
|
public class PercentageStrategy extends DiscountStrategy
{
private double singlePrice = 0;
private int copies = 0;
private Double percent;
public PercentageStrategy(double singlePrice, int copies)
{
super(singlePrice, copies);
}
public Double getPercent()
{
return percent;
}
public void setPercent(Double percent)
{
this.percent = percent;
}
@Override
public double calculateDiscount()
{
return copies * singlePrice * percent;
}
}
|
