球球的第四篇博客之——工厂模式

最新推荐文章于 2024-10-17 09:45:23 发布
最新推荐文章于 2024-10-17 09:45:23 发布
阅读量160 收藏
点赞数 1
分类专栏： 设计模式 文章标签： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46409937/article/details/105282320
版权

工厂模式专门负责将大量有共同接口的类实例化。工厂模式可以动态决定将哪个类实例化，不必事先知道每次要实例化哪个类。有简单工厂模式、工厂方法模式、抽象工厂模式三种形态。

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

解决的问题：

  • 将“类实例化的操作”与“使用对象的操作”分开，让使用者（客户端）不用知道具体参数就可以实例化出所需要的“产品”类，从而避免了在客户端代码中显示指定，实现了解耦。
  • 即使用者可直接消费产品而不需要知道其生产的细节。

问题的引入——计算器程序：

实现一个计算器控制台程序，要求输入两个数和运算符号，得到结果

package sjms;
import java.util.*;
public class Main{
	public static void main(String[] args){
		Scanner sc=new Scanner(System.in);
		System.out.println("请输入数字A：");
		String A=sc.nextLine();
		System.out.println("请选择运算符号（+、-、*、/）：");
		String B=sc.nextLine();
		System.out.println("请输入数字B：");
		String C=sc.nextLine();
		String D="";
	if("+".equals(B)){
		D=(Double.parseDouble(A)+Double.parseDouble(C))+"";}
	if("-".equals(B)){
		D=(Double.parseDouble(A)-Double.parseDouble(C))+"";}
	if("*".equals(B)){
		D=(Double.parseDouble(A)*Double.parseDouble(C))+"";}
	if("/".equals(B)){
		D=(Double.parseDouble(A)/Double.parseDouble(C))+"";}
	System.out.println("结果是："+D);
	}
}

分析：

  • A、B、C、D变量名称不规范
  • 没有判断除0的条件，没有考虑到用户输入出错的情况
  • 判断分支每次都要做三次无用的判断

改正以上3点后：

package sjms;
import java.util.*;
public class Main{
	public static void main(String[] args){
		Scanner sc=new Scanner(System.in);
		System.out.println("请输入数字A：");
		String strNumberA=sc.nextLine();
		System.out.println("请选择运算符号（+、-、*、/）：");
		String strOperator=sc.nextLine();
		System.out.println("请输入数字B：");
		String strNumberB=sc.nextLine();
		String strResult="";
	switch(strOperator.charAt(0)){
	case '+':strResult=(Double.parseDouble(strNumberA)+Double.parseDouble(strNumberB))+"";break;
	case '-':strResult=(Double.parseDouble(strNumberA)-Double.parseDouble(strNumberB))+"";break;
	case '*':strResult=(Double.parseDouble(strNumberA)*Double.parseDouble(strNumberB))+"";break;
	case '/':if(!"0".equals(strNumberB))
			strResult=(Double.parseDouble(strNumberA)/Double.parseDouble(strNumberB))+"";
	else strResult="除数不能为0";
	break;
	default:strResult="输入有错";
	}
	System.out.println("结果是："+strResult);
	}
}

分析：
上述编码过于结构化 （面向过程），程序只为满足实现当前的需求，未能体现面向对象（活字印刷，面向对象）的思想。达不到高质量代码的要求。

  • 不易维护——只需改要改的地方：可维护性
  • 不易扩展——若要增加内容直接加就行了：可扩展性
  • 不易复用——可在后来重复使用：可复用性
  • 灵活性差

修改后：

package sjms;
import java.util.*;
public class Main{
	public static void main(String[] args){
		Scanner sc=new Scanner(System.in);
		System.out.println("请输入数字A：");
		double A=sc.nextDouble();sc.nextLine();
		System.out.println("请选择运算符号（+、-、*、/）：");
		char op=sc.nextLine().charAt(0);
		System.out.println("请输入数字B：");
		double B=sc.nextDouble();
		Operation oper=new Operation();
		double D=oper.GetResult(A,B,op);
		if(oper.flag)System.out.println("结果是："+A+op+B+'='+D);
		else System.out.println("除数不能为0");
	}
}
class Operation{
	boolean flag;double result;
	double GetResult(double numberA,double numberB,char operate){
		result=0;flag=true;
		switch(operate)
		{
		case '+': result=numberA+numberB; break;
		case '-': result=numberA-numberB; break;
		case '*': result=numberA*numberB; break;
		case '/': if(Math.abs(numberB-0.0)>=1e-6)//与0非常接近
			 result=numberA/numberB;
		else{flag=false;return 0;}
		break;
	}
		return result;
	}
}

分析：

  • 若希望上述程序增加一个开根（sqrt）运算，则需要改Operation类，在switch中加一个分支，需要让加减乘除的运算都得来参与编译，如果不小心把加法运算改成了减法。。那就上头了
  • 类内耦合过紧，不利于维护
    修改后：（继承思想的编程）
package sjms;
import java.util.*;
public class Main{
	public static void main(String[] args){
		Scanner sc=new Scanner(System.in);
		System.out.println("请输入数字A：");
		String strNumberA=sc.nextLine();
		System.out.println("请选择运算符号（+、-、*、/）：");
		String strOperator=sc.nextLine();
		System.out.println("请输入数字B：");
		String strNumberB=sc.nextLine();
		Operation add=new OperationAdd();
		add.setNumberA(Double.parseDouble(strNumberA));
		add.setNumberB(Double.parseDouble(strNumberB));
		System.out.println("结果是："+add.getResult());
	}

	private static Operation Operation(char charAt) {
		// TODO Auto-generated method stub
		return null;
	}
}
abstract class Operation{
	//两个Number属性，主要用于计算器的前后数
	private double numberA=0;
	private double numberB=0;
	boolean flag=true;
	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;
	}
	//虚方法GetResult()，用于得到结果
	public abstract double getResult();
}
/** *加减乘除类--加法类，继承运算类* **/
class OperationAdd extends Operation{
	@Override
	public double getResult(){
		double result=0;
		return getNumberA()+getNumberB();
	}
}
/** * 加减乘除类--减法类，继承运算类* **/
class OperationSub extends Operation{
	@Override
	public double getResult(){
		double result=0;
		return getNumberA()-getNumberB();
	}
}
/** * 加减乘除类--乘法类，继承运算类* **/
class OperationMul extends Operation{
	@Override
	public double getResult(){
		double result=0;
		return getNumberA()*getNumberB();
    }
}
/** * 加减乘除类--除法类，继承运算类* **/
class OperationDiv extends Operation{
	@Override
	public double getResult(){
		double result=0;
		return getNumberA()/getNumberB();
	}
}

分析：

  • 不灵活
  • 暴露了多个类，不安全

简单工厂模式基本介绍：
1)简单工厂模式是属于创建型模式，是工厂模式的一种。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式。
2)简单工厂模式:定义了一个创建对象的类，由这个类来封装实例化对象的行为(代码)。
3)在软件开发中，当我们会用到大量的创建某种、某类或者某批对象时，就会使用到工厂模式。
Simple Factory模式根据提供给它的数据，返回几个可能类中的一个类的实例。通常它返回的类都有一个公共的父类和公共的方法。

在这里插入图片描述

  • 工厂类角色Creator:工厂类在客户端的直接控制下( Create方法)创建产品对象。
  • 抽象产品角色Product:定义简单工厂创建的对象的父类或它们共同拥有的接口。可以是一个类、抽象类或接口。
  • 具体产品角色ConcreteProduct:定义工厂具体加工出的对象。
package sjms;
import java.util.*;

/*客户端程序*/
public class Main{
	public static void main(String[] args) {
		Scanner scanner=new Scanner(System.in);
		System.out.println("请输入数字A：");
		String strNumberA=scanner.nextLine();
		System.out.println("请选择运算符号（+、-、*、/、^）：");
		String strOperator=scanner.nextLine();
		System.out.println("请输入数字B：");
		String strNumberB=scanner.nextLine();
		Operation oper;
		oper=OperationFactory.createOperation(strOperator.charAt(0));
		oper.setNumberA(Double.parseDouble(strNumberA));
		oper.setNumberB(Double.parseDouble(strNumberB));
		System.out.println("结果是："+oper.getResult());
	}
	
}
abstract class Operation{
	private double numberA=0;
	private double numberB=0;
	boolean flag=true;
	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();
}
class OperationAdd extends Operation{

	@Override
	public double getResult() {
		// TODO Auto-generated method stub
		double result=0;
		return getNumberA()+getNumberB();
	}
	
}
class OperationSub extends Operation{

	@Override
	public double getResult() {
		// TODO Auto-generated method stub
		double result=0;
		return getNumberA()-getNumberB();
	}
	
}
class OperationMul extends Operation{

	@Override
	public double getResult() {
		// TODO Auto-generated method stub
		double result=0;
		return getNumberA()*getNumberB();
	}
	
}
class OperationDiv extends Operation{

	@Override
	public double getResult() {
		// TODO Auto-generated method stub
		double result=0;
		return getNumberA()/getNumberB();
	}
	
}
/*增加阶乘运算*/
class OperationFunc extends Operation{

	@Override
	public double getResult() {
		// TODO Auto-generated method stub
		double r=1;
		int a=(int) getNumberA();
		for(int i=1;i<=a;i++)
			r=r*i;
		return r;
	}
	
}

/*简单运算工厂类*/
class OperationFactory{
	public static Operation createOperation(char operate) {
		Operation oper=null;
		switch(operate)
		{
		case'+':oper=new OperationAdd();break;
		case'-':oper=new OperationSub();break;
		case'*':oper=new OperationMul();break;
		case'/':oper=new OperationDiv();break;
		/*增加阶乘运算*/
		case'^':oper=new OperationFunc();break;
		}/*对修改开放，违背了开放-封闭原则*/
		return oper;
		
	}
}

优点：
工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关类，对于客户来说，去除了与具体产品的依赖。简单工厂类含有必要的判断逻辑，可以决定在什么时候创建哪一个产品类的实例，客户端可以免除直接创建产品对象的责任，而仅仅"消费"产品。简单工厂模式通过这种做法实现了对责任的分割。

缺点：
●当产品有复杂的多层等级结构时，简单工厂类只有自己，以不变应万变，就是简单工厂模式的缺点。对工厂类过于依赖。因为简单工厂类集中了所有产品创建逻辑，一旦不能正常工作，整个系统都要受到影响。
●同时，在某种程度上违背了开放-封闭原则，系统扩展困难，一旦添加新产品就不得不修改工厂逻辑，有可能造成工厂逻辑过于复杂。
●另外，简单工厂模式通常使用静态工厂方法, 这使得无法由子类继承，造成简单工厂角色无法形成基于继承的等级结构。

工厂方法模式(Factory Method)

  • 既然简单工厂模式中的工厂类与分支耦合，那么根据依赖倒转原则，把工厂类抽象出一个接口，这个接口有一个创建抽象产品的工厂方法。所有的要生产具体类的工厂，就去实现这个接口，这样，一个简单工厂模式的工厂类，变成一个工厂抽象接口和多个具体生成对象的工厂。
  • 要增加‘求M数的N次方’ 的功能时，不需要更改原有的工厂类，只需要增加比功能的运算类和相应的工厂类。
  • 这样整个工厂和产品体系都没有修改的变化，而只是扩展的变化，这就完全符合了开放-封闭原则。
  • 工厂方法模式( Factory Method)，定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

工厂方法模式结构图：
在这里插入图片描述
抽象工厂角色： 是工厂方法模式的核心，与应用程序无关。任何在模式中创建的对象的工厂类必须实现这个接口。（OperationFactory）
具体工厂角色： 这是实现抽象工厂接口的具体工厂类，包含与应用程序密切相关的逻辑，并且受到应用程序调用以创建产品对象。（OperationAddFactory、OperationMulFactory、OperationSubFactory）
抽象产品角色： 工厂方法模式所创建的对象的超类型，也就是产品对象的共同父类或共同拥有的接口。（Operation）
具体产品角色: 这个角色实现了抽象产品角色所定义的接口。某具体产品有专门的具体工厂创建，它们之间往往一 一对应。（OperationAdd、OperationSub、OperationMul）

package sjms;
import java.util.*;

abstract class Operation{
	private double numberA=0;
	private double numberB=0;
	boolean flag=true;
	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();
}
class OperationAdd extends Operation{

	@Override
	public double getResult() {
		// TODO Auto-generated method stub
		double result=0;
		return getNumberA()+getNumberB();
	}
	
}
class OperationSub extends Operation{

	@Override
	public double getResult() {
		// TODO Auto-generated method stub
		double result=0;
		return getNumberA()-getNumberB();
	}
	
}
class OperationMul extends Operation{

	@Override
	public double getResult() {
		// TODO Auto-generated method stub
		double result=0;
		return getNumberA()*getNumberB();
	}
	
}
class OperationDiv extends Operation{

	@Override
	public double getResult() {
		// TODO Auto-generated method stub
		double result=0;
		return getNumberA()/getNumberB();
	}
	
}
/*增加求m的n次方*/
/*class OperationMN extends Operation{

	@Override
	public double getResult() {
		// TODO Auto-generated method stub
		double r=1;
		double m=getNumberA();
		int n=(int) getNumberB();
		for(int i=1;i<=n;i++)
			r=r*m;
		return r;
	}
	
}*/
interface IFactory{
	Operation createOperation();
}
class AddFactory implements IFactory{
	public Operation createOperation() {
		return new OperationAdd();
	}
}
class SubFactory implements IFactory{
	public Operation createOperation() {
		return new OperationSub();
	}
}
class MulFactory implements IFactory{
	public Operation createOperation() {
		return new OperationMul();
	}
}
class DivFactory implements IFactory{
	public Operation createOperation() {
		return new OperationDiv();
	}
}

/*简单运算工厂类*/
class OperationFactory{
	public static Operation createOperation(char operate) {
		Operation oper=null;
		switch(operate)
		{
		case'+':oper=new OperationAdd();break;
		case'-':oper=new OperationSub();break;
		case'*':oper=new OperationMul();break;
		case'/':oper=new OperationDiv();break;
		/*增加m的n次方*/
		/*case'^':oper=new OperationMN();break;*/
		}
		return oper;
		
	}
}
public class Main{
	public static void main(String[] args) {
		Scanner scanner=new Scanner(System.in);
		System.out.println("请输入数字A：");
		String strNumberA=scanner.nextLine();
		System.out.println("请选择运算符号（+、-、*、/）：");
		String strOperator=scanner.nextLine();
		System.out.println("请输入数字B：");
		String strNumberB=scanner.nextLine();
		IFactory operFactory=null;
		switch(strOperator.charAt(0))
		{
		case'+':operFactory=new AddFactory();break;
		case'-':operFactory=new SubFactory();break;
		case'*':operFactory=new MulFactory();break;
		case'/':operFactory=new DivFactory();break;
		}
		Operation oper=operFactory.createOperation();
		oper.setNumberA(Double.parseDouble(strNumberA));
		oper.setNumberB(Double.parseDouble(strNumberB));
		try {
			double result=oper.getResult();
			System.out.println("结果是："+result);
		}catch(Exception e) {
			e.printStackTrace();
		}
	}
	
}
滕大球球
关注
专栏目录
【基于AnyLogic的管理仿真系统】
Algernon98的博客
08-24 3638
HNU小学期课程，利用anylogic进行仿真模型
秋招面试！最全Java面试宝典！共计1700页的Java岗面试核心MCA版，手慢无！
weixin_66896902的博客
09-19 260
先看看《Java岗面试核心MCA版》的大概内容：Java基础、JVM、多线程、MySQL、Spring、SpringBoot、SpringCloud、Dubbo、Mybatis、Redis、网络、Linux、MQ、Zookeeper、Netty、大数据、算法与数据结构、设计模式、项目实战、简历模板等等。由于MCA版的细节内容实在是太多了，毕竟将近2000页的文档，只能把部分知识点里面的章节挑出来介绍一下，每个章节的小节点里面都有更详细的内容！SpringCloud部分。SpringBoot部分。
【Java】图形及事件驱动程序设计——弹球游戏
m0_72526865的博客
05-14 945
利用Javafx界面设计一个弹球游戏，包括重玩和下一关的按键，并且显示游戏时间和得分。
构造函数补充和设计模式
qq_38256266的博客
07-14 319
构造函数补充和设计模式一、构造函数补充二、设计模式2.1、概念2.2、设计模式的分类2.3、单例模式 一、构造函数补充 我们知道，ES6创建类是使用关键字class // ES6创建类 class Bull{ constructor(weight,color){ this.weight = weight; this.color = color; this.descri(); } descri(){ console.log
设计模式创建型——抽象工厂模式
tszc95的博客
04-06 8660
抽象工厂模式（Abstract Factory Pattern）隶属于设计模式中的创建型模式，用于产品族的构建。抽象工厂是所有形态的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂是指当有多个抽象角色时使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体情况下，创建多个产品族中的产品对象。
第一篇 设计模式引论 - 探索软件设计的智慧结晶
球球不吃虾WHR2349博客
12-29 692
设计模式，这个术语最初在建筑领域被广泛使用，用来描述在建筑设计中反复出现的问题及其解决方案。在软件工程中，设计模式同样指的是在软件设计过程中反复出现的、经过验证的最佳实践和解决方案。1994年，由Erich Gamma、Richard Helm、Ralph Johnson和John Vlissides四位作者（被称为"四人组"或GoF）合作出版了《设计模式：可复用面向对象软件的基础》一书，这是设计模式在软件工程领域正式确立的里程碑。
APP——List
热门推荐
Cincinnati_De的博客
03-13 3万+
['王者荣耀', 'QQ', '作业帮-学习辅导', '绝地求生：刺激战场', '爱奇艺', '快手', '腾讯视频', '微信', '抖音短视频', '全民K歌', '手机淘宝', '迷你世界', 'QQ音乐', '优酷', 'WiFi万能钥匙', '酷狗音乐', '荒野行动', '互动作业', '穿越火线：荒岛特训-60V60', 'QQ飞车手游', '拼多多', '绝地求生 全军出击', '...
设计模式
codertl
07-25 440
1、设计模式 1.1 设计模式的目的 编写软件过程中，程序员面临着来自 耦合性，内聚性，内聚性以及可维护性，可扩展性，重用性，灵活性 等多方面的挑战，设计模式是为了让 程序（软件），具有更好 代码重用性（即：相同功能的代码，不用多次编写） 可读性（即：编程规范性，便于其他程序员的阅读和理解） 可扩展性（即：当需要增加新的功能时，非常的方便，称为可维护） 可靠性（即：当我们增加新的功能...
题解 | #第二快/慢用时之差大于试卷时长一半的试卷#
每天多一点干货
07-17 352
我本来就在深圳，跟朋友优才获批后来香港的，目前在IT行业，月收比之前翻了两三倍，朝九晚六不算太卷的。#职场捅娄子大赛#先说一个我捅过的娄子：我刚工作的时候，策划一个活动，当时我简直像个脑子被丧尸吃了的。#机械制造投递记录# 米子啊，刚还夸我笔试好，嘱咐我二面要怎么怎么样，出来就把我秒挂，闹哪样....我是今年2023才读的在职硕士，一年制的在职研究生项目，费用8000元美金，如果努力一点，8个月就能。#实习，投递多份简历没人回复怎么办# #实习，投递多份简历没人回复怎么办# 现在正在用友公司摸鱼，回。
学习笔记——资料
03-26
- **常见设计模式**：单例、工厂、装饰器、代理、观察者等23种设计模式的原理和应用实例。 10. **Java进阶** - **反射机制**：允许在运行时动态获取类的信息并调用方法。 - **注解（Annotation）**：为代码添加...
Java面试：将近1700页的《Java面试核心知识点》，拿走不谢！！
weixin_66896902的博客
08-28 766
不得不说程序员除了做项目之外，提升自己技能最快的方式就是【看书！】和【刷题！】，这里说的刷题不是无脑刷，而是要明白面试官为什么会问这个问题，以及这个问题的意义在哪里！
计算机类毕业设计论文范文下载参考
biyelunwenfanwen的博客
10-29 8232
包含毕业设计全套文档，Word版本的
速读“消息中间件”架构体系-ActiveMQ：入门+原理分析+优缺点！
weixin_66896902的博客
09-14 884
Java 消息服务（Java Message Service）是 java 平台中关于面向消息中间件的 API，用于在两个应用程序之间，或者分布式系统中发送消息，进行异步通信。JMS 是一个与具体平台无关的 API ，绝大多数 MOM（Message Oriented Middleware）（面向消息中间件）提供商都对 JMS 提供了支持。例如ActiveMQ就是其中一个实现。MOM 是面向消息的中间件，使用消息传送提供者来协调消息传送操作。MOM 需要提供 API 和管理工具。
设计模式02-桥接模式(Java)
XYX_888的博客
10-13 580
它是用组合关系代替继承关系来实现，从而降低了抽象和实现这两个可变维度的耦合度。在使用关联关系是，及在抽象类引入实现类接口时可能会出现不适配的情况，这是可以用适配器类型将其转换成抽象类可以适配的类进行关联。扩展抽象化角色 ：是抽象化角色的子类，实现父类中的业务方法， 并通过组合关系调用实现化角色中的业务方法。实现化角色 ：定义实现化角色的接口，供扩展抽象化角色调用。抽象化角色 ：定义抽象类，并包含一个对实现化对象的引用。具体实现化角色 ：给出实现化角色接口的具体实现。实现了对抽象和实现之间的解耦。
Java设计模式梳理：行为型模式（策略，观察者等）
最新发布
helloworld工程师的博客
10-17 1039
行为型模式部分介绍了策略模式、观察者模式、责任链模式、模板方法模式和状态模式，其实，经典的行为型模式还包括备忘录模式、命令模式等，但是它们的使用场景比较有限，而且本文篇幅也挺大了，我就不进行介绍了。学习设计模式的目的是为了让我们的代码更加的优雅、易维护、易扩展。这次整理这篇文章，让我重新审视了一下各个设计模式，对我自己而言收获还是挺大的。我想，文章的最大收益者一般都是作者本人，为了写一篇文章，需要巩固自己的知识，需要寻找各种资料，而且，自己写过的才最容易记住，也算是我给读者的建议吧。（全文完）
Java设计模式
juanmiao的专栏
10-12 724
确保一个类只有一个实例，并提供一个全局访问点。
第九章 UML建模和设计模式
nihao_miai的博客
10-11 844
主要考察面向对象基础知识、面向对象分析与设计、设计模式。
适配器设计模式：基础解析与应用实例
weixin_52937170的博客
10-12 510
适配器设计模式的基础实现案例
php常用设计模式之单例模式
qq_38917476的博客
10-14 1068
如果实例的初始化开销大，且不一定每次都使用，选择懒汉式，延迟加载可以节省资源。如果应用对响应速度有要求，且希望在系统启动时就获得实例，则选择饿汉式，它提供了线程安全的同时，也减少了同步处理的开销。接下来，我将通过单例模式分别实现 MySQL、Redis、MongoDB 和 Elasticsearch 的连接管理，展示如何在这些场景中应用单例模式。通过单例模式，我们能够高效地管理 MySQL、Redis、MongoDB 和 Elasticsearch 等资源的连接，实现了资源的合理分配与复用。
Django球球大作战项目源码及使用说明
资源摘要信息:"该资源为基于Django和Python开发的球球大作战小游戏的完整源码及项目说明。游戏采用Web开发框架Django，结合Python编程语言，并利用多种技术组件确保运行环境的兼容性和稳定性。该小游戏支持Ubuntu...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值