《大话设计模式》之 简单工厂模式 Delphi/C shap /JAVA 实现

最新推荐文章于 2024-04-19 09:28:54 发布
最新推荐文章于 2024-04-19 09:28:54 发布
阅读量879 收藏
点赞数
分类专栏： 程序 程序Delphi 程序C# 文章标签： 设计模式 工厂模式 DelphiC shap JAVA
程序 同时被 3 个专栏收录
92 篇文章 8 订阅
订阅专栏
程序Delphi
46 篇文章 1 订阅
订阅专栏
程序C#
4 篇文章 0 订阅
订阅专栏

{

计算器的功能实现
 实现工厂设计模式
 通过面向对象的思想，进行设计，所用的编程思想为对象的三大特性：封装，继承，多态
 通过实现一个简单的 计算器的功能（输入两个数，进行加，减，乘，除）

 思想思路：
 1.设计虚拟父类;
 2.子类继承父类
 3. 通过虚拟方法，进行进行重载
 4.工厂类，实例化对象，采用多态

 
}
unit uOperation;

interface

uses Classes, inifiles;

type
  {基础类}
  TOperation = class(Tobject)
  private
    FNumberA: Double;
    FNumberB: Double;
  public
    function GetResult: double; virtual; abstract;
    property NumberA: Double read FNumberA write FNumberA;
    property NumberB: Double read FNumberB write FNumberB;
    constructor create;
    destructor Destroy; override;
  end;

  {加法}
  TAdd = class(TOperation)
  public
    function GetResult: double; override;
  end;

  {减法}
  TSub = class(Toperation)
  public
    function GetResult: double; override;
  end;

  {乘法}
  TMultiple = class(TOperation)
  public
    function GetResult: double; override;
  end;

  {除法}
  TDev = class(TOperation)
  public
    function GetResult: Double; override;
  end;

  {工厂类}

  TOperationFactory = class
  private
    FOpMap: TStringHash;
  public

     {可以 GetOperation 定义为类方法，这样就不用创建TOperationFactory 对象，可以直接使用

     TOperationFactory.GetOperation 但是在本例子中，由于要创建 FOpMap，所有不能定义 类方法，根据情况灵活应用，还有

    简单工厂模式，返回值是父类型}
     function GetOperation(Op: string): TOperation;
    constructor create;
    destructor Destroy; override;

  end;

implementation

{ TOperation }

constructor TOperation.create;
begin

end;

destructor TOperation.Destroy;
begin

  inherited;
end;      

{ TAdd }

function TAdd.GetResult: double;
begin
  result := FNumberA + FNumberB;
end;

{ TSub }

function TSub.GetResult: double;
begin
  result := FNumberA - FNumberB;
end;

{ TMultiple }

function TMultiple.GetResult: double;
begin
  Result := FNumberA * FNumberB;
end;

{ TDev }

function TDev.GetResult: Double;
begin
  Result := 0;
  if FNumberB <> 0 then
    Result := FNumberA / FNumberB;

end;

{ TOperationFactory }

constructor TOperationFactory.create;
begin
  FOpMap := TStringHash.Create;
  FOpMap.Add('+', 1);
  FOpMap.Add('-', 2);
  FOpMap.Add('*', 3);
  FOpMap.Add('/', 4);
end;

destructor TOperationFactory.Destroy;
begin
  FOpMap.Free;
  inherited;
end;

function TOperationFactory.GetOperation(Op: string): TOperation;
begin
  result := nil;
  case FOpMap.ValueOf(Op) of
    1: result := TAdd.create;
    2: result := TSub.create;
    3: result := TMultiple.create;
    4: result := TDev.create;
  end;
end;
end.

 

 

 

{使用}

 

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;

type
  TForm1 = class(TForm)
    Button1: TButton;
    Edit1: TEdit;
    Edit2: TEdit;
    Edit3: TEdit;
    Label1: TLabel;
    Label2: TLabel;
    Label3: TLabel;
    Label4: TLabel;
    Edit4: TEdit;
    procedure Button1Click(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
  end;

var
  Form1: TForm1;

implementation

uses uOperation;

{$R *.dfm}

procedure TForm1.Button1Click(Sender: TObject);
var
  op: TOperation;
  OpFact: TOperationFactory;
begin
  OpFact := TOperationFactory.create;

  op := OpFact.GetOperation(Edit4.Text);
  try
    if op = nil then exit;
    op.NumberA := strtointdef(Edit1.Text, -1);
    op.NumberB := strtointdef(Edit2.Text, -1);
    edit3.Text := FloatToStr(op.GetResult);
  finally
    OPFact.Free;
    OP.Free;
  end;
end;

end.

 

 

窗体文件：

 

 

object Form1: TForm1
  Left = 252
  Top = 218
  Width = 419
  Height = 271
  Caption = 'Form1'
  Color = clBtnFace
  Font.Charset = DEFAULT_CHARSET
  Font.Color = clWindowText
  Font.Height = -11
  Font.Name = 'MS Sans Serif'
  Font.Style = []
  OldCreateOrder = False
  PixelsPerInch = 96
  TextHeight = 13
  object Label1: TLabel
    Left = 120
    Top = 56
    Width = 60
    Height = 13
    Caption = '第一个数：'
  end
  object Label2: TLabel
    Left = 120
    Top = 88
    Width = 60
    Height = 13
    Caption = '第二个数：'
  end
  object Label3: TLabel
    Left = 120
    Top = 144
    Width = 36
    Height = 13
    Caption = '结果：'
  end
  object Label4: TLabel
    Left = 120
    Top = 114
    Width = 48
    Height = 13
    Caption = '操作符：'
  end
  object Button1: TButton
    Left = 232
    Top = 176
    Width = 75
    Height = 25
    Caption = '计算'
    TabOrder = 0
    OnClick = Button1Click
  end
  object Edit1: TEdit
    Left = 184
    Top = 56
    Width = 121
    Height = 21
    TabOrder = 1
  end
  object Edit2: TEdit
    Left = 184
    Top = 88
    Width = 121
    Height = 21
    TabOrder = 2
  end
  object Edit3: TEdit
    Left = 184
    Top = 144
    Width = 121
    Height = 21
    TabOrder = 3
  end
  object Edit4: TEdit
    Left = 184
    Top = 114
    Width = 121
    Height = 21
    TabOrder = 4
    Text = '+'
  end
end

 

 

//  C Sharp  实现

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace OpeartionClass
{
    //抽象父类
    public class TOpeartion
    {
        private Double _NumberA = 0;
        private double _NumberB = 0;

        public Double NumberA
        {
            get { return _NumberA; }
            set { _NumberA = value; }

        }
        public Double NumberB
        {
            get { return _NumberB; }
            set { _NumberB = value; }
        }

        public virtual Double GetResult()
        {
            Double result = 0;
            return result;
        }

    }

    // 加法子类
    public class TAdd : TOpeartion
    {
        public override Double GetResult()
        {
            Double result = 0;
            result = NumberA + NumberB;
            return result;
        }
    }

    // 减法子类
    public class TSub : TOpeartion
    {
        public override Double GetResult()
        {
            Double result = 0;
            result = NumberA - NumberB;
            return result;
        }
    }

    // 乘法子类
    public class TMul : TOpeartion
    {
        public override Double GetResult()
        {
            Double result = 0;
            result = NumberA * NumberB;
            return result;
        }

    }

    // 除法子类
    public class TDev : TOpeartion
    {
        public override double GetResult()
        {
            Double result = 0;
            if (NumberB == 0)
                throw new Exception("除数不能为零！");
            result = NumberA / NumberB;
            return result;
        }
    }


    public class TFactoryCreate
    {
        public static TOpeartion GetOperation(string str)
        {
            TOpeartion opr = null;
            switch (str)
            {
                case "+":
                    opr= new TAdd();
                    break;
                case "-":
                    opr= new TSub();
                    break;
                case "*":
                    opr = new TMul();
                    break;
                case "/":
                    opr= new TDev();
                    break;

            }
            return opr;
        }

    }

}

 

// 调用

 

 

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using OpeartionClass;

namespace WindowsFormsApplication1
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            TOpeartion opr;
            opr = TFactoryCreate.GetOperation(textBox3.Text);
            opr.NumberA = Convert.ToInt32(textBox1.Text);
            opr.NumberB = Convert.ToInt32(textBox2.Text);
            textBox4.Text = Convert.ToString(opr.GetResult());


        }
    }
}

 

 

// 窗体文件

 

namespace WindowsFormsApplication1
{
    partial class Form1
    {
        /// <summary>
        /// Required designer variable.
        /// </summary>
        private System.ComponentModel.IContainer components = null;

        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
        protected override void Dispose(bool disposing)
        {
            if (disposing && (components != null))
            {
                components.Dispose();
            }
            base.Dispose(disposing);
        }

        #region Windows Form Designer generated code

        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        {
            this.button1 = new System.Windows.Forms.Button();
            this.textBox1 = new System.Windows.Forms.TextBox();
            this.textBox2 = new System.Windows.Forms.TextBox();
            this.textBox3 = new System.Windows.Forms.TextBox();
            this.textBox4 = new System.Windows.Forms.TextBox();
            this.label1 = new System.Windows.Forms.Label();
            this.label2 = new System.Windows.Forms.Label();
            this.label3 = new System.Windows.Forms.Label();
            this.label4 = new System.Windows.Forms.Label();
            this.SuspendLayout();
            //
            // button1
            //
            this.button1.Location = new System.Drawing.Point(191, 168);
            this.button1.Name = "button1";
            this.button1.Size = new System.Drawing.Size(64, 27);
            this.button1.TabIndex = 0;
            this.button1.Text = "计算";
            this.button1.UseVisualStyleBackColor = true;
            this.button1.Click += new System.EventHandler(this.button1_Click);
            //
            // textBox1
            //
            this.textBox1.Location = new System.Drawing.Point(93, 23);
            this.textBox1.Name = "textBox1";
            this.textBox1.Size = new System.Drawing.Size(120, 21);
            this.textBox1.TabIndex = 1;
            //
            // textBox2
            //
            this.textBox2.Location = new System.Drawing.Point(93, 50);
            this.textBox2.Name = "textBox2";
            this.textBox2.Size = new System.Drawing.Size(120, 21);
            this.textBox2.TabIndex = 2;
            //
            // textBox3
            //
            this.textBox3.Location = new System.Drawing.Point(93, 77);
            this.textBox3.Name = "textBox3";
            this.textBox3.Size = new System.Drawing.Size(120, 21);
            this.textBox3.TabIndex = 3;
            //
            // textBox4
            //
            this.textBox4.Location = new System.Drawing.Point(93, 104);
            this.textBox4.Name = "textBox4";
            this.textBox4.Size = new System.Drawing.Size(120, 21);
            this.textBox4.TabIndex = 4;
            //
            // label1
            //
            this.label1.AutoSize = true;
            this.label1.Location = new System.Drawing.Point(11, 26);
            this.label1.Name = "label1";
            this.label1.Size = new System.Drawing.Size(77, 12);
            this.label1.TabIndex = 5;
            this.label1.Text = "第一个参数：";
            //
            // label2
            //
            this.label2.AutoSize = true;
            this.label2.Location = new System.Drawing.Point(12, 50);
            this.label2.Name = "label2";
            this.label2.Size = new System.Drawing.Size(77, 12);
            this.label2.TabIndex = 6;
            this.label2.Text = "第二个参数：";
            //
            // label3
            //
            this.label3.AutoSize = true;
            this.label3.Location = new System.Drawing.Point(12, 80);
            this.label3.Name = "label3";
            this.label3.Size = new System.Drawing.Size(65, 12);
            this.label3.TabIndex = 7;
            this.label3.Text = "运算符号：";
            //
            // label4
            //
            this.label4.AutoSize = true;
            this.label4.Location = new System.Drawing.Point(11, 113);
            this.label4.Name = "label4";
            this.label4.Size = new System.Drawing.Size(41, 12);
            this.label4.TabIndex = 8;
            this.label4.Text = "结果：";
            //
            // Form1
            //
            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 12F);
            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
            this.ClientSize = new System.Drawing.Size(296, 225);
            this.Controls.Add(this.label4);
            this.Controls.Add(this.label3);
            this.Controls.Add(this.label2);
            this.Controls.Add(this.label1);
            this.Controls.Add(this.textBox4);
            this.Controls.Add(this.textBox3);
            this.Controls.Add(this.textBox2);
            this.Controls.Add(this.textBox1);
            this.Controls.Add(this.button1);
            this.Name = "Form1";
            this.Text = "Form1";
            this.ResumeLayout(false);
            this.PerformLayout();

        }

        #endregion

        private System.Windows.Forms.Button button1;
        private System.Windows.Forms.TextBox textBox1;
        private System.Windows.Forms.TextBox textBox2;
        private System.Windows.Forms.TextBox textBox3;
        private System.Windows.Forms.TextBox textBox4;
        private System.Windows.Forms.Label label1;
        private System.Windows.Forms.Label label2;
        private System.Windows.Forms.Label label3;
        private System.Windows.Forms.Label label4;
    }
}

 

 

// JAVA 实现

 

//实现抽象类

 

package OperationFactory;

public abstract class Operation {
   private double NumberA;
   private double NumberB;
  
   public double GetNumberA()
   {
     return NumberA; 
   }
  
   public void SetNumberA(double numbera)
   {
       this.NumberA=numbera;
   }
  
   public double GetNumberB()
   {
       return NumberB;
   }
  
   public void SetNumberB(double numberb)
   {
       this.NumberB=numberb;
   }
  
   public abstract double getresult()throws Exception;
}

 

 

 

//实现子类  加法 OPerationAdd

package OperationFactory;

public class OperationAdd extends Operation {
    @Override
    public double getresult()throws Exception {
        double result = 0;
        result = GetNumberA() + GetNumberB();
        return result;
    }
}

 

//实现子类 除法 OperationDev

 

package OperationFactory;

public class OperationDev extends Operation {

    @Override
    public double getresult() throws Exception {
        double result=0;
        if (GetNumberB()==0)
            throw new Exception("除数不能为0");
        result=GetNumberA()/GetNumberB();
        return result;
    }
}

 

 

//实现子类 乘法 OPerationMul

 

package OperationFactory;

public class OperationMul extends Operation {

    @Override
    public double getresult() throws Exception {
        // TODO Auto-generated method stub
        double result=0;
        result=GetNumberA() * GetNumberB();
        return result;
    }

}

 

 

//实现子类 减法 OperationSub

 

 

package OperationFactory;

public class OperationSub extends Operation {
    @Override
    public double getresult() throws Exception {
        double result = 0;
        result = GetNumberA() - GetNumberB();
        return result;
    }

}

 

 

// 工厂类 OperateFactory

 

 

 

package OperationFactory;

public class OperateFactory {
  public static Operation CreateFactory(String sOperat){
   Operation opr=null;
   if ("+".equalsIgnoreCase(sOperat))
   {
    opr=new OperationAdd(); 
   }else if ("-".equalsIgnoreCase(sOperat))
   {
    opr=new OperationSub();  
   }else if ("*".equalsIgnoreCase(sOperat))
   {
     opr=new OperationMul(); 
   }else if ("/".equalsIgnoreCase(sOperat))
   {
     opr=new OperationDev(); 
   }
  
   return opr;
  }
}

 

 

 

总结： 上面我用三种语言- Delphi 、C Sharp、 JAVA  实现了简单工厂设计模式。它们都是面向对象语言特性，都可以实现其模式设计。这样做的目的是一种尝试，对于初学者来，可以洞悉其中的异同，对于同时需要掌握多门开发语言的人来说，可以做一个比较，印象会更深刻。

{http://blog.csdn.net/tjb_1216/article/details/5619146}

苍穹帝
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
delphi实现简单工厂
07-19
delphi 实现简单工厂模式
Delphi之Factory Method(工厂模式)
醒不来的专栏
03-21 1173
工厂方法(Factory Method)模式，又称虚构造子(Virtual Constructor)模式或多态工厂模式。工厂模式定义创建对象的借口，并由派生类决定哪一个类来创建对象。也就是说，工厂方法将创建对象的责任委托给派生类。这是因为基类并不知道要创建的对象是哪一个类的实例，所以将创建对象的责任委托给派生类，或者将实际创建工作延迟到派生类中完成。 TCPU = class(TObj
Delphi 工厂模式
小印丶的笔记
11-09 447
RAD Studio 10.2.3 测试√ 运行结果： 使用方法： procedure TDesignPattern.Button_FactoryPatternClick(Sender: TObject); var mBigBoss: TBigBoss; mFactory: IFactoryMgr; begin mBigBoss := TBigBoss.Create; mFactory := mBigBoss.GetFactory('小米手机'); mFactory.Make;
《大话设计模式》之 简单工厂模式 Delphi/C shap /JAVA 实现
tjb_1216的专栏
05-24 2180
{计算器的功能实现 实现工厂设计模式 通过面向对象的思想，进行设计，所用的编程思想为对象的三大特性：封装，继承，多态 通过实现一个简单的 计算器的功能（输入两个数，进行加，减，乘，除） 思想思路： 1.设计虚拟父类; 2.子类继承父类 3. 通过虚拟方法，进行进行重载 4.工厂类，实例化对象，采用多态 }unit uOperation;i
三层架构+工厂模式（经典案例）带图，带说明
11-08
三层架构+工厂模式（经典案例）带图，带说明 非常适合框架设计者，非常经典，里面关于每一层就详细的说明。
学生宿舍-学生宿舍系统-学生宿舍系统源码-学生宿舍管理系统-基于Web的学生宿舍系统设计与实现-学生宿舍系统设计与实现-java
02-05
shap学生宿舍-学生宿舍系统-学生宿舍系统源码-学生宿舍管理系统-学生宿舍管理系统java代码-学生宿舍系统设计与实现-基于springboot的学生宿舍系统-基于Web的学生宿舍系统设计与实现-学生宿舍网站-学生宿舍网站代码-...
shap面拓扑处理工具箱
08-08
shap面拓扑处理工具箱，全面处理arcgis重叠面，重叠处理，完美解决重叠面域。GIS技术中，可将拓扑理解为一种描述地理空间关系的模型，一种维护地理空间实体间空间几何关系的机制。而拓扑关系是指地理空间实体间的一...
基于微反射镜阵列的光刻照明模式变换系统设计
02-23
光源掩膜协同优化是45 nm节点以下浸没式光刻提高分辨率的重要途径之一，为了重构其优化后输出的像素级光源，提出了一种基于可寻址二维微反射镜阵列的新型照明模式变换系统设计方法。分析了减少重构光源所需微反射镜...
基于FPGA的并行处理实现数字中频的设计
01-19
　如图1所示，中频部分用数字方式来实现就称之为数字中频。数字中频技术通常包括上下变频（DUC/DDC）、波峰因子衰减（CFR）和数字预失真（DPD）。　DUC/DDC　DUC实现了从“复”基带（Baseband）信号到“实”带通...
Shape-E 教程：如何设置和使用 Shap-E 模型
05-29
Shap-E的多功能性也是其与众不同之处，用户可以将生成的3D对象在Microsoft Paint 3D等软件中打开，甚至可以转换成STL文件进行3D打印。这项技术正在重新定义我们处理文本到3D和图像到3D生成的方式，以及人工智能应用...
观察者模式delphi代码
09-26
观察者模式最好的诠释 模式编程中的观察者模式delphi代码
delphi 简单工厂模式
06-20
type TIProduct = class str:string; function Print():string;virtual; end; type TProduct_A = class(TIProduct) private public function Print():string;override; end; type TProduct_B = class(TIProduct) private public function Print():string;override; end; type TSimpleFactory = class private public function CreateProduct(A:string):TIProduct; end;
delphi设计模式 多语言开发
weixin_33910137的博客
05-31 188
系统支持简体、繁体、英文三种语言，开发语言Delphitype //接口定义 ILanguageTrans = interface ['{EE1BAE27-2E88-4F76-8AF3-169B6C7BF7C1}'] procedure ReadForm; //把界面所有控件翻译 procedure WriteForm;//把界面所有控件写入 function Get...
Delphi中的工厂模式
Chris Mao的专栏
11-16 276
在面向对象的程序设计中，某一功能的实现往往是依赖多个类的协同工作，这当中不必可避免的会有一个核心的关键类，非关键类对关键类的依赖程度比较高（耦合比较紧），关键类的变动会景响到非关键类与其通信。比如在某个MIS系统中，用户数据是存储在文件中的，那么所有数据的读取与保存都依赖与那和与文件进行通信的类。突然某一天客户说要将数据存储到数据库中，那么我们是必要找出所有使用这些与文件通信的类的代码，并使用新...
delphi简单工厂模式
gang148375的博客
01-05 267
关于设计模式，网上有大量类似的文章。不过大多数都是Java、Python之类的语言，我参考了Java的设计模式源码， 给出了对应Delphi的设计模式Demo，仅供参考。（设计模式本身是与编程语言无关）以下是Demo源码。 参考资料来自于书籍：大话设计模式 { 这是一个工厂模式的简单应用，实现2个数之间的加减乘除运算 当需要增加一个新的运算类型时，只需要增加一个新的运算类，并且在 工厂类的创造实例方法CreateOpera 增加这个新的运算类 } unit uCalcu...
delphi 实现简单工厂模式
easyboot的专栏
03-21 1023
计算器的功能实现 实现工厂设计模式 通过面向对象的思想，进行设计，所用的编程思想为对象的三大特性：封装，继承，多态 通过实现一个简单的 计算器的功能（输入两个数，进行加，减，乘，除） 思想思路： 1.设计虚拟父类; 2.子类继承父类 3. 通过虚拟方法，进行进行重载 4.工厂类，实例化对象，采用多态 } unit uOperation; interface uses Classes, i
Delphi XE10.x下的工厂模式
sonadorje的专栏
07-30 184
意图 提供用于创建相关或依赖对象系列的接口，而无需指定它们的具体类。 解释 真实世界的例子 要创建一个王国，我们需要具有共同主题的对象。精灵王国需要精灵国王、精灵城堡和精灵军队，而兽人王国需要兽人国王、兽人城堡和兽人军队。王国中的对象之间存在依赖关系。 简单来说 一个创建工厂的工厂；将单个但相关/依赖的工厂组合在一起而不指定它们的具体类的工厂。 维基百科说 抽象工厂模式提供了一种封装一组具有共同主题的独立工厂的方法，而无需指定它们的具体类 程序示例 翻译上面的王国例子。首先.
Delphi 设计模式：《HeadFirst设计模式》Delphi7代码---工厂模式之简单工厂[转]
weixin_30786617的博客
11-05 111
简单工厂：工厂依据传进的参数创建相应的产品。 12{《HeadFirst设计模式》工厂模式之简单工厂}3{产品类}4{编译工具：Delphi7.0}5{联系方式：[email protected]}67unituProducts;...
设计模式- 建造者模式（Builder Pattern）结构|原理|优缺点|场景|示例
最新发布
piaomiao_的博客
04-19 1026
建造者模式（Builder Pattern）是一种创建型设计模式，其主要目的是将复杂对象的构建过程与它的表示分离，使得相同的构建过程可以创建不同的表示。这种模式适用于创建包含多个可选部件、步骤复杂且可能需要逐步构建的复杂对象，它能将构建过程分解为多个独立的、可复用的步骤，使得对象的创建过程更加清晰、灵活且易于扩展。
Python实现SHAP
07-27
Python中可以使用SHAP（SHapley Additive exPlanations）库来实现SHAP值的计算和解释。SHAP是一种用于解释机器学习模型预测输出的方法，它基于Shapley值的概念，可以帮助我们了解每个特征对于模型预测结果的贡献程度...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值