设计模式------工厂模式

于 2018-02-24 16:48:59 发布
阅读量181 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jesse_cool/article/details/79363133
版权

fenlei

1）简单工厂模式（Simple Factory） 

2）工厂方法模式（Factory Method） 

3）抽象工厂模式（Abstract Factory） 

也可将工厂模式分为两类：工厂方法模式（Factory Method）与抽象工厂模式（Abstract Factory）。将简单工厂模式（Simple Factory）看为工厂方法模式的一种特例，两者归为一类。 


/**
 * 抽象产品角色
 * @author Administrator
 *
 */
public interface Car {
    public void drive();
}



/**
 * 具体产品类
 * @author Administrator
 *
 */
public class benzCar implements Car {
    @Override
    public void drive() {
        System.out.println("驾驶奔驰车......");
    }

}

/**
 * 具体产品类
 * @author Administrator
 *
 */
public class bmwCar implements Car {

    @Override
    public void drive() {
        System.out.println("驾驶宝马车......");
    }
}


/**
 * 工厂类角色
 * @author Administrator
 *
 */
public class driverFactory {
    //返回类型必须为抽象产品角色
    public static Car dirveCar(String params) throws          Exception{
        //判断逻辑，返回具体的产品角色给Client
        if(params.equals("benzCar")){
            return new benzCar();
        }else if(params.equals("bmwCar")){
            return new bmwCar();
        }else{
            throw new Exception(); 
        }   
    }
}
//客户
public class Client {
    public static void main(String[] args) throws Exception {
        //告诉司机(工厂) 开奔驰车
        Car car=driverFactory.dirveCar("benzCar");
        //下命令开车
        car.drive();
    }
}


/**
 * 抽象产品角色
 * @author Administrator
 *
 */
public interface Car {
    public void drive();
}



/**
 * 具体产品类
 * @author Administrator
 *
 */
public class benzCar implements Car {
    @Override
    public void drive() {
        System.out.println("驾驶奔驰车......");
    }

}

/**
 * 具体产品类
 * @author Administrator
 *
 */
public class bmwCar implements Car {

    @Override
    public void drive() {
        System.out.println("驾驶宝马车......");
    }
}


/**
 * 工厂类角色
 * @author Administrator
 *
 */
public class driverFactory {
    //返回类型必须为抽象产品角色
    public static Car dirveCar(String params) throws          Exception{
        //判断逻辑，返回具体的产品角色给Client
        if(params.equals("benzCar")){
            return new benzCar();
        }else if(params.equals("bmwCar")){
            return new bmwCar();
        }else{
            throw new Exception(); 
        }   
    }
}
//客户
public class Client {
    public static void main(String[] args) throws Exception {
        //告诉司机(工厂) 开奔驰车
        Car car=driverFactory.dirveCar("benzCar");
        //下命令开车
        car.drive();
    }
}

简单工厂模式将逻辑全部集中在单个工厂中，工厂负责生产所有汽车，无论是奔驰还是宝马，缺点是每次加车型都要去工厂里改逻辑。这时工厂方法出现了


/**
 * 抽象产品角色
 * @author Administrator
 *
 */
public interface Car {
    public void drive();
}



/**
 * 具体产品类
 * @author Administrator
 *
 */
public class benzCar implements Car {
    @Override
    public void drive() {
        System.out.println("驾驶奔驰车......");
    }

}

/**
 * 具体产品类
 * @author Administrator
 *
 */
public class bmwCar implements Car {

    @Override
    public void drive() {
        System.out.println("驾驶宝马车......");
    }
}


/**
 * 工厂类角色
 * @author Administrator
 *
 */
public class driverFactory {
    //返回类型必须为抽象产品角色
    public static Car dirveCar(String params) throws          Exception{
        //判断逻辑，返回具体的产品角色给Client
        if(params.equals("benzCar")){
            return new benzCar();
        }else if(params.equals("bmwCar")){
            return new bmwCar();
        }else{
            throw new Exception(); 
        }   
    }
}
//客户
public class Client {
    public static void main(String[] args) throws Exception {
        //告诉司机(工厂) 开奔驰车
        Car car=driverFactory.dirveCar("benzCar");
        //下命令开车
        car.drive();
    }
}



/**
 * 抽象产品角色
 * @author Administrator
 *
 */
abstract class Car {
    abstract void drive();
}


/**
 * 具体产品类
 * @author Administrator
 *
 */
public class bmwCar extends Car {

    @Override
    public void drive() {
        System.out.println("驾驶宝马车......");
    }
}
/**
 * 具体产品类
 * @author Administrator
 *
 */
public class benzCar extends Car {
    @Override
    public void drive() {
        System.out.println("驾驶奔驰车......");
    }
}


/**
 * 抽象工厂角色 用來生产车
 * @author Administrator
 *
 */
public interface abstractFactory {
    public Car driveFactory();

}


/**
 * 具体工厂角色
 * 创建奔驰车对象
 */
public class benzCarFactory implements abstractFactory {
    @Override
    public  Car driveFactory() {
        return new benzCar();
    }
}


/**
 * 具体工厂角色
 * 创建宝马车对象
 */
public class bmwCarFactory implements abstractFactory {
    @Override
    public Car driveFactory() {
        return new bmwCar();
    }
}


//客户
public class Client {
    private static Car benzcar,bmwcar;
    private static abstractFactory benzcarfactory,bmwcarfactory;
    public static void main(String[] args) throws Exception {
        //告诉(工厂) 要奔驰车
        benzcarfactory=new benzCarFactory();
        benzcar=benzcarfactory.driveFactory();
        //可以开车了
        benzcar.drive();
        System.out.println("-------------------");
        bmwcarfactory=new bmwCarFactory();
        bmwcar=bmwcarfactory.driveFactory();
        bmwcar.drive();
    }
}


多个工厂，每个工厂生产自己的一种车

抽象工厂模式

/**
 * 抽象产品角色
 * @author Administrator
 *
 */
public interface Car {
    public void drive();
}



/**
 * 具体产品类
 * @author Administrator
 *
 */
public class benzCar implements Car {
    @Override
    public void drive() {
        System.out.println("驾驶奔驰车......");
    }

}

/**
 * 具体产品类
 * @author Administrator
 *
 */
public class bmwCar implements Car {

    @Override
    public void drive() {
        System.out.println("驾驶宝马车......");
    }
}


/**
 * 工厂类角色
 * @author Administrator
 *
 */
public class driverFactory {
    //返回类型必须为抽象产品角色
    public static Car dirveCar(String params) throws          Exception{
        //判断逻辑，返回具体的产品角色给Client
        if(params.equals("benzCar")){
            return new benzCar();
        }else if(params.equals("bmwCar")){
            return new bmwCar();
        }else{
            throw new Exception(); 
        }   
    }
}
//客户
public class Client {
    public static void main(String[] args) throws Exception {
        //告诉司机(工厂) 开奔驰车
        Car car=driverFactory.dirveCar("benzCar");
        //下命令开车
        car.drive();
    }
}

/**
 * 抽象产品角色
 * @author Administrator
 *
 */
abstract class Car {
    abstract void drive();
}


/**
 * 具体产品类
 * @author Administrator
 *
 */
public class bmwCar extends Car {

    @Override
    public void drive() {
        System.out.println("驾驶宝马车......");
    }
}
/**
 * 具体产品类
 * @author Administrator
 *
 */
public class benzCar extends Car {
    @Override
    public void drive() {
        System.out.println("驾驶奔驰车......");
    }
}


/**
 * 抽象工厂角色 用來生产车
 * @author Administrator
 *
 */
public interface abstractFactory {
    public Car driveFactory();

}


/**
 * 具体工厂角色
 * 创建奔驰车对象
 */
public class benzCarFactory implements abstractFactory {
    @Override
    public  Car driveFactory() {
        return new benzCar();
    }
}


/**
 * 具体工厂角色
 * 创建宝马车对象
 */
public class bmwCarFactory implements abstractFactory {
    @Override
    public Car driveFactory() {
        return new bmwCar();
    }
}


//客户
public class Client {
    private static Car benzcar,bmwcar;
    private static abstractFactory benzcarfactory,bmwcarfactory;
    public static void main(String[] args) throws Exception {
        //告诉(工厂) 要奔驰车
        benzcarfactory=new benzCarFactory();
        benzcar=benzcarfactory.driveFactory();
        //可以开车了
        benzcar.drive();
        System.out.println("-------------------");
        bmwcarfactory=new bmwCarFactory();
        bmwcar=bmwcarfactory.driveFactory();
        bmwcar.drive();
    }
}



// 抽象工厂类  定义不同的产品之间的标准，商务车
public interface ICarA {
    public void drive();
}


// 抽象工厂类  定义不同的产品之间的标准 跑车族
public interface ICarB {
    public void drive();
}

//具体产品类
public class productAHongqi implements ICarA {
    @Override
    public void drive() {
        System.out.println("开商务族--红旗车");
    }
}

//具体工厂类
public class productABmw implements ICarA {
    @Override
    public void drive() {
         System.out.println("开商务族--宝马车 ..."); 
    }
}

//具体产品类
public class producSporttBAudi implements ICarB {
    @Override
    public void drive() {
        System.out.println("开跑车族--奥迪车...");
    }
}


//具体工厂类
public class productSportBBenz implements ICarB {
    @Override
    public void drive() {
         System.out.println("开跑车族--奔驰车 ..."); 
    }
}


/**
 * 抽象工厂类 创建跑车族跑车
 * @author Administrator
 *
 */
public abstract class abstractoryFactory1 {
    abstract ICarB getProductBBenz();
    abstract ICarB getProductBAudi();
}


/**
 * 抽象工厂类  创建商务族跑车
 * @author Administrator
 *
 */
public abstract class abstractoryFactory2 {
    abstract ICarA getProductABmw();
    abstract ICarA getProductBHongqi();
}


/**
 * 具体工厂类 跑车族
 * @author Administrator
 *
 */
public class Factory1 extends abstractoryFactory1 {

    @Override
    ICarB getProductBBenz() {
        return new productSportBBenz();
    }

    @Override
    ICarB getProductBAudi() {
        return new producSporttBAudi();
    }
}


/**
 * 具体工厂类
 * 商务族
 * @author Administrator
 *
 */
public class Factory2 extends abstractoryFactory2 {
    @Override
    ICarA getProductABmw() {
        return new productABmw();
    }

    @Override
    ICarA getProductBHongqi() {
        return new productAHongqi();
    }
}


public class Client {
    public static void main(String[] args) {
        //工厂一制造的产品族车
        abstractoryFactory1 factory1 = new Factory1(); 
        ICarB productsportAbenz = factory1.getProductBBenz(); 
        ICarB productsportBaudi = factory1.getProductBAudi(); 

        productsportAbenz.drive(); 
        productsportBaudi.drive(); 
        //工厂二制造的产品族车
        abstractoryFactory2 factory2 = new Factory2(); 
        ICarA productAbmw = factory2.getProductABmw(); 
        ICarA productBhongqi = factory2.getProductBHongqi(); 
        productAbmw.drive(); 
        productBhongqi.drive(); 
    }
}

表面上抽象工厂就是每个工厂里有一系列的产品（单个产品族，例如跑车）

六、和工厂方法模式区别 

工厂方法模式： 
一个抽象产品类，可以派生出多个具体产品类。 
一个抽象工厂类，可以派生出多个具体工厂类。 
每个具体工厂类只能创建 一个 具体产品类的实例。 
抽象工厂模式： 
多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。 
一个抽象工厂类，可以派生出多个具体工厂类。 
每个具体工厂类可以创建 多个 具体产品类的实例。 
区别： 
工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个(产品族)。 
工厂方法模式的具体工厂类只能创建一个具体产品类的实例(一对一),而抽象工厂模式可以创建多个具体产品类的实例(一对多)。 
/**
 * 抽象产品角色
 * @author Administrator
 *
 */
abstract class Car {
    abstract void drive();
}


/**
 * 具体产品类
 * @author Administrator
 *
 */
public class bmwCar extends Car {

    @Override
    public void drive() {
        System.out.println("驾驶宝马车......");
    }
}
/**
 * 具体产品类
 * @author Administrator
 *
 */
public class benzCar extends Car {
    @Override
    public void drive() {
        System.out.println("驾驶奔驰车......");
    }
}


/**
 * 抽象工厂角色 用來生产车
 * @author Administrator
 *
 */
public interface abstractFactory {
    public Car driveFactory();

}


/**
 * 具体工厂角色
 * 创建奔驰车对象
 */
public class benzCarFactory implements abstractFactory {
    @Override
    public  Car driveFactory() {
        return new benzCar();
    }
}


/**
 * 具体工厂角色
 * 创建宝马车对象
 */
public class bmwCarFactory implements abstractFactory {
    @Override
    public Car driveFactory() {
        return new bmwCar();
    }
}


//客户
public class Client {
    private static Car benzcar,bmwcar;
    private static abstractFactory benzcarfactory,bmwcarfactory;
    public static void main(String[] args) throws Exception {
        //告诉(工厂) 要奔驰车
        benzcarfactory=new benzCarFactory();
        benzcar=benzcarfactory.driveFactory();
        //可以开车了
        benzcar.drive();
        System.out.println("-------------------");
        bmwcarfactory=new bmwCarFactory();
        bmwcar=bmwcarfactory.driveFactory();
        bmwcar.drive();
    }
}
// 抽象工厂类  定义不同的产品之间的标准，商务车
public interface ICarA {
    public void drive();
}


// 抽象工厂类  定义不同的产品之间的标准 跑车族
public interface ICarB {
    public void drive();
}

//具体产品类
public class productAHongqi implements ICarA {
    @Override
    public void drive() {
        System.out.println("开商务族--红旗车");
    }
}

//具体工厂类
public class productABmw implements ICarA {
    @Override
    public void drive() {
         System.out.println("开商务族--宝马车 ..."); 
    }
}

//具体产品类
public class producSporttBAudi implements ICarB {
    @Override
    public void drive() {
        System.out.println("开跑车族--奥迪车...");
    }
}


//具体工厂类
public class productSportBBenz implements ICarB {
    @Override
    public void drive() {
         System.out.println("开跑车族--奔驰车 ..."); 
    }
}


/**
 * 抽象工厂类 创建跑车族跑车
 * @author Administrator
 *
 */
public abstract class abstractoryFactory1 {
    abstract ICarB getProductBBenz();
    abstract ICarB getProductBAudi();
}


/**
 * 抽象工厂类  创建商务族跑车
 * @author Administrator
 *
 */
public abstract class abstractoryFactory2 {
    abstract ICarA getProductABmw();
    abstract ICarA getProductBHongqi();
}


/**
 * 具体工厂类 跑车族
 * @author Administrator
 *
 */
public class Factory1 extends abstractoryFactory1 {

    @Override
    ICarB getProductBBenz() {
        return new productSportBBenz();
    }

    @Override
    ICarB getProductBAudi() {
        return new producSporttBAudi();
    }
}


/**
 * 具体工厂类
 * 商务族
 * @author Administrator
 *
 */
public class Factory2 extends abstractoryFactory2 {
    @Override
    ICarA getProductABmw() {
        return new productABmw();
    }

    @Override
    ICarA getProductBHongqi() {
        return new productAHongqi();
    }
}


public class Client {
    public static void main(String[] args) {
        //工厂一制造的产品族车
        abstractoryFactory1 factory1 = new Factory1(); 
        ICarB productsportAbenz = factory1.getProductBBenz(); 
        ICarB productsportBaudi = factory1.getProductBAudi(); 

        productsportAbenz.drive(); 
        productsportBaudi.drive(); 
        //工厂二制造的产品族车
        abstractoryFactory2 factory2 = new Factory2(); 
        ICarA productAbmw = factory2.getProductABmw(); 
        ICarA productBhongqi = factory2.getProductBHongqi(); 
        productAbmw.drive(); 
        productBhongqi.drive(); 
    }
}

六、和工厂方法模式区别 
工厂方法模式： 
一个抽象产品类，可以派生出多个具体产品类。 
一个抽象工厂类，可以派生出多个具体工厂类。 
每个具体工厂类只能创建一个具体产品类的实例。 
抽象工厂模式： 
多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。 
一个抽象工厂类，可以派生出多个具体工厂类。 
每个具体工厂类可以创建多个具体产品类的实例。 
区别： 
工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个(产品族)。 
工厂方法模式的具体工厂类只能创建一个具体产品类的实例(一对一),而抽象工厂模式可以创建多个具体产品类的实例(一对多)。

Jesse_cool
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
c++设计模式-工厂方法模式
06-04
在标题“c++设计模式-工厂方法模式”中，我们关注的是如何在C++中实现工厂方法这一设计模式。工厂方法模式的核心思想是定义一个创建对象的接口，但让子类决定实例化哪一个类。这样，工厂方法可以使类的实例化过程...
设计模式-工厂模式.pdf
04-11
设计模式 -工厂模式.pdf
Python设计模式-工厂模式
01-20
工厂模式有三种模式： 简单工厂模式：定义一个创建对象接口，通过参数来决定创建哪个类的实例 工厂方法模式：定义一个创建对象接口，让子类来决定创建哪个类的实例，工厂方法使一个类的实例化延迟到到其子类中 抽象...
设计模式-简单工厂模式-例题
03-13
设计模式第四章简单工厂模式一个小例题，类图+简单代码
设计模式-工厂模式
04-05
工厂模式是设计模式中的一个基础且重要的部分，它属于创建型设计模式，主要用于封装对象的创建过程，使得客户端不必关心具体的实现细节，提高了代码的可扩展性和可维护性。 工厂模式主要有三种形式：简单工厂模式、...
maven下载、安装、配置与使用教程&相关项目
07-06
【maven】下载、安装、配置与使用教程&相关项目
装甲车水上转向系统液压摆动油缸及液压系统设计（有cad图+三维图+原理图）.doc
07-05
装甲车水上转向系统液压摆动油缸及液压系统设计（有cad图+三维图+原理图）.doc
EY-零售和商业银行业务中的生成式人工智能（英文）(1).pdf
07-05
EY-零售和商业银行业务中的生成式人工智能（英文）(1).pdf
PWM - 单片机开发 - 安装 - 源代码
07-06
Contents 1. Installation 2 2. Creating the Project Workspace2 3. Opening Sample Code and Source8 4. Source Code Functionality 8
唯美陶瓷有限公司资本结构分析 毕设.docx
07-05
唯美陶瓷有限公司资本结构分析 毕设.docx
人工智能面试题（二）.docx
07-05
机器学习：介绍了基础概念、算法的原理和应用场景，如决策树、支持向量机和集成学习等，帮助读者理解如何选择和优化不同的机器学习模型。 深度学习：深入探讨了深度神经网络的架构、训练技巧和优化方法，涵盖卷积神经网络、递归神经网络和生成对抗网络等主题，提供了大量的实际案例和模型调优技巧。 强化学习：阐述了强化学习的核心概念和算法，如Q学习、策略梯度方法等，介绍了如何在不同的环境中应用这些算法来优化策略。 自然语言处理：涵盖了文本处理、词嵌入、机器翻译和文本生成等内容，提供了如何在文本分类、情感分析和语言生成等任务中应用先进算法的方法。 计算机视觉：详细讲解了图像分类、目标检测和语义分割等技术，讨论了如何处理图像数据中的挑战，如类别不平衡和数据增强等。
ACM的相关案例.txtACM的相关案例.txt
07-05
ACM的相关案例.txtACM的相关案例.txtACM的相关案例.txtACM的相关案例.txtACM的相关案例.txtACM的相关案例.txtACM的相关案例.txtACM的相关案例.txtACM的相关案例.txtACM的相关案例.txtACM的相关案例.txtACM的相关案例.txtACM的相关案例.txtACM的相关案例.txtACM的相关案例.txtACM的相关案例.txtACM的相关案例.txtACM的相关案例.txtACM的相关案例.txtACM的相关案例.txtACM的相关案例.txtACM的相关案例.txtACM的相关案例.txtACM的相关案例.txtACM的相关案例.txtACM的相关案例.txtACM的相关案例.txtACM的相关案例.txtACM的相关案例.txtACM的相关案例.txtACM的相关案例.txtACM的相关案例.txtACM的相关案例.txtACM的相关案例.txtACM的相关案例.txtACM的相关案例.txt
Python项目开发实战：视频监控系统(案例教程实例课程).pdf
07-05
Python项目开发实战：视频监控系统(案例教程实例课程).pdf
arduino创意作品.docx
07-06
Arduino创意作品是基于Arduino开发板的创新性项目，涵盖了多个领域，如机器人、智能家居、艺术装置等。Arduino的开源性质和简单易用的特点，使得这些创意作品能够轻松实现，并展现出丰富的想象力和创造力。以下是一些Arduino创意作品的示例： 1. 智能家居控制系统 功能描述：使用Arduino板和传感器构建一个智能家居控制系统，可以控制灯光、温度、湿度、空调、窗户和安全系统等设备。用户可以通过手机应用程序远程控制这些设备，实现家居的智能化管理。 应用场景：适用于现代家庭，提升居住舒适度和便利性。 2. 自动浇水系统 功能描述：将Arduino板与水泵和土壤湿度传感器配合使用，构建一个自动浇水系统。系统可以实时监测土壤湿度，并根据设定的阈值自动开启或关闭水泵，保证植物的健康成长。 应用场景：适用于家庭园艺、温室大棚等场景，减轻人工浇水的负担。 3. 智能车辆 功能描述：使用Arduino板和电机控制器构建一个智能车辆，可以通过遥控器或移动设备进行控制。车辆还可以添加传感器以提高安全性能，如避障传感器、红外传感器等。 应用场景：适用于玩具车、教育机器人等场景，提供趣味性和教育
java面试的相关案例.txtjava面试的相关案例.txt
07-05
java面试java面试的相关案例.txtjava面试的相关案例.txtjava面试的相关案例.txtjava面试的相关案例.txtjava面试的相关案例.txtjava面试的相关案例.txtjava面试的相关案例.txtjava面试的相关案例.txtjava面试的相关案例.txtjava面试的相关案例.txtjava面试的相关案例.txtjava面试的相关案例.txtjava面试的相关案例.txtjava面试的相关案例.txtjava面试的相关案例.txtjava面试的相关案例.txtjava面试的相关案例.txtjava面试的相关案例.txtjava面试的相关案例.txtjava面试的相关案例.txtjava面试的相关案例.txtjava面试的相关案例.txtjava面试的相关案例.txtjava面试的相关案例.txtjava面试的相关案例.txtjava面试的相关案例.txtjava面试的相关案例.txtjava面试的相关案例.txtjava面试的相关案例.txtjava面试的相关案例.txtjava面试的相关案例.txtjava面试的相关案例.txtjava面试的相关案例.tx
大型企业数字化转型管控平台解决方案两套材料.pptx
07-05
大型企业数字化转型管控平台解决方案两套材料.pptx
content_1720250468391.vsdx
07-06
content_1720250468391.vsdx
css,基础知识小总结
最新发布
07-06
前端，初学者基础知识小总结，内容简单易懂，适合想学习前端的新手小百查考学习,内容有 标签选择器，类选择器 ，id选择器，通配符，后代选择器，子选择器， 并集选择器，伪类选择器，字体“ 样式 系列 大小 粗细 风格”，文本样式 ，文本颜色，文本对齐，装饰文本，文本缩进，行间距，背景颜色， 背景图片，背景平铺，背景图片位置，背景样式简写，背景色半透明，元素的显示模式：“块元素, 行内元素,行内块元素,元素显示模式的转换" ,边框、外边距、内边距、实际内容,浮动，网页布局总结，清除浮动，CSS样式表：“行内样式表，内部样式表，外部样式表,这些基础前端内容。还未学习前端，想了解前端的宝子们可以看看。
B4-三层效果图、施工图312(12.24x9.54)建筑结构施工图.dwg
07-05
B4-【三层】效果图、施工图312(12.24x9.54)建筑结构施工图.dwg
图解Java设计模式-23种设计模式
08-28
- 抽象工厂模式（Abstract Factory Pattern） - 单例模式（Singleton Pattern） - 原型模式（Prototype Pattern） - 建造者模式（Builder Pattern） 2. 结构型模式（Structural Patterns）： - 适配器模式...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值