商品促销——策略模式

最新推荐文章于 2024-10-20 10:43:07 发布
最新推荐文章于 2024-10-20 10:43:07 发布
阅读量904 收藏
点赞数
文章标签： 算法 string class java 单元测试 null
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangyangkobe/article/details/5867082
版权
Java代码 复制代码
  1. /**  
  2.  * <h1>策略模式</h1>  
  3.  * QS:做个商场收银软件，营销员根据客户所购买的商品和数量向客户收费 第一次程序  
  4.  * @author xangqun  
  5.  *   
  6.  */   
  7. public   class  Program {   
  8.   
  9.      /**  
  10.      *PS:  
  11.      * <pre>如果商场搞活动，商品打8折，打5折怎么办？？</pre>  
  12.      * @param args  
  13.      * @throws IOException  
  14.      */   
  15.      public   static   void  main(String[] args)  throws  IOException {   
  16.         System.out.println( "单价：" );   
  17.         String strA =  new  BufferedReader( new  InputStreamReader(System.in))   
  18.                 .readLine();   
  19.         System.out.println( "数量：" );   
  20.         String strB =  new  BufferedReader( new  InputStreamReader(System.in))   
  21.                 .readLine();   
  22.          double  numberd = Double.valueOf(strA) + Double.valueOf(strB);   
  23.         System.out.println( "价格为："  + numberd);   
  24.   
  25.     }   
  26.   
  27. }   
/**
 * <h1>策略模式</h1>
 * QS:做个商场收银软件，营销员根据客户所购买的商品和数量向客户收费 第一次程序
 * @author xangqun
 * 
 */
public class Program {

	/**
	 *PS:
	 * <pre>如果商场搞活动，商品打8折，打5折怎么办？？</pre>
	 * @param args
	 * @throws IOException
	 */
	public static void main(String[] args) throws IOException {
		System.out.println("单价：");
		String strA = new BufferedReader(new InputStreamReader(System.in))
				.readLine();
		System.out.println("数量：");
		String strB = new BufferedReader(new InputStreamReader(System.in))
				.readLine();
		double numberd = Double.valueOf(strA) + Double.valueOf(strB);
		System.out.println("价格为：" + numberd);

	}

}

 

Java代码 复制代码
  1. /**  
  2.  * <h1>策略模式</h1>  
  3.  * QS:做个商场收银软件，营销员根据客户所购买的商品和数量向客户收费 第一次程序  
  4.  * @author xangqun  
  5.  * 改进的程序1  
  6.  */   
  7. public   class  ProgramTwo {   
  8.   
  9.      /**  
  10.      * PS:3个分支执行的语句除了打折不一样外几乎没什么不同应该考虑重构下  
  11.      * @param args  
  12.      * @throws IOException   
  13.      *   
  14.      */   
  15.      public   static   void  main(String[] args)  throws  IOException {   
  16.         
  17.         System.out.println( "单价：" );   
  18.         String strA =  new  BufferedReader( new  InputStreamReader(System.in))   
  19.                 .readLine();   
  20.         System.out.println( "数量：" );   
  21.         String strB =  new  BufferedReader( new  InputStreamReader(System.in))   
  22.                 .readLine();   
  23.         System.out.println( "折扣：" );   
  24.         String strC =  new  BufferedReader( new  InputStreamReader(System.in))   
  25.         .readLine();   
  26.          int  numc= Integer.valueOf(strC);   
  27.          double  result =  0 ;   
  28.          switch (numc){   
  29.          case   1 :result=Double.valueOf(strA) + Double.valueOf(strB); break ;   
  30.          case   2 :result=(Double.valueOf(strA) + Double.valueOf(strB))* 0.8 ; break ;   
  31.          case   3 :result=(Double.valueOf(strA) + Double.valueOf(strB))* 0.5 ; break ;   
  32.         }   
  33.         System.out.println(result);   
  34.     }   
/**
 * <h1>策略模式</h1>
 * QS:做个商场收银软件，营销员根据客户所购买的商品和数量向客户收费 第一次程序
 * @author xangqun
 * 改进的程序1
 */
public class ProgramTwo {

	/**
	 * PS:3个分支执行的语句除了打折不一样外几乎没什么不同应该考虑重构下
	 * @param args
	 * @throws IOException 
	 * 
	 */
	public static void main(String[] args) throws IOException {
     
		System.out.println("单价：");
		String strA = new BufferedReader(new InputStreamReader(System.in))
				.readLine();
		System.out.println("数量：");
		String strB = new BufferedReader(new InputStreamReader(System.in))
				.readLine();
        System.out.println("折扣：");
        String strC = new BufferedReader(new InputStreamReader(System.in))
		.readLine();
        int numc= Integer.valueOf(strC);
        double result = 0;
        switch(numc){
        case 1:result=Double.valueOf(strA) + Double.valueOf(strB);break;
        case 2:result=(Double.valueOf(strA) + Double.valueOf(strB))*0.8;break;
        case 3:result=(Double.valueOf(strA) + Double.valueOf(strB))*0.5;break;
        }
        System.out.println(result);
	}

 

Java代码 复制代码
  1. public   abstract   class  CashSuper {   
  2.   
  3.      public   abstract   double  acceptCash( double  money);   
  4. }   
public abstract class CashSuper {

	public abstract double acceptCash(double money);
}

 

Java代码 复制代码
  1. public   class  CashNormal  extends  CashSuper {   
  2.   
  3.      @Override   
  4.      public   double  acceptCash( double  money) {   
  5.   
  6.          return  money;   
  7.     }   
  8.   
  9. }   
public class CashNormal extends CashSuper {

	@Override
	public double acceptCash(double money) {

		return money;
	}

}

 

Java代码 复制代码
  1. public   class  CashRebate  extends  CashSuper {   
  2.   
  3.      private   double  moneyRebate=1d;   
  4.      public  CashRebate(){}   
  5.      public  CashRebate(String moneyRebate){   
  6.          this .moneyRebate=Double.valueOf(moneyRebate);   
  7.     }   
  8.      @Override   
  9.      public   double  acceptCash( double  money) {   
  10.          return  money*moneyRebate;   
  11.     }   
  12.   
  13. }   
public class CashRebate extends CashSuper {

	private double moneyRebate=1d;
	public CashRebate(){}
	public CashRebate(String moneyRebate){
		this.moneyRebate=Double.valueOf(moneyRebate);
	}
	@Override
	public double acceptCash(double money) {
		return money*moneyRebate;
	}

}

 

Java代码 复制代码
  1. public   class  CashReturn  extends  CashSuper {   
  2.   
  3.      private   double  moneyCondition= 0 .0d;   
  4.      private   double  moneyReturn= 0 .0d;   
  5.      public  CashReturn(){}   
  6.      public  CashReturn( double  moneyCondition, double  moneyReturn){   
  7.          this .moneyCondition=moneyCondition;   
  8.          this .moneyReturn=moneyReturn;   
  9.     }   
  10.      @Override   
  11.      public   double  acceptCash( double  money) {   
  12.          double  result=money;   
  13.          if (money>moneyCondition){   
  14.             result=money-Math.floor(money/moneyCondition)*moneyReturn;   
  15.         }   
  16.          return  result;   
  17.     }   
  18.   
  19. }   
public class CashReturn extends CashSuper {

	private double moneyCondition=0.0d;
	private double moneyReturn=0.0d;
	public CashReturn(){}
	public CashReturn(double moneyCondition,double moneyReturn){
		this.moneyCondition=moneyCondition;
		this.moneyReturn=moneyReturn;
	}
	@Override
	public double acceptCash(double money) {
		double result=money;
		if(money>moneyCondition){
			result=money-Math.floor(money/moneyCondition)*moneyReturn;
		}
		return result;
	}

}

 

Java代码 复制代码
  1. public   class  CashFactory {   
  2.   
  3.      public   static  CashSuper createCashAccept( int  type){   
  4.         CashSuper cs= null ;   
  5.          switch (type){   
  6.          case   1 :cs= new  CashNormal(); break ;   
  7.          case   2 : cs= new  CashReturn( 300 , 100 ); break ;   
  8.          case   3 :cs= new  CashRebate( "0.8" ); break ;   
  9.         }   
  10.          return  cs;   
  11.     }   
  12. }   
public class CashFactory {

	public static CashSuper createCashAccept(int type){
		CashSuper cs=null;
		switch(type){
		case 1:cs=new CashNormal();break;
		case 2: cs=new CashReturn(300,100);break;
		case 3:cs=new CashRebate("0.8");break;
		}
		return cs;
	}
}

 

Java代码 复制代码
  1. /**  
  2.  * <h1>策略模式</h1>  
  3.  * QS:做个商场收银软件，营销员根据客户所购买的商品和数量向客户收费 第一次程序  
  4.  * @author xangqun  
  5.  * 改进的程序2(采用简单工厂模式)  
  6.  */   
  7. public   class  ProgramThree {   
  8.   
  9.      /**PS:  
  10.      * 简单工厂模式只是解决对象的创建问题，面对算法时常变动应该考虑用其他方法  
  11.      * @param args  
  12.      * @throws IOException   
  13.      */   
  14.      public   static   void  main(String[] args)  throws  IOException {   
  15.         System.out.println( "单价：" );   
  16.         String strA =  new  BufferedReader( new  InputStreamReader(System.in))   
  17.                 .readLine();   
  18.         System.out.println( "数量：" );   
  19.         String strB =  new  BufferedReader( new  InputStreamReader(System.in))   
  20.                 .readLine();   
  21.            
  22.         CashSuper cs=CashFactory.createCashAccept( 1 );   
  23.          double  totalprices=0d;   
  24.         totalprices=cs.acceptCash(Double.valueOf(strA)*Double.valueOf(strB));   
  25.         System.out.println(totalprices);   
  26.     }   
  27.   
  28. }   
/**
 * <h1>策略模式</h1>
 * QS:做个商场收银软件，营销员根据客户所购买的商品和数量向客户收费 第一次程序
 * @author xangqun
 * 改进的程序2(采用简单工厂模式)
 */
public class ProgramThree {

	/**PS:
	 * 简单工厂模式只是解决对象的创建问题，面对算法时常变动应该考虑用其他方法
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		System.out.println("单价：");
		String strA = new BufferedReader(new InputStreamReader(System.in))
				.readLine();
		System.out.println("数量：");
		String strB = new BufferedReader(new InputStreamReader(System.in))
				.readLine();
		
		CashSuper cs=CashFactory.createCashAccept(1);
		double totalprices=0d;
		totalprices=cs.acceptCash(Double.valueOf(strA)*Double.valueOf(strB));
		System.out.println(totalprices);
	}

}

 

Java代码 复制代码
  1. public   class  CashContext {   
  2.   
  3.      private  CashSuper cs;   
  4.      public  CashContext(CashSuper csuper){   
  5.          this .cs=csuper;   
  6.     }   
  7.      public   double  getResult( double  money){   
  8.          return  cs.acceptCash(money);   
  9.     }   
  10. }   
public class CashContext {

	private CashSuper cs;
	public CashContext(CashSuper csuper){
		this.cs=csuper;
	}
	public double getResult(double money){
		return cs.acceptCash(money);
	}
}

 

Java代码 复制代码
  1. /**  
  2.  * <h1>策略模式</h1>  
  3.  * QS:做个商场收银软件，营销员根据客户所购买的商品和数量向客户收费 第一次程序  
  4.  * @author xangqun  
  5.  * 改进的程序3(采用策略模式)  
  6.  */   
  7. public   class  ProgramFour {   
  8.   
  9.      /**<b>策略模式(strategy)</b>  
  10.      *<br> 它定义了算法家族，分别封装起来，让他们之间可以相互替换，此模式让算法的变化不会影响到使用算法的客户<br>  
  11.      *策略模式是一种定义一系列算法的方法，从概念上来看，所以这些算法完成的都是相同的工作，只是实现不同，他可以  
  12.      *以相同的方式调用所有的算法，减少了各种算法类与使用算法类之间的耦合。  
  13.      *优点：1.context定义了一系列的可供重用的算法或行为，继承有助于析取出这些算法中公共功能（这里是getresult）  
  14.      *      2.简化了单元测试因为每个算法都有自己的类，可以通过自己的接口单独测试  
  15.      * 策略模式封装了变化  
  16.      * 应用：策略模式就是用来封装算法的，但实践中，我们发现可以用他来封装几乎任何类型的规则，只要在分析过程中  
  17.      *      听到需要在不同时间应用不同的业务规则，就可以考虑使用策略模式处理这种变化的可能性       
  18.      * @param args  
  19.      * @throws IOException   
  20.      */   
  21.      public   static   void  main(String[] args)  throws  IOException {   
  22.         System.out.println( "单价：" );   
  23.         String strA =  new  BufferedReader( new  InputStreamReader(System.in))   
  24.                 .readLine();   
  25.         System.out.println( "数量：" );   
  26.         String strB =  new  BufferedReader( new  InputStreamReader(System.in))   
  27.                 .readLine();   
  28.         System.out.println( "类型：" );   
  29.         String strC =  new  BufferedReader( new  InputStreamReader(System.in))   
  30.                 .readLine();   
  31.         CashContext cc= null ;   
  32.          switch (Integer.valueOf(strC)){   
  33.          case   1 :cc= new  CashContext( new  CashNormal()); break ;   
  34.          case   2 : cc= new  CashContext( new  CashReturn( 300 , 100 )); break ;   
  35.          case   3 :cc= new  CashContext( new  CashRebate( "0.8" )); break ;   
  36.         }   
  37.          double  totalprices=0d;   
  38.         totalprices=cc.getResult(Double.valueOf(strA)*Double.valueOf(strB));   
  39.         System.out.println(totalprices);   
  40.   
  41.     }   
/**
 * <h1>策略模式</h1>
 * QS:做个商场收银软件，营销员根据客户所购买的商品和数量向客户收费 第一次程序
 * @author xangqun
 * 改进的程序3(采用策略模式)
 */
public class ProgramFour {

	/**<b>策略模式(strategy)</b>
	 *<br> 它定义了算法家族，分别封装起来，让他们之间可以相互替换，此模式让算法的变化不会影响到使用算法的客户<br>
	 *策略模式是一种定义一系列算法的方法，从概念上来看，所以这些算法完成的都是相同的工作，只是实现不同，他可以
	 *以相同的方式调用所有的算法，减少了各种算法类与使用算法类之间的耦合。
	 *优点：1.context定义了一系列的可供重用的算法或行为，继承有助于析取出这些算法中公共功能（这里是getresult）
	 *      2.简化了单元测试因为每个算法都有自己的类，可以通过自己的接口单独测试
	 * 策略模式封装了变化
	 * 应用：策略模式就是用来封装算法的，但实践中，我们发现可以用他来封装几乎任何类型的规则，只要在分析过程中
	 *      听到需要在不同时间应用不同的业务规则，就可以考虑使用策略模式处理这种变化的可能性     
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		System.out.println("单价：");
		String strA = new BufferedReader(new InputStreamReader(System.in))
				.readLine();
		System.out.println("数量：");
		String strB = new BufferedReader(new InputStreamReader(System.in))
				.readLine();
		System.out.println("类型：");
		String strC = new BufferedReader(new InputStreamReader(System.in))
				.readLine();
		CashContext cc=null;
		switch(Integer.valueOf(strC)){
		case 1:cc=new CashContext(new CashNormal());break;
		case 2: cc=new CashContext(new CashReturn(300,100));break;
		case 3:cc=new CashContext(new CashRebate("0.8"));break;
		}
		double totalprices=0d;
		totalprices=cc.getResult(Double.valueOf(strA)*Double.valueOf(strB));
		System.out.println(totalprices);

	}

 

Java代码 复制代码
  1. public   class  CashContextFactory {   
  2.   
  3.      private  CashSuper cs;   
  4.      public  CashContextFactory( int  type){   
  5.          switch (type){   
  6.          case   1 : this .cs= new  CashNormal(); break ;   
  7.          case   2 : this .cs= new  CashReturn( 300 , 100 ); break ;   
  8.          case   3 : this .cs= new  CashRebate( "0.8" ); break ;   
  9.         }   
  10.     }   
  11.      public   double  getResult( double  money){   
  12.          return  cs.acceptCash(money);   
  13.     }   
  14. }   
public class CashContextFactory {

	private CashSuper cs;
	public CashContextFactory(int type){
		switch(type){
		case 1:this.cs=new CashNormal();break;
		case 2:this.cs=new CashReturn(300,100);break;
		case 3:this.cs=new CashRebate("0.8");break;
		}
	}
	public double getResult(double money){
		return cs.acceptCash(money);
	}
}

 

Java代码 复制代码
  1. /**  
  2.  * <h1>策略模式</h1>  
  3.  * QS:做个商场收银软件，营销员根据客户所购买的商品和数量向客户收费 第一次程序  
  4.  * @author xangqun  
  5.  * 改进的程序3(采用策略模式+简单工厂模式)  
  6.  */   
  7. public   class  ProgramFive {   
  8.   
  9.      /**  
  10.      * @param args  
  11.      * @throws IOException   
  12.      */   
  13.      public   static   void  main(String[] args)  throws  IOException {   
  14.         System.out.println( "单价：" );   
  15.         String strA =  new  BufferedReader( new  InputStreamReader(System.in))   
  16.                 .readLine();   
  17.         System.out.println( "数量：" );   
  18.         String strB =  new  BufferedReader( new  InputStreamReader(System.in))   
  19.                 .readLine();   
  20.         System.out.println( "类型：" );   
  21.         String strC =  new  BufferedReader( new  InputStreamReader(System.in))   
  22.                 .readLine();   
  23.         CashContextFactory cc= new  CashContextFactory(Integer.valueOf(strC));   
  24.          double  totalprices=cc.getResult(Double.valueOf(strA)*Double.valueOf(strB));   
  25.         System.out.println(totalprices);   
  26.     }   
  27.   
  28. }  

 

自己C++实现的策略模式

wangyangkobe
关注
设计模式（十四）—— 策略模式
壹升茉莉清的博客
09-30 157
该模式定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的变化不会影响使用算法的客户。策略模式属于对象行为模式，它通过对算法进行封装，把使用算法的责任和算法的实现分割开来，并委派给不同的对象对这些算法进行管理。
大话设计模式——策略模式
等一杯咖啡的博客
07-11 635
大话设计模式——策略模式需求做一个商场收银软件，营业员根据客户所购买商品的单价和数量向客户收费。即简单的收银软件。简单实现利用Java的GUI编程，作出一个可视化界面如下。这里利用了IntelliJ IDEA的GUI Designer来进行界面功能编写，会用的话还是挺方便的。 业务逻辑还是比较简单的，主要就是确定按钮和重置按钮的监听事件。源码配合注释如下:import javax.swing
大话设计模式笔记(二)——商品促销 策略模式
咸鱼老罗的博客
08-01 1045
第二章商品促销——策略模式 需求：商品价格计算，并增加折扣条件 工厂模式UML图 在工厂模式中，调用端代码会通过折扣工厂类生成折扣对象，折扣对象调用折扣方法。这里关联了两个类，工厂类和抽象折扣类。 策略模式UML图 在策略模式中，会在策略环境类的构造器中完成折扣类的初始话，并在策略环境的实现方法调用折扣类的折扣算法。这样调用类只会关联策略环境类。 简单工厂模式需要的是生成的
策略模式——商品促销
QAQ
09-10 1211
许多商家为了提高知名度或是其他原因会进行商品促销活动。而有时对于新老客户的促销策略又有所不同。比如新客户打9折，老客户打8折。（当然，这只是比喻）我们可以用简单的程序来表示这种促销活动。public class Merchandise { //新客户 public final static int NEW_CUSTOMER = 0; //老客户 public fina
二、商品促销-策略模式
Mook的博客
05-29 647
策略模式
策略模式
renwotao2009的专栏
03-27 1153
策略模式将可变的部分从程序中抽象分离成算法接口，在该接口下分别封装一系列算法实现。 网上商店购买商品，在网上支付时，我们可以选择不同银行提供的支付接口，因为银行不同其提供的支付算法不同。
策略模式之商场促销
小武的专栏
05-13 1840
每到5.1 10.1等节日，都会看到商场里人山人海。商场之所以如此吸引人，是因为疯狂的折扣。下面以商场打折为例，谈谈策略模式。商品的折扣算法：算法一：对于有的商品，没有折扣。算法二：对于有的商品，采取固定金额的折扣。算法三：对于有的商品，采取百分比的折扣。解决方案：方案一：将所有的业务逻辑放在客户端。客户端根据参数选择具体的算法，但是这样客户端会变得复杂
02 大话设计模式C++实现之商场促销——策略模式
Woosual的博客
12-12 327
/* 策略模式（商场促销）： 算法时常改变,它定义了算法家族，分别封装起来，让他们之间可以相互替换 此模式让算法的变化不会影响使用算法的客户 */ #define _CRT_SECURE_NO_WARNINGS #include<iostream> #include<string> using namespace std; //定义一个抽象类算法 class Stra...
设计模式——策略模式
04-10
策略模式是一种行为设计模式，它使你能在运行时改变对象的行为。在软件开发中，我们经常遇到需要根据不同的条件或策略来执行不同操作的情况。策略模式允许我们将算法封装到独立的可互换的策略对象中，从而使算法的...
营销课件——促销策略.ppt
01-14
这份“营销课件——促销策略.ppt”主要涵盖了四个关键部分：说服模式、沟通模式、人员推销和广告。 一、说服模式 说服模式是促销策略中的基础，它涉及到如何运用不同的技巧来说服消费者。修辞模式强调语言的准确性...
2.商场促销 - 策略模式 （大话设计模式Kotlin版）
犟驴的博客
05-20 519
编程题：制作商场收银软件 利用编程做一个简易的商场收银系统，营业员根据客户购买的商品的单价与数量，向客户收费。 快速实现 马上想到的解决思路：无非是提供两个输入，分别对应商品单价与数量，然后通过计算得到费用输出！ v1.0代码 /** * @create on 2020/5/19 22:02 * @description 收银客户端 * @author mrdonkey */ class Client { companion object { @JvmStatic.
23种设计模式-策略模式《商家打折》
热门推荐
yancyang的博客
07-20 2万+
对于许久不用的东西，容易忘记。百度许久，也未能找到自己所要。 从今日起，有些东西就记载下来，不仅方便自己，希望能帮到他人吧 最近开发一款电商App，对于商家推出的活动焦头烂额，好歹想起了设计模式中的策略模式，从容的解决这种问题。 商家的活动： 1.满100减10元。 2.三件8.5折。 3.五件送一件最近价格商品。 … 最开始使用swich，后来越来越多case，代码繁杂...
【C++】促销商品的折扣计算
lothome的博客
01-05 8931
本店满500元享受9折优惠，满1000元享受8折优惠，满2000元享受7折优惠，满3000元享受9折优惠。 #include"iostream.h" #include"stdio.h" //本店满500元享受9折优惠，满1000元享受8折优惠，满2000元享受7折优惠，满3000元享受6折优惠。 void main() { int imoney; cout cin
[Java]无脑理解JAVA策略模式
05-13 794
场景:某超市收银台,营业员根据客户购买的商品和数量向客户收费. 问题:
java匹配规则_复杂匹配规则
weixin_39633165的博客
02-25 657
匹配开头和结尾用正则表达式进行多行匹配时，我们用^表示开头，$表示结尾。例如，^A\d{3}$，可以匹配"A001"、"A380"。匹配指定范围如果我们规定一个7~8位数字的电话号码不能以0开头，应该怎么写匹配规则呢？\d{7,8}是不行的，因为第一个\d可以匹配到0。使用[...]可以匹配范围内的字符，例如，[123456789]可以匹配1~9，这样就可以写出上述电话号码的规则：[1234567...
二分查找算法（折半查找算法）
最新发布
Mooczx的博客
10-20 316
是一种在有序数组中查找特定元素的搜索算法。该算法通过将数组分成两半，逐步缩小查找范围来提高查找效率。具体来说，每次比较中间元素与目标值，根据比较结果决定是继续在左半部分还是右半部分进行查找，从而每次迭代都能排除一半的查找空间，时间复杂度对数级别O(logn)
Javascript算法——双指针法移除元素、数组去重、比较含退格字符、有序数组平方
警警的博客
10-17 489
暴力求解法（两层for循环）,length单词拼写错误❌二次嵌套for的length设置。return位置❌ ,核心基础。双指针法（一层for循环）
美团点评渠道考试——交易与营销策略
1. 交易产品识别：题目要求考生区分美团点评提供的各种产品，这可能包括但不限于餐饮团购、代金券、套餐、优惠券等，考察对平台商品的理解。 2. 团购限制性条款：可能涉及团购的使用条件、时间限制、最低消费额等，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值