java工厂模式

最新推荐文章于 2023-08-22 20:53:16 发布
最新推荐文章于 2023-08-22 20:53:16 发布
阅读量434 收藏 2
点赞数

转载请标明出处：http://blog.csdn.net/lmj623565791/article/details/24460585  http://www.cnblogs.com/archimedes/

1、静态工厂模式

2、简单工厂模式

3、工厂方法模式

4、抽象工厂模式

1、静态工厂模式

这个最常见了，项目中的辅助类，TextUtil.isEmpty等，类+静态方法。详细介绍：略。

2、简单工厂模式

下面以卖肉夹馍为例讲解。

首先你得有个店：RoujiaMoStore

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. package com.zhy.pattern.factory.a;  
  2.   
  3. public class RoujiaMoStore  
  4. {  
  5.   
  6.     /** 
  7.      * 根据传入类型卖不同的肉夹馍 
  8.      *  
  9.      * @param type 
  10.      * @return 
  11.      */  
  12.     public RouJiaMo sellRouJiaMo(String type)  
  13.     {  
  14.         RouJiaMo rouJiaMo = null;  
  15.           
  16.         if (type.equals("Suan"))  
  17.         {  
  18.             rouJiaMo = new SuanRouJiaMo();  
  19.   
  20.         } else if (type.equals("Tian"))  
  21.         {  
  22.             rouJiaMo = new TianRouJiaMo();  
  23.         } else if (type.equals("La"))  
  24.         {  
  25.             rouJiaMo = new LaRouJiaMo();  
  26.         }  
  27.           
  28.         rouJiaMo.prepare();  
  29.         rouJiaMo.fire();  
  30.         rouJiaMo.pack();  
  31.         return rouJiaMo;  
  32.     }  
  33.   
  34. }  

然后你得有各种风味的馍馍：

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. package com.zhy.pattern.factory.a;  
  2.   
  3. public abstract class RouJiaMo  
  4. {  
  5.     protected String name;  
  6.   
  7.     /** 
  8.      * 准备工作 
  9.      */  
  10.     public void prepare()  
  11.     {  
  12.         System.out.println("揉面-剁肉-完成准备工作");  
  13.     }  
  14.   
  15.     /** 
  16.      * 使用你们的专用袋-包装 
  17.      */  
  18.     public void pack()  
  19.     {  
  20.         System.out.println("肉夹馍-专用袋-包装");  
  21.     }  
  22.     /** 
  23.      * 秘制设备-烘烤2分钟 
  24.      */  
  25.     public void fire()  
  26.     {  
  27.         System.out.println("肉夹馍-专用设备-烘烤");  
  28.     }  
  29. }  

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. package com.zhy.pattern.factory.a;  
  2.   
  3. import com.zhy.pattern.factory.a.RouJiaMo;  
  4.   
  5. /** 
  6.  * 辣味肉夹馍 
  7.  *  
  8.  * @author zhy 
  9.  *  
  10.  */  
  11. public class LaRouJiaMo extends RouJiaMo  
  12. {  
  13.     public LaRouJiaMo()  
  14.     {  
  15.         this.name = "辣味肉夹馍";  
  16.     }  
  17. }  

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. package com.zhy.pattern.factory.a;  
  2.   
  3.   
  4.   
  5. /** 
  6.  * 酸味肉夹馍 
  7.  *  
  8.  * @author zhy 
  9.  *  
  10.  */  
  11. public class SuanRouJiaMo extends RouJiaMo  
  12. {  
  13.     public SuanRouJiaMo()  
  14.     {  
  15.         this.name = "酸味肉夹馍";  
  16.     }  
  17. }  

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. package com.zhy.pattern.factory.a;  
  2.   
  3.   
  4.   
  5. /** 
  6.  * 酸味肉夹馍 
  7.  *  
  8.  * @author zhy 
  9.  *  
  10.  */  
  11. public class SuanRouJiaMo extends RouJiaMo  
  12. {  
  13.     public SuanRouJiaMo()  
  14.     {  
  15.         this.name = "酸味肉夹馍";  
  16.     }  
  17. }  

现在这样的设计，虽然可以支持你卖肉夹馍了，但是有点问题，生产馍的种类和你的RoujiaMoStore耦合度太高了，如果增加几种风味，删除几种风味，你得一直修改sellRouJiaMo中的方法，所以我们需要做一定的修改，此时简单工厂模式就能派上用场了。

我们开始写个简单工厂，把产生馍的过程拿出来：

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. package com.zhy.pattern.factory.a;  
  2.   
  3. public class SimpleRouJiaMoFactroy  
  4. {  
  5.     public RouJiaMo createRouJiaMo(String type)  
  6.     {  
  7.         RouJiaMo rouJiaMo = null;  
  8.         if (type.equals("Suan"))  
  9.         {  
  10.             rouJiaMo = new SuanRouJiaMo();  
  11.   
  12.         } else if (type.equals("Tian"))  
  13.         {  
  14.             rouJiaMo = new TianRouJiaMo();  
  15.         } else if (type.equals("La"))  
  16.         {  
  17.             rouJiaMo = new LaRouJiaMo();  
  18.         }  
  19.         return rouJiaMo;  
  20.     }  
  21.   
  22. }  

然后以组合的方式，让Store来使用：

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. package com.zhy.pattern.factory.a;  
  2.   
  3. public class RoujiaMoStore  
  4. {  
  5.     private SimpleRouJiaMoFactroy factroy;  
  6.   
  7.     public RoujiaMoStore(SimpleRouJiaMoFactroy factroy)  
  8.     {  
  9.         this.factroy = factroy;  
  10.     }  
  11.   
  12.     /** 
  13.      * 根据传入类型卖不同的肉夹馍 
  14.      *  
  15.      * @param type 
  16.      * @return 
  17.      */  
  18.     public RouJiaMo sellRouJiaMo(String type)  
  19.     {  
  20.         RouJiaMo rouJiaMo = factroy.createRouJiaMo(type);  
  21.         rouJiaMo.prepare();  
  22.         rouJiaMo.fire();  
  23.         rouJiaMo.pack();  
  24.         return rouJiaMo;  
  25.     }  
  26.   
  27. }  

好了，现在你随便添加什么种类的馍，删除什么种类的馍就和Store无关了，就是么~人家只负责卖馍么~ 这就是简单工厂模式，当然了，大家也都比较熟悉。

3、工厂方法模式

当系统准备为用户提供某个类的子类的实例，又不想让用户代码和该子类形成耦合时，就可以使用工厂方法模式来设计系统。工厂方法模式的关键是在一个接口或抽象类中定义一个抽象方法，该方法返回某个类的子类的实例，该抽象类或接口让其子类或实现该接口的类通过重写这个抽象方法返回某个子类的实例。

适用性

1.当一个类不知道它所必须创建的对象的类的时候。

2.当一个类希望由它的子类来指定它所创建的对象的时候。

3.当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候。  

参与者

1.Product 定义工厂方法所创建的对象的接口。

2.ConcreteProduct 实现Product接口。

3.Creator 声明工厂方法，该方法返回一个Product类型的对象。 Creator也可以定义一个工厂方法的缺省实现，它返回一个缺省的ConcreteProduct对象。 可以调用工厂方法以创建一个Product对象。

4.ConcreteCreator 重定义工厂方法以返回一个ConcreteProduct实例。

工厂方法模式的结构与使用

模式的结构中包括四种角色：

•抽象产品（Product）

•具体产品（ConcreteProduct）

•构造者（Creator）

•具体构造者（ConcreteCreator） 

模式的UML类图

实战部分

【例1】：假设有三个笔芯，分别是红笔芯、蓝笔芯和黑笔芯。用户希望通过圆珠笔来明确笔芯的颜色。

模式的结构的描述与使用 

1．抽象产品（Product）: PenCore.java

public abstract class PenCore{
   String color;
   public abstract void writeWord(String s);
}

2．具体产品（ConcreteProduct）_1 : RedPenCore.java

public class RedPenCore extends PenCore{
    RedPenCore(){
      color="红色";
    }
    public void writeWord(String s){
       System.out.println("写出"+color+"的字:"+s);
    }
}

具体产品（ConcreteProduct）_2 : BluePenCore.java

public class BluePenCore extends PenCore{
    BluePenCore(){
      color="蓝色";
    }
    public void writeWord(String s){
       System.out.println("写出"+color+"的字:"+s);
    }
}

具体产品（ConcreteProduct）_3: BlackPenCore.java

public class BlackPenCore extends PenCore{
    BlackPenCore(){
      color="黑色";
    }
    public void writeWord(String s){
       System.out.println("写出"+color+"的字:"+s);
    }
}

3．构造者（Creator）: BallPen.java

public abstract class BallPen{
    BallPen(){
       System.out.println("生产了一只装有"+getPenCore().color+"笔芯的圆珠笔");
    }
    public abstract PenCore getPenCore(); //工厂方法
}

4．具体构造者（ConcreteCreator）:

RedBallPen.java
public class RedBallPen extends BallPen{
    public PenCore getPenCore(){
       return new RedPenCore();
    }
}
BlueBallPen.java
public class BlueBallPen extends BallPen{
    public PenCore getPenCore(){
       return new BluePenCore();
    }
}
BlackBallPen.java
public class BlackBallPen extends BallPen{
    public PenCore getPenCore(){
       return new BlackPenCore();
    }
}

5．应用 Application.java

public class Application{
    public static void main(String args[]){
       PenCore penCore;
       BallPen ballPen=new BlueBallPen();
       penCore=ballPen.getPenCore();
       penCore.writeWord("你好,很高兴认识你");
       ballPen=new RedBallPen();
       penCore=ballPen.getPenCore();
       penCore.writeWord("How are you");
       ballPen=new BlackBallPen();
       penCore=ballPen.getPenCore();
       penCore.writeWord("nice to meet you");
    }
} 

4.抽象工厂模式

当系统准备为用户提供一系列相关的对象，又不想让用户代码和创建这些对象的类形成耦合时，就可以使用抽象工厂方法模式来设计系统。抽象工厂模式的关键是在一个抽象类或接口中定义若干个抽象方法，这些抽象方法分别返回某个类的实例，该抽象类或接口让其子类或实现该接口的类重写这些抽象方法，为用户提供一系列相关的对象。

适用性

1.一个系统要独立于它的产品的创建、组合和表示时。

2.一个系统要由多个产品系列中的一个来配置时。

3.当你要强调一系列相关的产品对象的设计以便进行联合使用时。

4.当你提供一个产品类库，而只想显示它们的接口而不是实现时。

参与者

1.AbstractFactory 声明一个创建抽象产品对象的操作接口。

2.ConcreteFactory 实现创建具体产品对象的操作。

3.AbstractProduct 为一类产品对象声明一个接口。

4.ConcreteProduct 定义一个将被相应的具体工厂创建的产品对象。 实现AbstractProduct接口。

5.Client 仅使用由AbstractFactory和AbstractProduct类声明的接口

抽象工厂模式的结构与使用

模式的结构中包括四种角色：

•抽象产品（Prodcut）

•具体产品（ConcreteProduct）

•抽象工厂（AbstractFactory）

•具体工厂（ConcreteFactory） 

模式的UML类图

实战部分

【例1】：建立一个系统，该系统可以为用户提供西服套装（上衣＋裤子）和牛仔套装（上衣＋裤子）。

模式的结构的描述与使用 

1．抽象产品（Product） :

 UpperClothes.java

public abstract class UpperClothes{
   public abstract int getChestSize();
   public abstract int getHeight();
   public abstract String getName(); 
}

Trousers.java

public abstract class Trousers{
   public abstract int getWaistSize();
   public abstract int getHeight();
   public abstract String getName(); 
}

2．具体产品（ConcreteProduct)_1: WesternUpperClothes.java

public class WesternUpperClothes extends UpperClothes{
   private int chestSize;
   private int height;
   private String name;
   WesternUpperClothes(String name,int chestSize,int height){
       this.name=name;
       this.chestSize=chestSize;
       this.height=height;
   }
   public int getChestSize(){
       return chestSize;
   }
   public int getHeight(){
       return height;
   }
   public String getName(){
       return name;
   } 
}

2．具体产品（ConcreteProduct)_2: CowboyUpperClothes.java

public class CowboyUpperClothes extends UpperClothes{
   private int chestSize;
   private int height;
   private String name;
   CowboyUpperClothes(String name,int chestSize,int height){
       this.name=name;
       this.chestSize=chestSize;
       this.height=height;
   }
   public int getChestSize(){
       return chestSize;
   }
   public int getHeight(){
       return height;
   }
   public String getName(){
       return name;
   } 
}

2．具体产品（ConcreteProduct)_3: WesternTrousers.java

public class WesternTrousers extends Trousers{
   private int waistSize;
   private int height;
   private String name;
   WesternTrousers(String name,int waistSize,int height){
       this.name=name;
       this.waistSize=waistSize;
       this.height=height;
   }
    public int getWaistSize(){
       return waistSize;
   }
   public int getHeight(){
       return height;
   }
   public String getName(){
       return name;
   } 
}

2．具体产品（ConcreteProduct)_4: CowboyTrousers.java

public class CowboyTrousers extends Trousers{
   private int waistSize;
   private int height;
   private String name;
   CowboyTrousers(String name,int waistSize,int height){
       this.name=name;
       this.waistSize=waistSize;
       this.height=height;
   }
    public int getWaistSize(){
       return waistSize;
   }
   public int getHeight(){
       return height;
   }
   public String getName(){
       return name;
   } 
}

3．抽象工厂（AbstractFactory）: ClothesFactory.java

public abstract class ClothesFactory{
    public abstract UpperClothes createUpperClothes(int chestSize,int height);
    public abstract Trousers createTrousers(int waistSize,int height);
}

4．具体工厂（ConcreteFactory）: BeijingClothesFactory.java

public class BeijingClothesFactory extends ClothesFactory {
    public UpperClothes createUpperClothes(int chestSize,int height){
         return new WesternUpperClothes("北京牌西服上衣",chestSize,height);
    }
    public Trousers createTrousers(int waistSize,int height){
         return new WesternTrousers("北京牌西服裤子",waistSize,height);
    }
}

ShanghaiClothesFactory.java

public class ShanghaiClothesFactory extends ClothesFactory {
    public UpperClothes createUpperClothes(int chestSize,int height){
         return new WesternUpperClothes("上海牌牛仔上衣",chestSize,height);
    }
    public Trousers createTrousers(int waistSize,int height){
         return new WesternTrousers("上海牌牛仔裤",waistSize,height);
    }
}

5．应用_1: Shop.java

public class Shop{
    UpperClothes cloth;
    Trousers trouser; 
    public void giveSuit(ClothesFactory factory,int chestSize,int waistSize,int height){
       cloth=factory.createUpperClothes(chestSize,height);
       trouser=factory.createTrousers(waistSize,height);
       showMess();
    }
    private void showMess(){
       System.out.println("<套装信息>");
       System.out.println(cloth.getName()+":");
       System.out.print("胸围:"+cloth.getChestSize());
       System.out.println("身高:"+cloth.getHeight());
       System.out.println(trouser.getName()+":");
       System.out.print("腰围:"+trouser.getWaistSize());
       System.out.println("身高:"+trouser.getHeight());
    }
}

5．应用_2: Application.java

public class Application{
    public static void main(String args[]){
       Shop shop=new Shop();
       ClothesFactory factory=new BeijingClothesFactory(); 
       shop.giveSuit(factory,110,82,170);
       factory=new ShanghaiClothesFactory(); 
       shop.giveSuit(factory,120,88,180);
    }
}

抽象工厂模式的优点

•抽象工厂模式可以为用户创建一系列相关的对象，使得用户和创建这些对象的类脱耦。

•使用抽象工厂模式可以方便的为用户配置一系列对象。用户使用不同的具体工厂就能得到一组相关的对象，同时也能避免用户混用不同系列中的对象。

•在抽象工厂模式中，可以随时增加“具体工厂”为用户提供一组相关的对象。


goingandgoing
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JAVA设计模式之工厂模式（三种工厂模式）
m0_65260253的博客
11-17 1万+
JAVA设计模式之工厂模式（三种工厂模式）
Java工厂模式（随笔）
是个非常热爱生活、乐观、奋斗、努力的逗比青年
06-01 4205
三大工厂都是哪些？简单工厂模式工厂模式抽象工厂模式特殊工厂都是哪些？容器工厂模式超级工厂模式准确的来说工厂模式一共只有三种；但在我们程序员这里不止三种，还有两种，我们把它叫 ‘容器工厂模式’ 和 ‘超级工厂模式为什么它们没有增加到三大模式呢？因为它们都是基于‘简单工厂模式’扩展开辟出来的，解决了简单工厂模式存在违反开闭原则等弊端。Java简单工厂模式是一种创建型设计模式，它提供了一个工厂类，用于根据传入的参数来决定创建哪种类的实例；
Java设计模式——工厂设计模式，详解
08-22 3709
工厂模式是一种创建对象的设计模式，它提供了一种方式来封装对象的创建逻辑，并根据不同的需求，返回相应的对象实例。工厂模式使得客户端代码与具体对象的创建过程解耦将代码中的关联性和依赖性降低，使得各个模块之间的耦合度减少），提高了代码灵活性和可维护性。总结：工厂模式是 通过封装对象创建的过程，提供了一种统一的接口来创建对象。它隐藏了对象的具体实现细节，提供了灵活性、可扩展性，并提高了代码的可读性和可维护性。工厂模式的主要目的是。
Java设计模式 - 工厂模式
三丰的专栏
10-10 1265
工厂模式主要是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。 工厂模式在《Java与模式》中分为三类： 1）简单工厂模式（Simple Factory）：不利于产生系列产品； 2）工厂方法模式（Factory Method）：又称为多形性工厂； 3）抽象工厂模式（Abstract Factory）：又称为工具箱，产生产品族，但不利于产生新的产品
Java23种设计模式之第三弹-工厂模式
weixin_44735933的博客
11-26 1841
简单工厂也称为静态工厂。是一种创建型模式。在简单工厂中，可以根据传入参数的不同返回不同类的对象实例。简单工厂是一个专门的工厂类，用来创建不同其他类的实例对象。这些实例对象通常他们的父类是同一个抽象类或者接口。相当于加了一层。在一个工厂类中生产各种产品，对单一产品的修改又或者增加产品都可能会影响到之前创建其他产品的逻辑。所以我们要加一层将创建产品的过程移至子类生产，每个工厂子类对应一个产品的生产。产品的增加和删除不会影响到其他产品的产出单个产品逻辑修改只需要在对应的工厂类修改即可，不需要动其他的工厂。
Java工厂模式
12-24
Java工厂模式的一个例子，使用配置文件来决定具体生成的实例，拓展性强
Java工厂模式定义与用法实例分析
08-25
主要介绍了Java工厂模式定义与用法,结合具体实例形式分析了java工厂模式定义、使用相关操作技巧,并总结了类图原理,需要的朋友可以参考下
JAVA工厂模式ppt
11-24
JAVA工厂模式详细讲解
设计模式之java工厂模式
03-09
创建者模式中的工厂模式
【Java开发】设计模式 02：工厂模式
尹煜的博客
03-11 1311
工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。
2022-15-Java 设计模式-抽象工厂模式
zzhangwa的博客
05-11 3298
在工厂方法模式中，我们使用一个工厂创建一个产品，一个具体工厂对应一个具体产品，但有时候我们需要一个工厂能够提供多个产品对象，而不是单一的对象，这个时候我们就需要使用抽象工厂模式。 在介绍抽象工厂模式前，我们先厘清两个概念： 产品等级结构：产品等级结构指的是产品的继承结构，例如一个空调抽象类，它有海尔空调、格力空调、美的空调等一系列的子类，那么这个空调抽象类和他的子类就构成了一个产品等级结构。 产品族：产品族是指由同一个工厂生产的，位于不同产品等级结构中的一组产品。比如，海尔工厂生产海尔空调、海尔冰
工厂模式（上）：我为什么说没事不要随便用工厂模式创建对象？
zhujiangtaotaise的专栏
12-02 419
一般情况下，工厂模式分为三种更加细分的类型：简单工厂、工厂方法和抽象工厂。不过，在 GoF 的《设计模式》一书中，它将简单工厂模式看作是工厂方法模式的一种特例，所以工厂模式只被分成了工厂方法和抽象工厂两类。实际上，前面一种分类方法更加常见，所以，在今天的讲解中，我们沿用第一种分类方法。 在这三种细分的工厂模式中，简单工厂、工厂方法原理比较简单，在实际的项目中也比较常用。而抽象工厂的原理稍微复杂点，在实际的项目中相对也不常用。所以，我们今天讲解的重点是前两种工厂模式。对于抽象工厂，你稍微了解一下即可。 除此之
Java设计模式之---工厂模式介绍
呋喃的博客
03-31 1118
工厂模式是一种常见的创建型设计模式，它提供了一种创建对象的最佳实践，将对象的创建过程封装到一个单独的类中，从而将对象的使用代码与具体对象的实现代码解耦。简单工厂模式工厂方法模式和抽象工厂模式。简单工厂模式：简单工厂模式是最基本的工厂模式，它定义了一个工厂类，根据客户端的需求创建不同的产品对象。工厂方法模式：工厂方法模式通过定义一个工厂接口和多个具体的工厂实现类，实现了客户端与具体产品类的解耦。
java工厂模式详解
qq_50278146的博客
11-14 2021
工厂模式，抽象工厂，工厂方法，简单工厂，工厂模式详解
《设计模式详解》创建型模式 - 工厂模式
萌宅鹿的技术小屋
01-05 1671
《设计模式详解》4.2 工厂模式4.2.1 概述4.2.2 简单工厂模式4.2.2.1 结构4.2.2.2 实现4.2.2.3 优缺点4.2.2.4 扩展 - 静态工厂4.2.3 工厂方法模式4.2.3.1 概念4.2.3.2 结构4.2.3.3 实现4.2.3.4 优缺点4.2.4 抽象工厂模式4.2.4.1 概念4.2.4.2 结构4.2.4.2 实现4.2.4.3 优缺点4.2.4.4 使用场景4.2.5 扩展：简单工厂 + 配置文件4.2.6 JDK源码 - Collection.iterator
【Java】设计模式（1）—工厂模式
weixin_42043946的博客
05-08 565
总体来说设计模式分为三大类：、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。这里我们先来聊聊工厂方法模式。
Java特性之设计模式【工厂模式】
Vinjcent
02-19 641
工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式
java工厂模式实验
最新发布
03-21
Java工厂模式是一种创建对象的设计模式，它提供了一种将对象的创建与使用分离的方式。通过使用工厂模式，我们可以通过调用工厂类的方法来创建对象，而不需要直接使用new关键字实例化对象。 在Java中，工厂模式通常...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值