工具类:
public class FactorialUtil{
private static FactorialUtil singleton;
private FactorialAlgorithm algorithm;
/**
* Default (internal) constructor constructs our default algorithm.
*/
private FactorialUtil()
{
algorithm = new CachedFactorialImplementation();
}
/**
* New initializer which allows selection of the algorithm mechanism
* @param algorithm
*/
public FactorialUtil(FactorialAlgorithm a)
{
algorithm = a;
}
/**
* Default public interface for handling our factorial algorithm. Uses
* the old standard established earlier for calling into our utility class.
* @param n
* @return
*/
public static BigInteger factorial(int n)
{
if (singleton == null) {
// Use default constructor which uses default algorithm
singleton = new FactorialUtil();
}
return singleton.doFactorial(n);
}
/**
* New mechanism which allows us to instantiate individual factorial
* utilitiy classes and invoke customized factorial algorithms directory.
* @param n
* @return
*/
private BigInteger doFactorial(int n)
{
// Defer to our algorithm
return algorithm.factorial(n);
}
}
接口:
public interface FactorialAlgorithm{
BigInteger factorial(int n);
}
缓存实现
public class CachedFactorialImplementation implements FactorialAlgorithm
{
static HashMap cache = new HashMap();
@Override
public BigInteger factorial(int n)
{
BigInteger ret;
if (n == 0) return BigInteger.ONE;
if (null != (ret = cache.get(n))) return ret;
ret = BigInteger.valueOf(n).multiply(factorial(n-1));
cache.put(n, ret);
return ret;
}
}
循环实现
public class LoopedFactorialImplementation implements FactorialAlgorithm
{
@Override
public BigInteger factorial(int n)
{
BigInteger ret = BigInteger.ONE;
for (int i = 1; i <= n; ++i) ret = ret.multiply(BigInteger.valueOf(i));
return ret;
}
}
这种方式无法实现运行时动态选择使用哪个实现类。即,无法完成如下的调用。