策略模式:
* 策略模式定义了算法家族,分别封装起来,让他们之间可以互相替换,此模式让算法的变化,
* 不会影响到使用算法的客户。
*
* 策略模式是一种定义一系列算法的方法,从概念上来看,所有这些算法完成的都是相同的工作,只是
* 实现不同,它可以以相同的方式调用所有的算法,减少了各种算法类与使用算法类之间的耦合
单例模式:
* 单例模式:
* 单例类只能有一个实例
* 单例类必须自己创建自己唯一的实例
* 单例类必须给其他对象提供这一实例
策略模式实例:商场有不同打折促销方式,计算用户购买东西花费的钱。
CashSuper类:
package cn.edu.tju.strategyPattern;
public class CashSuper {
/*
* 参数money为正常的,单价*件数
*/
public double acceptCash(double money){
return 0;
}
}
CashNormal类:
package cn.edu.tju.strategyPattern;
/*
* 正常付款方式,付款金额=单价*件数
*/
public class CashNormal extends CashSuper{
public double acceptCash(double money){
return money;
}
}
CashRebate类:
package cn.edu.tju.strategyPattern;
/*
* 打折促销方式,付款金额=单价*件数*折扣
* 参数money为单价*件数,rebate为折扣
*/
public class CashRebate extends CashSuper{
double rebate = 1;
public CashRebate(double rebate){
this.rebate = rebate;
}
public double acceptCash(double money){
return money * rebate;
}
}
CashReturn类:
package cn.edu.tju.strategyPattern;
/*
* 满多少A送多少B促销方式,付款金额 = (单价*件数 )- ((单价*件数)/ A) * B
* 参数money = 单价*件数,moneyCondition表示满多少,moneyReturn表示返多少
*/
public class CashReturn extends CashSuper {
private double moneyCondition = 0;
private double moneyReturn = 0;
public CashReturn(double moneyCondition, double moneyReturn) {
this.moneyCondition = moneyCondition;
this.moneyReturn = moneyReturn;
}
public double acceptCash(double money) {
if (money >= moneyCondition) {
return money - Math.floor((money / moneyCondition)) * moneyReturn;// floor向下取整
} else {
return money;
}
}
}
CashContext类:有多个CashSuper类属性,所以为聚合关系
package cn.edu.tju.strategyPattern;
public class CashContext {
private CashSuper cs;
public CashContext(CashSuper cs){
this.cs = cs;
}
public double getResult(double money){
return cs.acceptCash(money);
}
}
测试类:
package cn.edu.tju.strategyPattern;
/*
* 策略模式定义了算法家族,分别封装起来,让他们之间可以互相替换,此模式让算法的变化,
* 不会影响到使用算法的客户。
*
* 策略模式是一种定义一系列算法的方法,从概念上来看,所有这些算法完成的都是相同的工作,只是
* 实现不同,它可以以相同的方式调用所有的算法,减少了各种算法类与使用算法类之间的耦合
*/
public class Test {
/*
* 条件判断语句又回到了客户端,每次增加新的促销方式时,需要修改客户端,添加新的促销算法类
* 为此,将策略模式和简单工厂模式相结合,具体看CashContext2以及Test2;
*
*/
public static void main(String[] args){
double totalPrice = 0;//总额
double price = 100;//单价
int num = 5;//数量
CashContext cc = null;
//java中switch后的判断条件只能是char,int,short,byte类型,不能是string
int type = 3;//1表示正常,2表示打折,3表示返利
switch(type){
case 1:
cc = new CashContext(new CashNormal());
break;
case 2:
cc = new CashContext(new CashRebate(0.8));//打八折
break;
case 3:
cc = new CashContext(new CashReturn(300, 100));//满300返100
break;
}
double money = price * num;
totalPrice = cc.getResult(money);
System.out.println("The totalPrice is " + totalPrice);
}
}
至此,策略模式完成。
这样存在问题:
* 条件判断语句又回到了客户端,每次增加新的促销方式时,需要修改客户端,添加新的促销算法类
* 为此,将策略模式和简单工厂模式相结合,具体看CashContext2以及Test2;
*
策略模式+简单工厂模式:
CashContext2类:
package cn.edu.tju.strategyPattern;
/*
* 条件判断语句又回到了客户端,每次增加新的促销方式时,需要修改客户端,添加新的促销算法类
* 为此,将策略模式和简单工厂模式相结合,具体看CashContext2以及Test2;
*
*/
public class CashContext2 {
//private CashContext cs;
private CashSuper cs;
public CashContext2(int type){
switch(type){
case 1://正常收费
this.cs = new CashNormal();
break;
case 2://打八折
this.cs = new CashRebate(0.8);
break;
case 3://满300返100
this.cs = new CashReturn(300, 100);
break;
}
}
public double getResult(double money){
return cs.acceptCash(money);
}
}
Test2类:
package cn.edu.tju.strategyPattern;
public class Test2 {
/*
* 条件判断语句又回到了客户端,每次增加新的促销方式时,需要修改客户端,添加新的促销算法类
* 为此,将策略模式和简单工厂模式相结合,具体看CashContext2以及Test2;
* 这样将分支条件挪到了CashContext里,增加新的促销方式时,不再需要修改客户端,实现客户端与后台的完全分离
*
*/
public static void main(String[] args){
double totalPrice = 0;//总额
double price = 100;//单价
int num = 5;//数量
//java中switch后的判断条件只能是char,int,short,byte类型,不能是string
int type = 1;//1表示正常,2表示打折,3表示返利
CashContext2 cc = new CashContext2(type);
totalPrice = cc.getResult(price * num);
System.out.println("The total price is " + totalPrice);
}
}
单例模式
饿汉式:
package cn.edu.tju.singletonPattern;
/*
* 饿汉式单例模式:在自己被加载时就将自己实例化
* 提前占用系统资源
*/
public class EagerSingleton {
//静态初始化,在类加载时即实例化,并只加载一次,解决了多线程问题
private static EagerSingleton singleton = new EagerSingleton();
/*
* private的构造方法保证外部类不能通过new产生新的实例
*/
private EagerSingleton(){}
/*
* 提供一个public接口,允许外部类获得实例
*/
public static EagerSingleton getInstance(){
return singleton;
}
}
懒汉式:
package cn.edu.tju.singletonPattern;
/*
* 懒汉式单例模式,只有在第一次被引用时,才将自己实例化
* 锁占用资源
*/
public class LazySingleton {
private static LazySingleton singleton = null;
/*
* private的构造方法保证外部类不能通过new产生新的实例
*/
private LazySingleton(){}
/*
* 提供一个public接口,允许外部类获得实例
* 为保证线程安全,即两个线程同时访问时不会得到两个实例,使用synchronized
*/
public synchronized static LazySingleton getInstance(){
if(singleton == null){
singleton = new LazySingleton();
}
return singleton;
}
}
测试类:
package cn.edu.tju.singletonPattern;
/*
* 单例模式:
* 单例类只能有一个实例
* 单例类必须自己创建自己唯一的实例
* 单例类必须给其他对象提供这一实例
*/
public class Test {
public static void main(String[] args){
//饿汉式单例模式
EagerSingleton singleton1 = EagerSingleton.getInstance();
EagerSingleton singleton2 = EagerSingleton.getInstance();
if(singleton1 == singleton2){//判断是否为同一内存地址
System.out.println("它们是同一实例");
}else{
System.out.println("它们不是同一实例");
}
//懒汉式单例模式
LazySingleton singleton3 = LazySingleton.getInstance();
LazySingleton singleton4 = LazySingleton.getInstance();
if(singleton3 == singleton4){//判断是否为同一内存地址
System.out.println("它们是同一实例");
}else{
System.out.println("它们不是同一实例");
}
}
}