第五章 工厂模式

最新推荐文章于 2024-09-05 11:00:53 发布
最新推荐文章于 2024-09-05 11:00:53 发布
阅读量1.3k 收藏
点赞数
分类专栏： 设计模式 文章标签： java android jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_73198745/article/details/130289124
版权

文章目录

一、简单工厂模式

在这里插入图片描述

1、传统方式实现披萨订购( 可以忽略)

在这里插入图片描述

披萨父类 Pizza

package tanchishell.SJMS.factory;


//抽象类 Pizza 后续的所有 披萨都继承该类
public abstract class Pizza {

    protected String name;

    //由于不同的披萨有着不同的原材料所有 准备原材料的方法是抽象的需要子类自己去实现
    public abstract void prepare();

    //一下流程是各种披萨共有的，子类继承后自动实现
    public void bake() {
        System.out.println(name + " baking;");
    }
    public void cut() {
        System.out.println(name + " cutting;");
    }
    public void box() {
        System.out.println(name + " boxing;");
    }
    public void setName(String name) {
        this.name = name;
    }
}

子类胡椒披萨 PepperPizza

package tanchishell.SJMS.factory;

public class PepperPizza extends Pizza{
    @Override
    public void prepare() {
        System.out.println("准备胡椒披萨的原材料");
    }
}

子类印度披萨 GreekPizza

package tanchishell.SJMS.factory;

public class GreekPizza extends Pizza{
    @Override
    public void prepare() {
        System.out.println("准备希腊披萨的原材料");
    }
}

订购披萨 OrderPizza

package tanchishell.SJMS.factory;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class OrderPizza {
    //构造器

    public OrderPizza() {
        Pizza pizza = null;
        String orderType; // 订购披萨的类型
        do {
            orderType = getType();
            if (orderType.equals("greek")) {
                pizza = new GreekPizza();
                pizza.setName(" 希腊披萨 ");
            } else if (orderType.equals("pepper")) {
                pizza = new PepperPizza();
                pizza.setName("胡椒披萨");
            } else {
                System.out.println("请检查您的输入");
                break;
            }
            //输出 pizza 制作过程
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();

        } while (true);
    }


    //获取披萨的类型
    private String getType() {
        try {
            BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza 类型:");
            String str = strin.readLine();
            return str;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }

}

订购披萨的 客户端 PizzaStore

package tanchishell.SJMS.factory;

//订购Pizza的客户端
public class PizzaStore {
    public static void main(String[] args) {
        new OrderPizza();
    }

}

运行结果

在这里插入图片描述

传统的方式的优缺点，新增子类需要修改的地方牵扯太多

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

传统方式的究极耦合

新增一个子类，所有的OrderPizza类都需要修改，一旦过多，耦合度极高。

在这里插入图片描述

2、使用简单工厂模式 🔞🔞🔞

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

完整代码

披萨父类 Pizza

package tanchishell.SJMS.factory;


//抽象类 Pizza 后续的所有 披萨都继承该类
public abstract class Pizza {

    protected String name;

    //由于不同的披萨有着不同的原材料所有 准备原材料的方法是抽象的需要子类自己去实现
    public abstract void prepare();

    //以下流程是各种披萨共有的，子类继承后自动实现
    public void bake() {
        System.out.println(name + " baking;");
    }
    public void cut() {
        System.out.println(name + " cutting;");
    }
    public void box() {
        System.out.println(name + " boxing;");
    }
    public void setName(String name) {
        this.name = name;
    }
}

披萨子类 GreekPizza / PepperPizza / ChinesePizza

印度披萨

package tanchishell.SJMS.factory;

public class GreekPizza extends Pizza{
    @Override
    public void prepare() {
        System.out.println("准备希腊披萨的原材料");
    }
}

胡椒披萨

package tanchishell.SJMS.factory;

public class PepperPizza extends Pizza{
    @Override
    public void prepare() {
        System.out.println("准备胡椒披萨的原材料");
    }
}

中国披萨

package tanchishell.SJMS.factory;

public class ChinesePizza extends Pizza {
    @Override
    public void prepare() {
        System.out.println("准备中国披萨的原材料");
    }
}

订购披萨 OrderPizza

package tanchishell.SJMS.factory;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class OrderPizza{

    //定义一个简单工厂对象
//    SimpleFactory simpleFactory = new SimpleFactory(); //如果OrderPizza 和 工厂类同生共死就是组合关系
    SimpleFactory simpleFactory;
    Pizza pizza = null;

    //构造器
    public OrderPizza(SimpleFactory simpleFactory) {
        setFactory(simpleFactory);
    }
    public void setFactory(SimpleFactory simpleFactory) {
        String orderType = ""; //用户输入的，先定义一个空串提供下面使用
        this.simpleFactory = simpleFactory; //设置简单工厂对象
        do {
            orderType = getType();
            //可以在这里更换工厂方法
            pizza = this.simpleFactory.createPizza(orderType);

            //输出 pizza
            if(pizza != null) { //订购成功
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            } else {
                System.out.println(" 订购披萨失败 ");
                break;
            }
        }while(true);
    }



    //获取用户需要披萨的类型
    private String getType() {
        try {
            BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza 类型:");
            String str = strin.readLine();
            return str;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }

}

披萨简单工厂 SimpleFactory

package tanchishell.SJMS.factory;

/**
 * 添加新品种的 披萨 只需要添加一个Pizza子类和在工厂类中做一个判断
 */

public class SimpleFactory {

    //更加 orderType 返回对应的 Pizza 对象
    public Pizza createPizza(String orderType) {
        Pizza pizza = null;
        System.out.println("使用简单工厂模式");
        if (orderType.equals("greek")) {
            pizza = new GreekPizza();
            pizza.setName(" 希腊披萨 ");
        } else if (orderType.equals("chinese")) {
            pizza = new ChinesePizza();
            pizza.setName(" 中国披萨 ");
        } else if (orderType.equals("pepper")) {
            pizza = new PepperPizza();
            pizza.setName("胡椒披萨");
        }else if (orderType.equals("usa")){  //新增美国披萨
            pizza = new USAPizza();
            pizza.setName("我是美国披萨");
        }
        return pizza;
    }

    //简单工厂模式 也叫 静态工厂模
    public static Pizza createPizza2(String orderType) {
        Pizza pizza = null;
        System.out.println("使用简单工厂模式 2");
        if (orderType.equals("greek")) {
            pizza = new GreekPizza();
            pizza.setName(" 希腊披萨 ");
        } else if (orderType.equals("chinese")) {
            pizza = new ChinesePizza();
            pizza.setName(" 中国披萨 ");
        } else if (orderType.equals("pepper")) {
            pizza = new PepperPizza();
            pizza.setName("胡椒披萨");
        }
        return pizza;
    }
}

客户端订购披萨 PizzaStore

package tanchishell.SJMS.factory;

//订购Pizza的客户端
public  class PizzaStore {
    public static void main(String[] args) {
//        new OrderPizza();
        //获取订单，传入一个工厂
        new OrderPizza(new SimpleFactory());
        System.out.println("退出程序");
    }

}

添加披萨子类 USAPizza 美国披萨

package tanchishell.SJMS.factory;

public class USAPizza extends Pizza{
    @Override
    public void prepare() {
        System.out.println("准备制作美国披萨");
    }
}

在这里插入图片描述

运行结果

在这里插入图片描述

二、工厂方法模式

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

完整代码

披萨父类 Pizza

package tanchishell.SJMS.methedfactory;

//抽象类 Pizza 后续的所有 披萨都继承该类
public abstract class Pizza {

    protected String name;

    //由于不同的披萨有着不同的原材料所有 准备原材料的方法是抽象的需要子类自己去实现
    public abstract void prepare();

    //以下流程是各种披萨共有的，子类继承后自动实现
    public void bake() {
        System.out.println(name + " baking;");
    }
    public void cut() {
        System.out.println(name + " cutting;");
    }
    public void box() {
        System.out.println(name + " boxing;");
    }
    public void setName(String name) {
        this.name = name;
    }
}

北京奶酪披萨 BJCheesePizza

public class BJCheesePizza extends Pizza{
    @Override
    public void prepare() {
        setName("北京奶酪披萨");
        System.out.println("准备北京制作奶酪披萨");
    }
}

北京胡椒披萨 BJPepperPizza

public class BJPepperPizza extends Pizza {
    @Override
    public void prepare() {
        setName("北京胡椒披萨");
        System.out.println("准备北京胡椒披萨的原材料");
    }
}

伦敦奶酪披萨 LDCheesePizza

public class LDCheesePizza extends Pizza{
    @Override
    public void prepare() {
        setName("伦敦奶酪披萨");
        System.out.println("准备伦敦制作奶酪披萨");
    }
}

伦敦胡椒披萨 LDPepperPizza

public class LDPepperPizza extends Pizza {
    @Override
    public void prepare() {
        setName("伦敦胡椒披萨");
        System.out.println("准备伦敦胡椒披萨的原材料");
    }
}

抽象订购披萨 OrderPizza （充当工厂角色）

package tanchishell.SJMS.methedfactory;

import tanchishell.SJMS.factory.SimpleFactory;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public abstract class OrderPizza {


    //定义一个抽象方法，createPizza , 让各个工厂子类自己实现
    abstract Pizza createPizza(String orderType);

    // 构造器
    public OrderPizza() {
        Pizza pizza = null;
        String orderType; // 订购披萨的类型
        do {
            orderType = getType();
            pizza = createPizza(orderType); //抽象方法，由工厂子类完成
            //输出 pizza 制作过程
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
        } while (true);
    }



    //获取用户需要披萨的类型
    private String getType() {
        try {
            BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza 类型: ---- pepper(胡椒口味) -----cheese（奶酪口味）");
            String str = strin.readLine();
            return str;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }

}

订购披萨子类 BJOrderPizza / LDOrderPizza

BJOrderPizza

package tanchishell.SJMS.methedfactory;

public class BJOrderPizza extends OrderPizza{
    @Override
    Pizza createPizza(String orderType) {
        Pizza pizza = null;
        if(orderType.equals("cheese")) {
            pizza = new BJCheesePizza();
        } else if (orderType.equals("pepper")) {
            pizza = new BJPepperPizza();
        }
        /**
         * 需要添加北京口味的披萨只需要设计一个披萨子类 并在 这里加一个判断
         */
        return pizza;
    }
}

LDOrderPizza

package tanchishell.SJMS.methedfactory;

public class LDOrderPizza extends OrderPizza{
    @Override
    Pizza createPizza(String orderType) {
        Pizza pizza = null;
        if(orderType.equals("cheese")) {
            pizza = new LDCheesePizza();
        } else if (orderType.equals("pepper")) {
            pizza = new LDPepperPizza();
        }
// TODO Auto-generated method stub
        return pizza;
    }
}

客户端订购披萨

package tanchishell.SJMS.methedfactory;

import java.util.Scanner;

public class PizzaStore {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.println("请选择您的口味---目前支持 1，北京口味 ----2，伦敦口味");
        int i = scanner.nextInt();

        if(i == 1){
            new BJOrderPizza();
        }
        if(i == 2){
            new LDOrderPizza();
        }
    }
}

运行结果

在这里插入图片描述

添加披萨口味

新增子类实现

在这里插入图片描述

在对应的 Order 实现类进行判断

在这里插入图片描述

测试

在这里插入图片描述

在这里插入图片描述

三、抽象工厂模式

在这里插入图片描述

在这里插入图片描述

抽象工厂模式是对简单工厂和工厂方法的一个整合

代码示例

pizza 代码和 工厂方法模式一致，就不写了

抽象工厂 AbsFactory 接口

public interface AbsFactory {
    //让下面的工厂子类来 具体实现
    Pizza createPizza(String orderType);
}

北京披萨工厂 BJFactory 实现 AbsFactory 接口

package tanchishell.SJMS.absFactory;

public class BJFactory implements AbsFactory{
    @Override
    public Pizza createPizza(String orderType) {
        System.out.println("~使用的是抽象工厂模式~");

        Pizza pizza = null;
        if(orderType.equals("cheese")) {
            pizza = new BJCheesePizza();
        } else if (orderType.equals("pepper")){
            pizza = new BJPepperPizza();
        }
        /**
         * 添加披萨子类和判断就能完成披萨口味的添加
         */
        return pizza;
    }
}

伦敦披萨工厂 LDFactory 实现 AbsFactory 接口

package tanchishell.SJMS.absFactory;

public class LDFactory implements AbsFactory{
    @Override
    public Pizza createPizza(String orderType) {
        System.out.println("~使用的是抽象工厂模式~");
        Pizza pizza = null;
        if (orderType.equals("cheese")) {
            pizza = new LDCheesePizza();
        } else if (orderType.equals("pepper")) {
            pizza = new LDPepperPizza();
        }
        return pizza;
    }
}

披萨订购 OrderPizza 聚合 AbsFactory 接口

package tanchishell.SJMS.absFactory;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class OrderPizza {
    AbsFactory factory;

    // 构造器
    public OrderPizza(AbsFactory factory) {
        setFactory(factory);
    }

    private void setFactory(AbsFactory factory) {
        Pizza pizza = null;
        String orderType = ""; // 用户输入
        this.factory = factory;
        do {
            orderType = getType();
// factory 可能是北京的工厂子类，也可能是伦敦的工厂子类
            pizza = factory.createPizza(orderType);
            if (pizza != null) { // 订购 ok
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            } else {
                System.out.println("订购失败");
                break;
            }
        } while (true);
    }

    // 写一个方法，可以获取客户希望订购的披萨种类
    private String getType() {
        try {
            BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza 类型: ---- pepper(胡椒口味) -----cheese（奶酪口味）");
            String str = strin.readLine();
            return str;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }
}

客户端订购披萨

package tanchishell.SJMS.absFactory;

import java.util.Scanner;

public class PizzaStore {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.println("请选择您的口味---目前支持 1，北京口味 ----2，伦敦口味");
        int i = scanner.nextInt();

        if(i == 1){
            new OrderPizza(new BJFactory());
        }
        if(i == 2){
            new OrderPizza(new LDFactory());
        }
    }
}

运行结果

在这里插入图片描述

JDKの工厂模式: Calendar日历类

在这里插入图片描述

        Calendar cal = Calendar.getInstance();
// 注意月份下标从0开始，所以取月份要+1
        System.out.println("年:" + cal.get(Calendar.YEAR));
        System.out.println("月:" + (cal.get(Calendar.MONTH) + 1));
        System.out.println("日:" + cal.get(Calendar.DAY_OF_MONTH));
        System.out.println("时:" + cal.get(Calendar.HOUR_OF_DAY));
        System.out.println("分:" + cal.get(Calendar.MINUTE));
        System.out.println("秒:" + cal.get(Calendar.SECOND));

进入Calendar cal = Calendar.getInstance();

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

工厂模式小结

在这里插入图片描述

无奈朝来寒雨晚来风
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
第三章：类创建型模式之工厂模式
一只猫的博客
02-09 476
工厂模式是一种创建型模式，具体属于类创建型模式，它提供了一种创建对象的最佳实现。在工厂模式中有一个专门的工厂类来负责实例化各种产品实例，而客户端代码通过工厂类对象来获得所需要的产品实例。工厂模式有三种实现方式，分别是简单工厂模式工厂方法模式和抽象工厂模式。简单工厂模式是工厂模式的基础形式，它通过一个简单的工厂类来实现所有的产品实例，根据传入的参数来决定实例化特定的产品实例。工厂方法模式定义了一个用于创建实例的接口或抽象类，由实现它的具体工厂子类决定实例化的产品类型。抽象工厂模式。
第四章：Spring AOP API 设计模式1
08-03
5. **单例模式（Singleton）**：Spring AOP中的`SingletonTargetSource`保证了每个目标对象只被创建一次，实现了单例模式，确保在整个应用程序中只有一个共享的实例存在，提高了资源利用效率。 6. **适配器模式...
第五章 工厂方法模式
Lin_Miao_09的博客
06-03 860
在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。
【设计模式】第5章·抽象工厂模式
weixin_44143114的博客
08-23 408
**抽象工厂模式**：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们的具体的类。
设计模式-第6章（工厂模式）
保持热爱，持续学习
03-01 2075
简单工厂实现 工厂模式实现 简单工厂 VS 工厂方法 商场收银程序再再升级（简单工厂+策略+装饰+工厂方法） 工厂方法模式总结
设计模式--第十八章 抽象工厂模式
追梦的土豆的博客
04-07 192
第十八章 抽象工厂模式
第五章：工厂模式
u014692224的博客
11-09 750
1.简单工厂模式 简单工厂模式的实际需求 看一个披萨的项目：要便于披萨种类的扩展，要便于维护 1.披萨的种类很多(比如 GreekPizz、CheesePizz 等) 2.披萨的制作有 prepare、bake、cut、box 3.完成披萨店订购功能 传统方式的代码实现 类图设计 代码实现 Pizza 抽象父类 //将Pizza 类做成抽象 public abstract class Pizza { protected String name; //名字 public void setName
大话设计模式：第8章 工厂方法模式
Always On The Way
04-26 163
第8章：工厂方法模式 简单工厂 v.s. 工厂方法 简单工厂模式 优点：工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关的类，对于客户端来说，去除了与具体产品的依赖。 局限：增加功能时，需要修改原有的工厂类，违背了开放-封装原则 在简单工厂模式中，由于工厂类与分支耦合，根据依赖倒转原则，应将工厂类抽象成一个接口，这个接口只有一个方法，就是创建抽象产品的工厂方法。然后，所...
第五章：设计模式-工厂模式
p812438109的专栏
11-05 145
一）介绍 工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。该设计模式属于创建型模式，它提供了一种创建对象的最佳方式。 主要解决：接口选择的问题。 何时使用：明确知道不同条件下创建不同实例时。 如何解决：让其子类实现工厂接口，返回的也是一个抽象的产品。 优点： 1、一个调用者想创建一个对象，只要知道其对象名称就可以了。 2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。 3、屏蔽产品的具体实现，调用者只关心产品的接口。 缺点：每次增加一个产品时.
第3章 工厂方法模式
the_bud的博客
06-08 292
第3章 工厂方法模式 软件开发的过程中实现软件对象的生产和使用相分离，在满足开闭原则的前提下，客户可以随意增删或改变软件相关对象的使用，是工厂方法模式讨论的问题。 3.1模式的定义 定义一个创建产品对象的工厂接口，将产品对象的实际创建工作推迟到具体子工厂类当中。这满足创建型模式中所要求的“创建与使用相分离”的特点。我们把被创建的对象称为“产品”，把创建产品的对象称为“工厂”。 简单工厂模式 如果要创建的产品不多，只要一个工厂类就能完成，这就是简单工厂模式，但这样违背了“开闭原则”，简单工厂模式不是23中
第5章_工厂方法模式.ppt
03-29
在简单工厂模式中，只提供了一个工厂类，该工厂类处于对产品类进行实例化的中心位置，它知道每一个产品对象的创建细节，并决定何时实例化哪一个产品类。简单工厂模式最大的缺点是当有新产品要加入到系统中时，必须...
第10章设计模式-解析1
08-03
设计模式是软件工程中经过实践验证的解决方案模板，用于解决常见的设计问题。以下是针对题目中提到的设计模式的详细解释： 1. **命令模式（Command）**：命令模式将一个请求封装为一个对象，使得可以使用不同的请求...
Java基础（6）- Java代码笔记3
weixin_47062560的博客
08-30 3240
数据类型[][] 数组名 = new 数据类型[m][n]数据类型 数组名[][] = new 数据类型[m][n]数据类型[] 数组名[] = new 数据类型[m][n]m：代表二维数组长度n：代表二维数组中每个一维数组的长度。
JAVA基础：数据类型、命名规范
weixin_53755148的博客
09-05 1141
变量类型就是用来指定变量中存储数据的类型。也称为数据类型。
浅析synchronized锁升级的原理与实现 1
水w的博客
09-01 1244
浅析synchronized锁升级的原理与实现
基于JavaWeb开发的JavaSpringboot+Vue实现前后端分离房屋租赁系统
最新发布
央顺科技官方博客
09-05 418
2021年处于信息科技高速发展的大背景之下。在今天，缺少手机和电脑几乎已经成为不可能的事情，人们生活中已经难以离开手机和电脑。针对增加的成本管理和操作,各大商家非常有必要建立自己的网上房屋租赁平台系统，这既可以让更多的人体验到网络所带来的方便，也有助于提高房屋的租赁。在经过几十年的高速发展后，互联网已成为最流行、最普及的媒体，每天的信息流量甚至能比得上过去十年。其以便捷的信息交换、快速的沟通速度，悄然地改变着会员的消费方式。
计算机毕业设计选题推荐-任务管理系统-项目任务分配系统-Java/Python项目实战
IT研究室的博客
09-03 803
随着信息化技术的迅猛发展，各类企业和组织越来越依赖于高效的任务管理系统以保证其日常运营的顺利进行。根据IDC（国际数据公司）发布的报告显示，全球企业在数字化转型上的投入已达数千亿美元，其中相当一部分资金用于提升企业内部的管理效率。任务管理系统作为企业信息化的重要组成部分，能有效帮助企业分配、监控和反馈任务，从而提高工作效率。然而，尽管市场上已有多种任务管理系统，它们在功能、用户体验和适用性上存在显著差异。
数据访问：JPA
hhgh_的博客
09-02 1005
其二，Sun希望整合ORM 技术，实现统一的 API调用接口。@Table（name=“”,catalog=“”,schema=“”）可选，用来标注一个数据库对应的实体类，数据库中创建的表明默认和类名一致，通常和@Entity配合使用，只能标注在实体的class定义处，表示实体对应的数据库表的信息。@Entity(name=“EntityName”)必须，用来标注一个数据库表对应的实体，数据库中创建的表明默认和类名一致，其中，name可选，对应数据库中的一个表，使用此注解标记Pojo是一个JPA实体。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值