第 6 章 工厂模式
第 6 章 工厂模式
1、简单工厂模式
简单工厂模式的实际需求
看一个披萨的项目:要便于披萨种类的扩展,要便于维护
- 披萨的种类很多(比如 GreekPizz、CheesePizz 等)
- 披萨的制作有 prepare、bake、cut、box
- 完成披萨店订购功能
传统方式的代码实现
类图设计
代码实现
Pizza
抽象父类//将Pizza 类做成抽象 public abstract class Pizza {protected String name; //名字public void setName(String name) {this.name = 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;");}}
CheesePizza
:奶酪披萨public class CheesePizza extends Pizza {@Overridepublic void prepare() {System.out.println("给制作奶酪披萨 准备原材料 ");} }
GreekPizza
:希腊披萨public class GreekPizza extends Pizza {@Overridepublic void prepare() {System.out.println("给希腊披萨 准备原材料 ");} }
PepperPizza
:胡椒披萨public class PepperPizza extends Pizza {@Overridepublic void prepare() {System.out.println("给胡椒披萨准备原材料 ");} }
OrderPizza
:表示披萨商店,可以根据用户的输入,制作相应的披萨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("cheese")) {pizza = new CheesePizza();pizza.setName("奶酪披萨");} else if (orderType.equals("pepper")) {pizza = new PepperPizza();pizza.setName("胡椒披萨");} else {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
:相当于客户端,发出订购披萨的请求//相当于一个客户端,发出订购 public class PizzaStore {public static void main(String[] args) {new OrderPizza();}}
程序运行结果
input pizza 种类: greek 给希腊披萨 准备原材料 希腊披萨 baking; 希腊披萨 cutting; 希腊披萨 boxing;input pizza 种类: pepper 给胡椒披萨准备原材料 胡椒披萨 baking; 胡椒披萨 cutting; 胡椒披萨 boxing;input pizza 种类:
传统方式的优缺点分析
- 优点是比较好理解,简单易操作。
- 缺点是违反了设计模式的
ocp
原则,即对扩展开放(提供方),对修改关闭(使用方)。即当我们给类增加新功能的时候,尽量不修改代码,或者尽可能少修改代码. - 比如我们这时要新增加一个
Pizza
的种类(Pepper
披萨),我们需要在使用方OderPizza
中添加新的判断条件,违反开闭原则
改进思路
- 分析: 如果说新增
Pizza
需要修改代码,这可以接受, 但是如果我们在其它的地方也有创建Pizza
的代码,就意味着,有很多处的代码都需要修改,而且这些创建Pizza
的代码全都是冗余代码。 - 思路: 把创建
Pizza
对象封装到一个类中,这样我们有新的Pizza
种类时,只需要修改该类就可, 其它有创建到Pizza
对象的代码就不需要修改了 --> 简单工厂模式
简单工厂模式的代码实现
简单工厂模式介绍
- 简单工厂模式是属于创建型模式,是工厂模式的一种。 简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式
- 简单工厂模式:定义了一个创建对象的类,由这个类来封装实例化对象的行为(代码)
- 在软件开发中,当我们会用到大量的创建某种、某类或者某批对象时,就会使用到工厂模式
类图
代码实现
Pizza
抽象父类以及Pizza
的具体实现类和上面一样SimpleFactory
:工厂类,根据用户输入,制作相应的Pizza
,此时SimpleFactory
为提供方//简单工厂类 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("cheese")) {pizza = new CheesePizza();pizza.setName("奶酪披萨");} else if (orderType.equals("pepper")) {pizza = new PepperPizza();pizza.setName("胡椒披萨");}return pizza;}}
OrderPizza
:根据用户的输入,调用SimpleFactory
工厂类制作相应的Pizza
,OrderPizza
为使用方public class 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);// 输出pizzaif (pizza != null) { // 订购成功pizza.prepare();pizza.bake();pizza.cut();pizza.box();System.out.println();} 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 "";}}}
PizzaStore
:相当于客户端,发出订购披萨的请求//相当于一个客户端,发出订购 public class PizzaStore {public static void main(String[] args) {// 使用简单工厂模式new OrderPizza(new SimpleFactory());System.out.println("~~退出程序~~");}}
其他说明:简单工厂模式也叫静态工厂模式,很多代码中都将简单工厂中提供示例 Bean
的方法声明为静态 static
方法,可通过工厂类直接调用
//简单工厂类
public class SimpleFactory {// 简单工厂模式 也叫 静态工厂模式public static Pizza createPizza(String orderType) {Pizza pizza = null;System.out.println("使用简单工厂模式2");if (orderType.equals("greek")) {pizza = new GreekPizza();pizza.setName("希腊披萨");} else if (orderType.equals("cheese")) {pizza = new CheesePizza();pizza.setName("奶酪披萨");} else if (orderType.equals("pepper")) {pizza = new PepperPizza();pizza.setName("胡椒披萨");}return pizza;}}
简单工厂模式总结:
- 如果使用传统方法,使用方为
OrderPizza
,提供方Pizza
及其实现类,这样编写代码使用方和提供方紧紧耦合在一起,但凡需要新增Pizza
的实现类,都需要修改OrderPizza
中的代码,添加新的判断逻辑 - 为了满足
OCP
原则,我们建立简单工厂类SimpleFactory
,通过SimpleFactory
作为一个中间者的角色:SimpleFactory
向上为OrderPizza
提供相应的Pizza
,SimpleFactory
向下负责与Pizza
及其实现类打交道,完成Pizza
的生产 - 我们将生产
Pizza
的具体细节放在SimpleFactory
工厂类里面实现,让SimpleFactory
作为Pizza
的提供方,这样新增Pizza
的实现类时,我们只需要修改提供方(SimpleFactory
)的代码,而无需修改使用方(OrderPizza
)的代码
2、工厂方法模式
工厂方法模式的实际需求
看一个新的需求
披萨项目新的需求: 客户在点披萨时, 可以点不同口味的披萨, 比如北京的奶酪 pizza
、 北京的胡椒 pizza
或者是伦敦的奶酪 pizza
、 伦敦的胡椒 pizza
。
思路一:简单工厂模式
使用简单工厂模式, 创建不同的简单工厂类, 比如 BJPizzaSimpleFactory
、LDPizzaSimpleFactory
等等。
从当前这个案例来说, 也是可以的, 但是考虑到项目的规模, 以及软件的可维护性、 可扩展性并不是特别好,因为过多的工厂类会导致整个项目类膨胀
思路二:使用工厂方法模式
工厂方法模式介绍
- 工厂方法模式设计方案: 将披萨项目的实例化功能抽象成抽象方法, 在不同的口味点餐子类中具体实现。
- 工厂方法模式: 定义了一个创建对象的抽象方法, 由子类决定要实例化的类。 工厂方法模式将对象的实例化推迟到子类
工厂方法模式应用案例
项目需求:披萨项目新的需求: 客户在点披萨时, 可以点不同口味的披萨, 比如 北京的奶酪 pizza
、 北京的胡椒 pizza
或者是伦敦的奶酪 pizza
、 伦敦的胡椒 pizza
类图
代码实现
Pizza
:抽象父类,和之前的定义一样//将Pizza 类做成抽象 public abstract class Pizza {protected String name; // 名字public void setName(String name) {this.name = 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;");}}
BJCheesePizza
:北京的奶酪披萨public class BJCheesePizza extends Pizza {@Overridepublic void prepare() {setName("北京的奶酪pizza");System.out.println("北京的奶酪pizza 准备原材料");} }
BJPepperPizza
:北京的胡椒披萨public class BJPepperPizza extends Pizza {@Overridepublic void prepare() {setName("北京的胡椒pizza");System.out.println("北京的胡椒pizza 准备原材料");} }
LDCheesePizza
:伦敦的奶酪披萨public class LDCheesePizza extends Pizza {@Overridepublic void prepare() {setName("伦敦的奶酪pizza");System.out.println("伦敦的奶酪pizza 准备原材料");} }
LDPepperPizza
:伦敦的胡椒披萨public class LDPepperPizza extends Pizza {@Overridepublic void prepare() {setName("伦敦的胡椒pizza");System.out.println("伦敦的胡椒pizza 准备原材料");} }
OrderPizza
:含有抽象方法的工厂父类,其抽象方法待子类去实现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();System.out.println();} 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 "";}}}
BJOrderPizza
:北京披萨的生产工厂public class BJOrderPizza extends OrderPizza {@OverridePizza createPizza(String orderType) {Pizza pizza = null;if (orderType.equals("cheese")) {pizza = new BJCheesePizza();} else if (orderType.equals("pepper")) {pizza = new BJPepperPizza();}return pizza;} }
LDOrderPizza
:伦敦披萨的生产工厂public class LDOrderPizza extends OrderPizza {@OverridePizza createPizza(String orderType) {Pizza pizza = null;if (orderType.equals("cheese")) {pizza = new LDCheesePizza();} else if (orderType.equals("pepper")) {pizza = new LDPepperPizza();}return pizza;} }
PizzaStore
:相当于客户端,发出订购披萨的请求public class PizzaStore {public static void main(String[] args) {String loc = "bj"; // 假设这里是用户输入的位置信息if (loc.equals("bj")) {// 创建北京口味的各种Pizzanew BJOrderPizza();} else {// 创建伦敦口味的各种Pizzanew LDOrderPizza();}}}
程序运行结果
input pizza 种类: cheese 北京的奶酪pizza 准备原材料 北京的奶酪pizza baking; 北京的奶酪pizza cutting; 北京的奶酪pizza boxing;input pizza 种类: pepper 北京的胡椒pizza 准备原材料 北京的胡椒pizza baking; 北京的胡椒pizza cutting; 北京的胡椒pizza boxing;input pizza 种类:
工厂方法模式总结
- 首先要说明的是,对于此案例,我们也可以采用简单工厂模式来实现,缺点是:对于一个地区的披萨,我们就需要创建一个对应的工厂类,这会造成项目类膨胀;并且生产披萨的代码几乎都是相同的,这就造成披萨工厂类中的代码冗余
- 对于这种情况,我们可以使用工厂方法模式,将具体的抽象方法声明在父类工厂中,其具体的实现下沉到工厂子类,我们通过工厂子类可以获得所需要的
Bean
- 对于此例,抽象父类
OrderPizza
中有一个抽象方法abstract Pizza createPizza(String orderType);
,该方法接收Pizza
的类型,并生产指定类型的Pizza
;在工厂子类BJOrderPizza
,LDOrderPizza
中实现了该抽象方法,实现了具体生产Pizza
的逻辑 - 对于工厂方法模式,抽象工厂父类
OrderPizza
为Bean
的使用方,它负责调用工厂子类BJOrderPizza
,LDOrderPizza
中已重写的抽象方法,获得生产好的Pizza
,然后使用该Pizza
实例
简单工厂模式与工厂方法模式的对比:
- 简单工厂模式:工厂类作为
Bean
的制造者(提供方),负责与具体的实体类打交道,并负责相应业务逻辑的处理;使用方调用工厂类获取Bean
,使用即可,无需关心该Bean
是如何得到的,也无需关心制造此Bean
的具体业务逻辑,满足OCP
原则 - 工厂方法模式:工厂父类中有一个抽象方法负责制造
Bean
,该抽象方法会下沉到其子类,由工厂子类实现其具体的业务细节,所以工厂子类是Bean
的提供方,此时的工厂父类消费由工厂子类制造的Bean
,为使用方
3、抽象工厂模式
抽象工厂模式的基本介绍
- 抽象工厂模式: 定义了一个
interface
用于创建相关或有依赖关系的对象簇, 而无需指明具体的类 - 抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合。
- 从设计层面看, 抽象工厂模式就是对简单工厂模式的改进(或者称为进一步的抽象)。
- 将工厂抽象成两层,
AbsFactory
(抽象工厂) 和 具体实现的工厂子类。 程序员可以根据创建对象类型使用对应的工厂子类。 这样将单个的简单工厂类变成了工厂簇, 更利于代码的维护和扩展。
抽象工厂模式的案例
使用抽象工厂模式来完成披萨项目
类图
代码实现
Pizza
抽象父类以及Pizza
的具体实现类和上面一样AbsFactory
:工厂抽象层,定义制造Bean
的抽象方法//一个抽象工厂模式的抽象层(接口) public interface AbsFactory {// 让下面的工厂子类来 具体实现public Pizza createPizza(String orderType); }
BJFactory
:北京工厂子类(提供方),负责制造北京各种口味的Pizza
//这是工厂子类 public class BJFactory implements AbsFactory {@Overridepublic 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
:伦敦工厂子类(提供方),负责制造伦敦各种口味的Pizza
public class LDFactory implements AbsFactory {@Overridepublic 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
:使用方,负责消费Pizza
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) { // 订购okpizza.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 "";}} }
PizzaStore
:客户端,发出订购披萨的请求public class PizzaStore {public static void main(String[] args) {//new OrderPizza(new BJFactory());new OrderPizza(new LDFactory());}}
抽象工厂模式总结
AbsFactory
仍然是简单工厂(简单工厂模式),但是工厂方法的具体实现需下沉到各个工厂子类(工厂方法模式),所以说抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合。- 抽象工厂模式分为两层:抽象层和实现层。
AbsFactory
作为工厂抽象层,只对工厂规范进行定义,其具体的实现交由工厂子类 - 简单工厂模式很难满足对多种不同类型的
Bean
进行创建,所以我们使用抽象工厂模式,定义一个工厂抽象层,但具体实现需下沉到各个工厂子类
4、JDK Calendar
JDK Calendar 中使用到了简单工厂模式
测试代码
public class Factory {public static void main(String[] args) {// getInstance 是 Calendar 静态方法Calendar cal = Calendar.getInstance();// 注意月份下标从0开始,所以取月份要+1System.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.getInstance()
方法的实现
/*** Gets a calendar using the default time zone and locale. The* <code>Calendar</code> returned is based on the current time* in the default time zone with the default* {@link Locale.Category#FORMAT FORMAT} locale.** @return a Calendar.*/
public static Calendar getInstance()
{return createCalendar(TimeZone.getDefault(), Locale.getDefault(Locale.Category.FORMAT));
}
createCalendar()
方法的实现:如果 provider == null
,就会根据 caltype
的值,来创建具体的工厂子类对象
private static Calendar createCalendar(TimeZone zone,Locale aLocale)
{CalendarProvider provider =LocaleProviderAdapter.getAdapter(CalendarProvider.class, aLocale).getCalendarProvider();if (provider != null) {try {return provider.getInstance(zone, aLocale);} catch (IllegalArgumentException iae) {// fall back to the default instantiation}}Calendar cal = null;if (aLocale.hasExtensions()) {String caltype = aLocale.getUnicodeLocaleType("ca");if (caltype != null) {switch (caltype) {case "buddhist":cal = new BuddhistCalendar(zone, aLocale);break;case "japanese":cal = new JapaneseImperialCalendar(zone, aLocale);break;case "gregory":cal = new GregorianCalendar(zone, aLocale);break;}}}if (cal == null) {// If no known calendar type is explicitly specified,// perform the traditional way to create a Calendar:// create a BuddhistCalendar for th_TH locale,// a JapaneseImperialCalendar for ja_JP_JP locale, or// a GregorianCalendar for any other locales.// NOTE: The language, country and variant strings are interned.if (aLocale.getLanguage() == "th" && aLocale.getCountry() == "TH") {cal = new BuddhistCalendar(zone, aLocale);} else if (aLocale.getVariant() == "JP" && aLocale.getLanguage() == "ja"&& aLocale.getCountry() == "JP") {cal = new JapaneseImperialCalendar(zone, aLocale);} else {cal = new GregorianCalendar(zone, aLocale);}}return cal;
}
5、工厂模式小结
工厂模式的意义:将实例化对象的代码提取出来,放到一个类中统一管理和维护,达到和主项目的依赖关系的解耦。从而提高项目的扩展和维护性。
三种工厂模式
- 简单工厂模式
- 工厂方法模式
- 抽象工厂模式
设计模式的依赖抽象原则
- 创建对象实例时,不要直接
new
这个类,而是把这个new
类的动作放在一个工厂的方法中,并返回。有的书上说,变量不要直接持有具体类的引用。这样做的好处是:我们依赖的是一个抽象层(缓冲层),如果之后有什么变动,修改工厂类中的代码即可 - 不要让类继承具体类,而是继承抽象类或者是实现
interface
(接口) - 不要覆盖基类中已经实现的方法
第 6 章 工厂模式相关推荐
- 【设计模式】第四章 工厂模式
第四章 工厂模式 文章目录 第四章 工厂模式 一.介绍 二.简单工厂模式 三.工厂方法模式 四.抽象工厂模式 一.介绍 工厂模式(Factory Pattern),工厂就是创建产品的地方,根据创建的产 ...
- 【设计模式2022】第四章 工厂模式
[设计模式2022]第四章 工厂模式 文章目录 [设计模式2022]第四章 工厂模式 一.概述 二.简单工厂模式 1.结构 2.实现 3.分析 4.扩展 三.工厂方法模式 1.结构 2.实现 3.分析 ...
- Python 设计模式 - 工厂模式
精通Python设计模式第二版 第 1 章 工厂模式 学习笔记 工厂模式 工厂模式的思想意在简化对象的创建过程.调用者(客户端)不清楚对象的来源以及生成对象的方式,调用者只需要调用某个方法或者实例某个 ...
- python工厂模式 django_Mastering.Python.Design.Patterns
第一章 工厂模式 创造模式处理一个对象的创建.创造模式的目的是为了在不按照约定而直接地创建的地方提供可选择的情况. 在工厂模式中,客户端查询一个对象而不知道这个对象来自哪里(即,哪一个类被用来生成它) ...
- 《javascript设计模式》笔记之第七章:工厂模式
在读了这章之后,根据我个人现在的理解,工厂模式就是:将一个类或者一个方法称为一个工厂,然后再将一些模块交给这个工厂,让这个工厂按照给它的不同模块产出不同的实例. 下面为正文: 一:简单工厂: 例子: ...
- 【Golang第8章:面向对象编程】Go语言的结构体是什么,怎么声明;Golang方法的调用和声明;go语言面向对象实例,go语言工厂模式;golang面向对象的三大特性:继承、封装、多态
介绍 这个是在B站上看边看视频边做的笔记,这一章是Glang面向对象编程 这一章内容较多,内容有Go语言的结构体是什么,怎么声明:Golang方法的调用和声明:go语言面向对象实例,go语言工厂模式: ...
- [Python设计模式] 第1章 计算器——简单工厂模式
github地址:https://github.com/cheesezh/python_design_patterns 写在前面的话 """ 读书的时候上过<设计模 ...
- 第一章 简单工厂模式
面向对象编程永远在考虑:解藕和复用. 设计模式是前辈总结的结果,这些模式都是基于问题本身的抽象,活学活用才是王道. /// 简单工厂模式具有面向对象编程的基本优点:封装.继承和多态. /*** Cre ...
- 《Head First设计模式》第四章笔记 工厂模式
之前我们一直在使用new操作符,但是实例化这种行为并不应该总是公开的进行,而且初始化经常会造成耦合问题,工厂模式将摆脱这种复杂的依赖,本次内容包括简单工厂,工厂方法和抽象工厂三种情况. 1 2 3 4 ...
最新文章
- .net下绘制统计图工具-请推荐
- 计算机中的大端模式与小端模式
- 启动项目时出现java.io.EOFException异常。
- 发布一个Python小程序:ManHourCalendar
- jdbc java例子_Spring JDBC 例子
- 删除桌面快捷方式小图标的bat命令
- 【壁纸】(可商用) 70枚壁纸高清免费
- flask ajax 笔记
- 设置网页右键点击,并阻止右键点击默认事件
- HCIA-IoT V2.5物联网初级考试总结(附题库,历年真题,刷题软件)
- 汽车故障诊断技术【11】
- 基于因子分析法分析新冠肺炎疫情对房地产业上市公司财务的影响
- Linux: 软件包管理工具 yum/dnf 命令(Fedora/CentOS/RedHat)
- Java如何把文档转换成PDF
- 手机科普(软硬件简介——android)看了会懂很多东西的!
- 嵌入式常见的面试题汇总
- 企业微信如何解散自己建的群聊
- Ryzen3 2200g安装Debian11.1后配置VBox
- 趋势交易大师php,系统交易的初阶——趋势交易者路在何方?
- 测试apk-异常管控Sensor攻击者开发
热门文章
- html 增加和删除一行,关于JS点击增加一行,点击删除一行的问题?
- oracle form执行后左上角没出现oracle标记,Oracle FORM 开发技巧(1)
- 翻车事故频发,原来是开发者漏了这一步!
- Java 是如何优雅地实现接口数据校验的?
- GitHub 一周热点:听说程序员都是颜控?
- Python 玩出花了!一文教你用 Python 制作吃豆人游戏! | 附代码
- 天猫京东618下单金额近万亿;苹果或选择印度组装新款iPhone SE;Adobe将于12月31日终止支持Flash| 极客头条...
- 移动电话之父第一个电话打给对手,起底现代移动通信崛起之路!
- 释放低代码小宇宙,微软 Power Platform 震撼来袭!
- 微信付费阅读支付宝可用,iOS抽成30%;苹果安卓充电器或统一;UOS 20发布 | 极客头条...