设计模式：Abstract Factory模式

最新推荐文章于 2023-07-10 13:53:41 发布
最新推荐文章于 2023-07-10 13:53:41 发布
阅读量948 收藏 1
点赞数
分类专栏： 设计模式 Java 设计模式 文章标签： Abstract Factory 设计模式 Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39384184/article/details/80316083
版权
Java 同时被 3 个专栏收录
81 篇文章 2 订阅
订阅专栏
设计模式
28 篇文章 2 订阅
订阅专栏
设计模式
26 篇文章 5 订阅
订阅专栏

Abstract Factory模式——将关联的零件组装成产品

关于工厂模式，参见链接（设计模式：Factory Method模式）在Abstract Factory模式中，不仅有“抽象工厂”，还有“抽象零件”和“抽象产品”。抽象工厂的工作是将“抽象零件”组装成“抽象产品”。

我们并不关心零件的具体实现，而是只关心接口（API）。我们仅使用该接口（API）将零件组装成为产品。

下面的示例程序的功能是将带有层次关系的链接的集合制作成HTML文件。

在示例程序中，类被划分为以下3个包。

  • 类的一览表
包名字说明
factoryFactory表示抽象工厂的类（制作Link，Tray，Page）
factoryItem方便统一处理Link和Tray的类
factoryLink抽象零件：表示HTML的链接的类
factoryTray抽象零件：表示含有Link和Tray的类
factoryPage抽象零件：表示HTML页面的类
defaultMain测试程序行为的类
listfactoryListFactory表示具体工厂的类（制作ListLink，ListTray，ListPage）
listfactoryListLink具体零件：表示HTML的链接的类
listfactoryListTray具体零件：表示含有Link和Tray的类
listfactoryListPage具体零件：表示HTML页面的类
tablefactoryTableFactory表示具体工厂的类（制作ListLink，ListTray，ListPage）
tablefactoryTableLink具体零件：表示HTML的链接的类
tablefactoryTableTray具体零件：表示含有Link和Tray的类
tablefactoryTablePage具体零件：表示HTML页面的类

每个包中的类依次如下。

  • factory.Item类
package factory;

public abstract class Item {
    protected String caption;

    public Item(String caption) {
        this.caption = caption;
    }

    public abstract String makeHTML();
}
  • factory.Link类
package factory;

public abstract class Link extends Item {
    protected String url;

    public Link(String caption, String url) {
        super(caption);
        this.url = url;
    }
}
  • factory.Tray类
package factory;

import java.util.ArrayList;

public abstract class Tray extends Item {
    protected ArrayList tray = new ArrayList();

    public Tray(String caption) {
        super(caption);
    }

    public void add(Item item) {
        tray.add(item);
    }
}
  • factory.Page类
package factory;

import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
import java.util.ArrayList;

public abstract class Page {
    protected String title;
    protected String author;
    protected ArrayList content = new ArrayList();

    public Page(String title, String author) {
        this.title = title;
        this.author = author;
    }

    public void add(Item item) {
        content.add(item);
    }

    public void output() {
        try {
            String filename = title + ".html";
            Writer writer = new FileWriter(filename);
            writer.write(this.makeHTML());
            writer.close();
            System.out.println(filename + " has wrote.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public abstract String makeHTML();
}
  • factory.Factory类
package factory;

public abstract class Factory {
    public static Factory getFactory(String classname) {
        Factory factory = null;
        try {
            factory = (Factory) Class.forName(classname).newInstance();
        } catch (ClassNotFoundException e) {
            System.err.println("have not found " + classname + " class.");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return factory;
    }

    public abstract Link createLink(String caption, String url);

    public abstract Tray createTray(String caption);

    public abstract Page createPage(String title, String author);
}
  • Main类
import factory.Factory;
import factory.Link;
import factory.Page;
import factory.Tray;

public class Main {
    public static void main(String[] args) {
        if (args.length != 1) {
            System.out.println("Usage: java Main class.name.of.ConcreteFactory");
            System.out.println("Example 1: java Main listfactory.ListFactory");
            System.out.println("Example 2: java Main tablefactory.TableFactory");
            System.exit(0);
        }

        Factory factory = Factory.getFactory(args[0]);

        Link people = factory.createLink("人民日报",
                "http://www.people.com.cn/");
        Link gmw = factory.createLink("光明日报",
                "http://www.gmw.cn/");

        Link us_yahoo = factory.createLink("Yahoo!",
                "http://www.yahoo.com/");
        Link jp_yahoo = factory.createLink("Yahoo!Japan",
                "http://www.yahoo.co.jp/");

        Link excite = factory.createLink("Excite",
                "http://www.excite.com/");
        Link google = factory.createLink("Google",
                "http://www.google.com/");

        Tray traynews = factory.createTray("日报");
        traynews.add(people);
        traynews.add(gmw);

        Tray trayyahoo = factory.createTray("Yahoo!");
        trayyahoo.add(us_yahoo);
        trayyahoo.add(jp_yahoo);

        Tray traysearch = factory.createTray("搜索引擎");
        traysearch.add(trayyahoo);
        traysearch.add(excite);
        traysearch.add(google);

        Page page = factory.createPage("LinkPage", "F.Mortal");
        page.add(traynews);
        page.add(traysearch);
        page.output();
    }
}
  • listfactory.ListFactory类
package listfactory;

import factory.Factory;
import factory.Link;
import factory.Page;
import factory.Tray;

public class ListFactory extends Factory {

    @Override
    public Link createLink(String caption, String url) {
        return new ListLink(caption, url);
    }

    @Override
    public Tray createTray(String caption) {
        return new ListTray(caption);
    }

    @Override
    public Page createPage(String title, String author) {
        return new ListPage(title, author);
    }
}
  • listfactory.ListLink类
package listfactory;

import factory.Link;

public class ListLink extends Link {
    public ListLink(String caption, String url) {
        super(caption, url);
    }

    @Override
    public String makeHTML() {
        return "  <li><a href=\"" + url + "\">" + caption + "</a></li>\n";
    }
}
  • listfactory.ListTray类
package listfactory;

import factory.Item;
import factory.Tray;

import java.util.Iterator;

public class ListTray extends Tray {
    public ListTray(String caption) {
        super(caption);
    }

    @Override
    public String makeHTML() {
        StringBuffer buffer = new StringBuffer();
        buffer.append("<li>\n");
        buffer.append(caption + "\n");
        buffer.append("<ul>\n");
        Iterator it = tray.iterator();
        while (it.hasNext()) {
            Item item = (Item) it.next();
            buffer.append(item.makeHTML());
        }
        buffer.append("</ul>\n");
        buffer.append("</li>\n");
        return buffer.toString();
    }
}
  • listfactory.ListPage类
package listfactory;

import factory.Item;
import factory.Page;

import java.util.Iterator;

public class ListPage extends Page {
    public ListPage(String title, String author) {
        super(title, author);
    }

    @Override
    public String makeHTML() {
        StringBuffer buffer = new StringBuffer();
        buffer.append("<html><head><title>" + title + "</title></head>\n");
        buffer.append("<body>\n");
        buffer.append("<h1>" + title + "</h1>\n");
        buffer.append("<ul>\n");
        Iterator it = content.iterator();
        while (it.hasNext()) {
            Item item = (Item) it.next();
            buffer.append(item.makeHTML());
        }
        buffer.append("</ul>\n");
        buffer.append("<hr><address>" + author + "</address>");
        buffer.append("</body></html>\n");
        return buffer.toString();
    }
}
  • tablefactory.TableFactory类
package tablefactory;

import factory.Factory;
import factory.Link;
import factory.Page;
import factory.Tray;

public class TableFactory extends Factory {
    @Override
    public Link createLink(String caption, String url) {
        return new TableLink(caption, url);
    }

    @Override
    public Tray createTray(String caption) {
        return new TableTray(caption);
    }

    @Override
    public Page createPage(String title, String author) {
        return new TablePage(title, author);
    }
}
  • tablefactory.TableLink类
package tablefactory;

import factory.Link;

public class TableLink extends Link {
    public TableLink(String caption, String url) {
        super(caption, url);
    }
    @Override
    public String makeHTML() {
        return "<td><a href=\"" + url + "\">" + caption + "</a></td>\n";
    }
}
  • tablefactory.TableTray类
package tablefactory;

import factory.Item;
import factory.Tray;

import java.util.Iterator;

public class TableTray extends Tray {
    public TableTray(String caption) {
        super(caption);
    }

    @Override
    public String makeHTML() {
        StringBuffer buffer = new StringBuffer();
        buffer.append("<td>");
        buffer.append("<table width=\"100%\" border=\"1\"><tr>");
        buffer.append("<td bgcolor=\"#cccccc\" align=\"center\" colspan=\"" +
                tray.size() + "\"><b>" + caption + "</b></td>");
        buffer.append("</tr>\n");
        buffer.append("<tr>\n");
        Iterator it = tray.iterator();
        while (it.hasNext()) {
            Item item = (Item) it.next();
            buffer.append(item.makeHTML());
        }
        buffer.append("</tr></table>");
        buffer.append("</td>");
        return buffer.toString();
    }
}
  • tablefactory.TablePage类
package tablefactory;

import factory.Item;
import factory.Page;

import java.util.Iterator;

public class TablePage extends Page {
    public TablePage(String title, String author) {
        super(title, author);
    }

    @Override
    public String makeHTML() {
        StringBuffer buffer = new StringBuffer();
        buffer.append("<html><head><title>" + title + "</title></head>\n");
        buffer.append("<body>\n");
        buffer.append("<h1>" + title + "</h1>\n");
        buffer.append("<table width=\"80%\" border=\"3\">\n");
        Iterator it = content.iterator();
        while (it.hasNext()) {
            Item item = (Item)it.next();
            buffer.append("<tr>" + item.makeHTML() + "</tr>");
        }
        buffer.append("</table>\n");
        buffer.append("<hr><address>" + author + "</address>");
        buffer.append("</body></html>\n");
        return buffer.toString();
    }
}

在程序运行的时候需要**传入参数“listfactory.ListFactory”或“tablefactory.TableFactory”**来决定使用List还是Table来生成HTML文档

示例输出如下：

  • 使用listfactory.ListFactory

这里写图片描述

<html><head><title>LinkPage</title></head>
<body>
<h1>LinkPage</h1>
<ul>
<li>
日报
<ul>
  <li><a href="http://www.people.com.cn/">人民日报</a></li>
  <li><a href="http://www.gmw.cn/">光明日报</a></li>
</ul>
</li>
<li>
搜索引擎
<ul>
<li>
Yahoo!
<ul>
  <li><a href="http://www.yahoo.com/">Yahoo!</a></li>
  <li><a href="http://www.yahoo.co.jp/">Yahoo!Japan</a></li>
</ul>
</li>
  <li><a href="http://www.excite.com/">Excite</a></li>
  <li><a href="http://www.google.com/">Google</a></li>
</ul>
</li>
</ul>
<hr><address>F.Mortal</address></body></html>
  • 使用tablefactory.TableFactory

这里写图片描述

<html><head><title>LinkPage</title></head>
<body>
<h1>LinkPage</h1>
<table width="80%" border="3">
<tr><td><table width="100%" border="1"><tr><td bgcolor="#cccccc" align="center" colspan="2"><b>日报</b></td></tr>
<tr>
<td><a href="http://www.people.com.cn/">人民日报</a></td>
<td><a href="http://www.gmw.cn/">光明日报</a></td>
</tr></table></td></tr><tr><td><table width="100%" border="1"><tr><td bgcolor="#cccccc" align="center" colspan="3"><b>搜索引擎</b></td></tr>
<tr>
<td><table width="100%" border="1"><tr><td bgcolor="#cccccc" align="center" colspan="2"><b>Yahoo!</b></td></tr>
<tr>
<td><a href="http://www.yahoo.com/">Yahoo!</a></td>
<td><a href="http://www.yahoo.co.jp/">Yahoo!Japan</a></td>
</tr></table></td><td><a href="http://www.excite.com/">Excite</a></td>
<td><a href="http://www.google.com/">Google</a></td>
</tr></table></td></tr></table>
<hr><address>F.Mortal</address></body></html>

##Abstract Factory模式中的角色

  • AbstractProduct（抽象产品）

AbstractProduct角色负责定义AbstractFactory角色所生成的抽象零件和产品的接口（API）。在示例程序中，由Item类，Link类，Tray类和Page类扮演此角色。

  • AbstractFactory（抽象工厂）

AbstractFactory角色负责定义用于生成抽象产品的接口（API）。在示例程序中，由Factory类扮演此角色。

  • Client（委托者）

Client角色仅会调用AbstractFac角色和AbstractProduct角色的接口（API）来进行工作。对于具体的零件，产品和工厂一无所知。在示例程序中，由Main类扮演此角色。

  • ConcreteProduct（具体产品）

ConcreteProduct角色负责实现AbstractProduct角色的接口（API）。在示例程序中，以下类扮演此角色：

listfactory包：ListLink类，ListTray类和ListPage类。

tablefactory包：TableLink类，TableTray类和TablePage类。

  • ConcreteFactory（具体工厂）

ConcreteFactory角色负责实现AbstractFactory角色的接口（API）。在示例程序中，由ListFactory类和TableFactory类扮演此角色。

##Abstract Factory模式的思路

  • 易于增加具体的工厂

假设要在示例程序中增加新的具体工厂，那么只需要编写Factory，Link，Tray和Page这4个类的子类，并实现它们定义的抽象方法。这样，无论要增加多少个具体工厂（或是要修改具体工厂的Bug），都无需修改抽象工厂和Main部分。

  • 难以增加新的零件

而如果要在示例程序中增加新的零件，很多类都需要修改。例如，新增Picture零件，那么我们必须做以下修改：

  • 在所有的Factory类中加入createPicture方法
  • 在所有的具体实现中编写Picture类的具体实现。

想了解更多关于设计模式：设计模式专栏
设计模式总结

嘿哈哈哈
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
设计模式 t03AbstractFactory
06-11
设计模式 t03AbstractFactory
设计模式之抽象工厂模式(Abstract Factory)
程小明的博客
05-10 9768
一、抽象工厂模式(Abstract Factory)简介 抽象工厂模式(Abstract Factory)是以一个超级工厂创建其他工厂。它属于创建型模式。抽象工厂模式是工厂方法模式的升级版本，他用来创建一组相关或者相互依赖的对象。他与工厂方法模式的区别就在于，工厂方法模式针对的是一个产品等级结构；而抽象工厂模式则是针对的多个产品等级结构。 二、抽象工厂模式(Abstract Factory)的优点 抽象工厂模式将具体产品的创建延迟到具体工厂的子类中，这样将对象的创建封装起来，可以减少客户端与具体产品类之间的
Abstract Factory（抽象工厂） 模式
矢落叶の博客
06-15 1202
8.1 Abstract Factory 模式   通常，我们不会将 “抽象的” 这个词与 “工厂” 这个词联系到一起。所谓工厂，就是将零件组装成产品的地方，这是一项具体的工作。大在 Abstract Factory 模式中，不仅有 “抽象工厂” ，还有 “抽象零件” 和 “抽象产品” 。抽象工厂的工作是将 “抽象零件” 组装为 “抽象产品”。   在面向对象的编程中 “抽象” 这个词的具体含义指...
设计模式学习（九）：Abstract Factory抽象工厂模式
m0_49499183的博客
01-19 1526
Abstract的意思是“抽象的”，Factory的意思是“工厂”。在Abstract Factory模式中，不仅有“抽象工厂”，还有“抽象零件”和“抽象产品”。抽象工厂的工作是将“抽象零件”组装为“抽象产品”。请大家先回忆一下面向对象编程中的“抽象”这个词的具体含义。它指的是“不考虑具体怎样实现，而是仅关注接口(API )"的状态。例如，抽象方法(Abstract Method)并不定义方法的具体实现，而是仅仅只确定了方法的名字和签名(参数的类型和个数)。
【设计模式】抽象工厂(Abstract Factory)模式
No Pain, No Gain .
05-10 327
抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态。 定义：提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们具体的类。 为了方便引进抽象工厂模式引进一个新概念：产品族（Product Family）。所谓产品族，是指位于不同产品等级结构，功能相关联的产品组成的家族。 图中一共有四个产品族，分布于三个不同的等级结构中。只要指明一个产品所处的产品族一集它所属的等级结构中就可以为以确定这个产品。 引进抽象工厂格式 所谓的抽象工厂是指一个工厂等级结构可以常见出分属于不同产品等级结构的一.
抽象工厂模式(Abstract Factory)
weixin_43956958的博客
05-06 1057
抽象工厂模式（Abstract Factory Pattern）：属于创建型模式，它提供了一种创建对象的最佳方式。在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类，每个生成的工厂都能按照工厂模式提供对象。 意图： 提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。 主要解决：主要解决接口选择的问题。 何时使用：系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。 如何解决：在一个产品族里面，定义多个产品。 关键代码： 在一个工厂里聚合多个同类产品。 优点：
.NET设计模式（3）：抽象工厂模式（AbstractFactory）
03-03
这就是我们要说的抽象工厂模式。提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。逻辑模型：物理模型：抽象工厂的目的是要提供一个创建一系列相关或相互依赖对象的接口，而不需要指定它们具体...
设计模式之抽象工厂模式(AbstractFactory)摘录
03-04
面向对象系统的分析和设计实际上追求的就是两点：高内聚(Cohesion)和低耦合(Coupling).
抽象工厂（Abstarct Factory)
強雲的博客
07-10 545
抽象工厂类（AbstractFactory）定义了创建产品的接口，具体工厂类（ConcreteFactory1 和 ConcreteFactory2）实现了抽象工厂接口，并根据需要创建具体的产品对象。每个具体工厂实现了抽象工厂定义的方法，根据需要创建具体的产品对象。通过抽象工厂模式，我们可以在客户端代码中使用抽象工厂和抽象产品，而不需要直接与具体工厂和具体产品进行交互，从而实现了解耦和灵活的对象创建。具体产品（Concrete Product）：实现了抽象产品定义的接口，具体产品是抽象产品的实际实现。
AbstractFactory 模式
Lce的专栏
07-30 216
AbstractFactory模式关键就是将这一组对象的创建封装到一个用于创建对象的类（ConcreteFactory）中，维护这样一个创建类总比维护n多相关对象的创建过程要简单的多。图1AbstractFactoryPattern结构图。AbstractFactory模式就是用来解决这类问题的要创建一组相关或者相互依赖的对象。............
设计模式——Abstract Factory（抽象工厂）模式
qq_43664121的博客
03-26 227
抽象的零件：Item类 Item类是Link和Tray类的父类，这样Link和Tray类就具有可替换性了。 caption字段表示项目的“标题” makeHTML方法是抽象，需要子类来实现这个方法。该方法会返回HTML文件的内容（需要子类去实现） package factory; public abstract class Item { protected String caption; public Item(String caption) { this.caption
设计模式（四）——抽象工厂模式(Abstract Factory)
张宜强的博客
10-22 582
设计模式（四）——抽象工厂模式(Abstract Factory)
设计模式---抽象工厂(AbstractFactory)模式
honor_zhang的博客
10-12 218
1 名词解释 产品等级：指产品的类型一样，品牌不一样。例如空调是一种产品类型，美的空调与格力空调是不同的品牌。 产品族：同一个品牌的不同产品。例如美的的空调，电饭锅，热水器属于同一产品族。 这里引用一个图片来具体说明这两个名词解释。（来自引用2） 2 定义 是一种为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。抽象工厂模式是工厂方法模式的升级版本，工厂方法模式只生产一个等级的产品，而抽象工厂模式可生产多个等级的产品.
2.Java设计模式-----抽象工厂模式（Abstract Factory Pattern）
扛麻袋的少年的博客
04-27 1320
抽象工厂模式（Abstract Factory），是23种设计模式之一。抽象工厂模式是这样子定义的： 抽象工厂模式，提供一个创建一系列相关或互相依赖对象的接口，而无需指定它们具体的类。 在学习抽象工厂模式之前，最好熟悉简单工厂模式以及工厂方法模式，这样对理解抽象工厂模式会有一定帮助，而且抽象工厂模式是基于工厂方法模式而来的。如果你还没有了解到什么是简单工厂模式以及工厂方法模式...
设计模式(DesignPattern)之工厂模式(Factory)
inventor1024的博客
05-01 671
1、定义        定义一个创建对象的接口，由子类决定去实例化具体的类，工厂方法把实例化推迟到了子类中。2、关键点        在需要创建大量对象的时候可以使用工厂方法模式，遵循依赖倒置原则，依赖抽象接口，不依赖具体类，能够很好的减少客户端与目标类之间的耦合问题。3、UML类图4、代码实现1、工厂方法模式实现/** * 水果接口 */ public interface IFruit { ...
软件设计模式与体系结构 实验二 抽象工厂模式
abc1498880402的博客
03-25 2445
【实验内容和要求】 麦当劳（McDonalds）和肯德基（KFC）快餐店都经营汉堡（Hamburg）和可乐（Cole），用JAVA语言实现（C#控制台应用程序实现）这两个快餐店经营产品的抽象工厂模式。绘制该模式的UML图。 一、实验目的： 1) 掌握抽象工厂模式（Abstract Factory）的特点 2) 分析具体问题，使用抽象工厂模式进行设计。 二、实验环境： ...
『Java』设计模式（Design pattern）之工厂模式（Factory Pattern）
Ho1aAs‘s Blog
12-19 733
# 前言 设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结。工厂模式属于创建型模式。工厂顾名思义就是创建产品，根据产品是具体产品还是具体工厂可分为**简单工厂模式和工厂方法模式**，根据工厂的抽象程度可分为**工厂方法模式和抽象工厂模式**。 **工厂模式的本质就是对获取对象过程的抽象。** 工厂模式中，创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。
抽象工厂（Abstract Factory）模式——Java设计模式（三）
weixin_39651041的博客
04-26 2490
抽象工厂模式简介 抽象工厂模式（Abstract Factory Pattern）：围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。 分类：创建型模式。 在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。 意图：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。 主要解决：主要解决接口选择的...
【java设计模式】之 抽象工厂（Abstract Factory）模式
热门推荐
武哥聊编程
04-26 1万+
1. 女娲的失误         上一节学习了工厂模式，女娲运用了该模式成功创建了三个人种，可是问题来了，她发现没有性别……这失误也忒大了点吧……竟然没有性别，那岂不是……无奈，只好抹掉重来了，于是所有人都被消灭掉了，重新造人。         女娲开始分析了，既然要区别男女，那么生产人种的工厂（八卦炉）要重新改造了，因为一个设备要么全男性，要么全女性。所以只能将八卦炉拆开了，把原先的一个变两...
Abstract Factory 模式
最新发布
09-07
Abstract Factory 模式是一种创建型设计模式，它提供了一种创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。这个模式的主要目的是将客户端代码与具体类的创建分离，从而使客户端代码能够与抽象接口...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值