下载文档原格式
HeadFirst设计模式之⽬录只有沉淀、积累，才能远航；沉沉浮浮，脚踏实地。
这本书已经闲置了好久，⼼⾎来潮，决定写个⽬录，让⾃⼰坚持看完这本书创建型模式1. (Abstract factory pattern): 提供⼀个接⼝, ⽤于创建相关或依赖对象的家族, ⽽不需要指定具体类.2. (Builder pattern): 使⽤⽣成器模式封装⼀个产品的构造过程, 并允许按步骤构造. 将⼀个复杂对象的构建与它的表⽰分离, 使得同样的构建过程可以创建不同的表⽰.3. (factory method pattern): 定义了⼀个创建对象的接⼝, 但由⼦类决定要实例化的类是哪⼀个. ⼯⼚⽅法让类把实例化推迟到⼦类.4. (prototype pattern): 当创建给定类的实例过程很昂贵或很复杂时, 就使⽤原形模式.5. (Singleton pattern): 确保⼀个类只有⼀个实例, 并提供全局访问点.6. 多例模式(Multition pattern): 在⼀个解决⽅案中结合两个或多个模式, 以解决⼀般或重复发⽣的问题.结构型模式1. : 将⼀个类的接⼝, 转换成客户期望的另⼀个接⼝. 适配器让原本接⼝不兼容的类可以合作⽆间. 对象适配器使⽤组合, 类适配器使⽤多重继承.2. : 使⽤桥接模式通过将实现和抽象放在两个不同的类层次中⽽使它们可以独⽴改变.3. : 允许你将对象组合成树形结构来表现"整体/部分"层次结构. 组合能让客户以⼀致的⽅式处理个别对象以及对象组合.4. : 动态地将责任附加到对象上, 若要扩展功能, 装饰者提供了⽐继承更有弹性的替代⽅案.5. : 提供了⼀个统⼀的接⼝, ⽤来访问⼦系统中的⼀群接⼝. 外观定义了⼀个⾼层接⼝, 让⼦系统更容易使⽤.6. : 如想让某个类的⼀个实例能⽤来提供许多"虚拟实例", 就使⽤蝇量模式.7. : 为另⼀个对象提供⼀个替⾝或占位符以控制对这个对象的访问.⾏为型模式1. : 通过责任链模式, 你可以为某个请求创建⼀个对象链. 每个对象依序检查此请求并对其进⾏处理或者将它传给链中的下⼀个对象.2. : 将"请求"封闭成对象, 以便使⽤不同的请求,队列或者⽇志来参数化其他对象. 命令模式也⽀持可撤销的操作.3. : 使⽤解释器模式为语⾔创建解释器.4. : 提供⼀种⽅法顺序访问⼀个聚合对象中的各个元素, ⽽⼜不暴露其内部的表⽰.5. : 使⽤中介者模式来集中相关对象之间复杂的沟通和控制⽅式.6. : 当你需要让对象返回之前的状态时(例如, 你的⽤户请求"撤销"), 你使⽤备忘录模式.7. : 在对象之间定义⼀对多的依赖, 这样⼀来, 当⼀个对象改变状态, 依赖它的对象都会收到通知, 并⾃动更新.8. : 允许对象在内部状态改变时改变它的⾏为, 对象看起来好象改了它的类.9. : 定义了算法族, 分别封闭起来, 让它们之间可以互相替换, 此模式让算法的变化独⽴于使⽤算法的客户.10. : 在⼀个⽅法中定义⼀个算法的⾻架, ⽽将⼀些步骤延迟到⼦类中. 模板⽅法使得⼦类可以在不改变算法结构的情况下, 重新定义算法中的某些步骤.11. : 当你想要为⼀个对象的组合增加新的能⼒, 且封装并不重要时, 就使⽤访问者模式.七⼤设计原则1. 单⼀职责原则【SINGLE RESPONSIBILITY PRINCIPLE】：⼀个类负责⼀项职责。
⼀句话的事⼉，Headfirst设计模式head first 设计模式，是⽐较有趣的⼀本设计模式的书。
在学校⾥看书和在⼯作时看书，意义是不⼀样的。
在学校时是为读书⽽读书，我们可以从0到1，我们有的是时间。
但是⼯作后就不⼀样。
我觉得这时的书更像是打通⾃⼰任督⼆脉的武功秘诀。
在平时⼯作中，杂七杂⼋地学了⼀些东西，但是却不能融会贯通。
所以还需要通过书来厘清你的思路。
这是写本⽂的出发点，也是我的碎碎念！看完该书后，转换成⾃⼰的语⾔，再表达出来，可能有错（那是⼀定的），但是，有总⽐没有好。
如果有同学能够从中得到些启发，也算是⾃⼰的⼀种幸运吧！我竟试图以⼀句话来描述⼀个设计模式！1. 策略模式！将统⼀的东西作为基类，可变的东西⾏为独⽴出来，在基类中通过变量进⾏引⽤，通过委托变量的⽅式，使⽤setter⽅法将委托变量改变，使其具有⾏为可变性。
⾯向接⼝编程，⽽⾮⾯向类编程。
其好处是，⽤同样的接⼝，通过不同⾏为类的传⼊产⽣不同的效果，便以改变⾏为变得容易。
2. 观察者模式！类似于发布-订阅模式。
存在注册服务，通知的过程。
其实现⽅式可以理解为，注册服务时，将观察者加⼊到队列当中，当主题发⽣变更时，由主题主动依次从观察者队列中依次调⽤，从⽽达到通知主动推送的作⽤。
其好处是，观察者随时注册观察可以实时收到消息，⽽被观察者对此⼀⽆所知，从⽽在达到通知的同时也解藕了。
3. 装饰者模式！以某对象为主要对象，⽣成后，将其传⼊装饰者构造函数中，经过装饰后，再⾏输出的模式。
该模式，可以许多散乱的⽅法独⽴组装出来，⽽不会影响其他变化，该模式是通过继承来实现的。
典型的装饰者模式运⽤，java io 类的继承，有多个主类，及多个装饰类，从⽽⽅便⽤户操作想要的⽅法。
其好处是，在⼤⽅向不变的情况下，可以反复更改主要的⾏为结果，对于⼀些附加类的变化，可以很⽅便地通过该模式进⾏数据再加⼯。
4. ⼯⼚模式！分为简单⼯⼚模式-⼯⼚模式-抽象⼯⼚模式。
Head First Design Patterns(深入浅出设计模式)-设计模式介绍1.Welcome to Design Patterns -设计模式介绍现在我们要住进对象村(Objectville),我们刚刚开始接触设计模式…每个人都在使用它们。
一会我们将去参加Jim和Betty的星期三晚上的模式聚会!有人已经解决了你的问题。
在这章里，你将学习到为什么(和怎么样)，你将学习到那些幸存下来的开发者的智慧和教训，他们都曾经历过类似的设计问题。
在我们做之前，我们将先看看设计模式的用途和好处，再看一些关键的面向对象设计原则，并且再通过一个实例了解模式的工作方式。
使用模式最好的方法就是把它们装入脑袋里，然后在你设计和现有的应用程序里找到你能够应用它们的地方。
相对于代码重用，使用模式你获得了经验的重用。
-1-从一个简单的模拟鸭子程序开始乔为一个制造非常成功的模拟鸭子池塘游戏(SimUDuck)的公司工作。
这个游戏可以展示很多种鸭子的游泳方式和呷呷叫声。
系统最初的设计者们使用了标准的面向对象技术，他们创建了一个Duck基类供所有其它类型的鸭子继承。
去年，竞争者们给公司带来了越来越多的压力。
经过历时一周在高尔夫球赛场上的集体讨论，公司的经理们都觉得该是进行一次大改革的时候了。
他们需要在下周在毛伊岛举行的股东大会上展示一些真正给人深刻印象的东西。
-2-但是我们现在需要鸭子可以飞经理们确定会飞的鸭子就是模拟器需要的用来击败其他竞争者的东西。
当然，乔的经理告诉他们，对于乔来说在一周内迅速搞定这些根本不是问题。
“毕竟”，乔的上司说，“他是一个面向对象的程序员…那些有什么难的呢？”乔想：我仅仅只需要在Duck类里增加fly()方法，然后所有其他鸭子就都可以继承它了。
现在是展示我真正的面向对象才华的时候了。
-3-但是有些事情严重错误了…乔的上司：乔，我正在股东大会上。
他们刚看完演示，很多橡皮鸭子在屏幕上四处乱飞。
这是你在开玩笑吗？…发生了什么事？乔没有注意到并不是所有Duck的子类都需要fly()方法。
编辑推荐本书荣获2005年第十五届Jolt通用类图书震撼大奖。
本书英文影印版被《程序员》等机构评选为2006年最受读者喜爱的十大IT图书之一 。
本书趋近完美，因为它在提供专业知识的同时，仍然具有相当高的可读性。
叙述权威、文笔优美。
本书共有14章，每章都介绍了几个设计模式，完整地涵盖了四人组版本全部23个设计模式。
前言先介绍这本书的用法；第1章到第11章陆续介绍的设计模式为Strategy、Observer、Decorator、Abstract Factory、Factory Method、Singleton、Command、Adapter、Facade、Templat Method、Iterator、Composite、State、Proxy。
最后三章比较特别。
第12章介绍如何将两个以上的设计模式结合起来成为新的设计模式（例如著名的MVC模式），作者称其为复合设计模式（这是作者自创的名称，并非四人组的标准名词），第13章介绍如何进一步学习设计模式，如何发觉新的设计模式等主题，至于第14章则很快地浏览尚未介绍的设计模式，包括Bridge、Builder、Chain of Responsibility、Flyweight、Interpreter、Mediator、Memento、Prototype、Visitor。
第1章还介绍了四个OO基本概念（抽象、封装、继承、多态），而第１章到第9章也陆续介绍了九个OO原则（Principle）。
千万不要轻视这些OO原则，因为每个设计模式背后都包含了几个OO原则的概念。
很多时候，在设计时有两难的情况，这时候我们必须回归到OO原则，以方便判断取舍。
可以这么说：OO原则是我们的目标，而设计模式是我们的做法。
本书作者Eric Freeman和Elisabeth Freeman是作家、讲师和技术顾问。
Eric拥有耶鲁大学的计算机科学博士学位，Elisabath拥有耶鲁大学的计算机科学硕士学位。
headfirst设计模式java_吐血整理HeadFirst设计模式大全首先，要理解Head First设计模式，需要明白设计模式的概念。
设计模式是在软件开发中经过实践验证的解决方案，它们是解决特定问题的经验总结。
Head First系列是一本非常经典的计算机科学图书系列，其中《Head First设计模式》专门介绍了23种常见的设计模式，并以Java语言进行讲解。
本书从实际问题出发，用生动形象的方式讲解设计模式，以帮助读者更好地理解和应用这些设计模式。
下面将介绍一些书中提到的设计模式和其在Java编程中的应用。
1. 策略模式（Strategy Pattern）：策略模式将一组行为封装成策略类，使其在运行时可以相互替换。
在Java中，可以使用接口来定义策略，不同的策略类实现相同的接口，根据不同情况选择不同的策略。
2. 观察者模式（Observer Pattern）：观察者模式定义了对象间的一种一对多的关系，当一个对象状态改变时，所有依赖它的对象都会被通知并自动更新。
在Java中，可以使用java.util.Observable类和java.util.Observer接口来实现观察者模式。
3. 装饰者模式（Decorator Pattern）：装饰者模式动态地将责任附加到对象上，通过创建一个装饰者类来包装原始对象，以提供额外的功能。
在Java中，可以通过继承原始对象并添加额外功能的方式来实现装饰者模式。
4. 工厂模式（Factory Pattern）：工厂模式定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。
在Java中，可以使用工厂方法模式来实现，通过定义一个工厂接口和具体的工厂类来创建实例。
5. 单例模式（Singleton Pattern）：单例模式确保一个类只有一个实例，并提供一个全局访问点。
在Java中，可以使用私有构造函数和静态方法来实现单例模式。
以上只是其中一部分介绍的设计模式，还有其他如适配器模式、迭代器模式、模板方法模式等。
计算机四大天书学习顺序
1、《计算机运作的简单原理》。
2、《算法图解》。
3、《HeadFirst设计模式》。
4、《交互式设计四策略》。
这四本书对应了四个阶段：
1、第一个阶段，初来乍到，需要学习计算机本质是什么，进而理解如何与计算机交流（编程语言），懂得代码是如何被执行的。
2、第二个阶段，已经初步学会使用一门编程语言求解计算问题，这个时候需要思考如何让你的程序更快更省（空间）的解决问题。
此时，经典算法和数据结构登场。
程序=代码+算法，算法是解决特定问题的特定方法（套路），一个算法是一个不会失败的，确保达到既定目标的过程。
3、第三个阶段，同学们开始学习高级编程语言或者编程平台（Web 应用、Android应用等）了，课程设计需要实现综合性的系统。
大家已明白现代软件是诸多组件的结合体，组件之间的交互需要精密的设计；开发的过程需要同小组的成员进行协作，也需要同未来的自己进行写作。
这时候，就需要设计模式出场了。
它既是解决领域的对象如何组织的特定方法（套路），也是同行之间交流的工具。
4、第四个阶段，我们的目标不只在于课程设计了，而是正经（假装会有人用）的产品了。
但是为何有些人做的软件用起来如“丝滑般
感受”，而有的却那么不懂用户的心思。
这时候，你需要学习一定的产品设计思维、用户体验设计技巧。
HeadFirst设计模式中文版课程设计一、课程简介HeadFirst设计模式中文版是一门面向对象设计模式的课程，主要介绍23个常用的设计模式以及如何在实际项目中应用它们。
课程难度适中，适合有一定编程基础的学员学习。
本课程旨在帮助学员深入理解面向对象设计原则以及如何将其应用于实践中。
二、课程目标本课程将通过以下几个方面来使学员达到掌握面向对象设计模式的目标：1.让学员了解23个常用的设计模式。
2.帮助学员了解如何将设计模式应用到实际项目中。
3.培养学员的面向对象设计思维。
4.掌握常见的面向对象设计原则。
三、课程结构本课程共分为6个单元，每个单元包含了多个设计模式的讲解，学员将会通过理论课、案例分析和练习来深入掌握每种设计模式的概念和实现方式。
具体的课程结构如下：内容单元单内容元1 面向对象设计概述、策略模式、观察者模式、装饰者模式、工厂模式2 单例模式、命令模式、适配器模式、外观模式、模板方法模式3 迭代器模式、组合模式、状态模式、代理模式、桥接模式4 生成器模式、原型模式、享元模式、责任链模式、解释器模式5 中介者模式、备忘录模式、访问者模式6 雷打设计模式四、教学方法本课程采用“理论+实践”的教学方式，其中理论课主要通过PPT、视频等多种形式给学员讲解各个设计模式的概念和实现方式；实践环节包括编程练习和项目案例分析，让学员深入理解并掌握每种设计模式的应用场景以及具体实现方法。
同时，我们还将为每位学员提供在线答疑服务，帮助他们解决学习中遇到的问题。
五、考核方式本课程的考核方式主要包括两个环节：作业和项目。
其中，作业主要考察学员对每种设计模式的理解和具体应用方法，要求学员在规定时间内完成编程练习和课堂练习；项目考核环节要求学员在实际项目上应用所学的设计模式，完成实际项目需求并提交相关文档和源代码。
六、课程资料本课程的主要资料包括：1.HeadFirst设计模式中文版课程PPT。
2.HeadFirst设计模式中文版课程视频。
《Head.First设计模式》读书笔记目录1、创建型设计模式 (1)1.1工厂方法Factory Method【类】与抽象工厂Abstract Factory【对象、chapter 4】 (1)1.2单件Singleton【chapter5、对象】 (2)2、结构型设计模式 (2)2.1适配器Adapter【chapter7、类/对象】 (2)2.2组合Composite【chapter9、对象】 (2)2.3装饰者Decorator【chapter3、对象】 (2)2.4外观Facade【chapter7、对象】 (3)2.5代理Proxy【chapter11、对象】 (3)3、行为型设计模式 (3)3.1模板方法Template Method【chapter8、类】 (3)3.2命令Command【chapter6、对象】 (3)3.3迭代器Iterator【chapter9、对象】 (4)3.4观察者Observer【chapter2、对象】 (4)3.5状态State【chapter10、对象】 (4)3.6策略Strategy【chapter1、对象】 (4)4、与设计模式相处 (5)1、创建型设计模式1.1工厂方法Factory Method【类】与抽象工厂Abstract Factory【对象、chapter 4】(1) 工厂方法Factory Method：定义：由子类决定要实例化的类是哪一个。
让类把实例化推迟到子类。
实例：拓展披萨工厂，有各地风味的加盟店。
实现：分为Product(产品类披萨)和Creator(创建者类PizzaStore)两个类层级，都有许多具体的子类，每个子类都有自己特定的实现。
相关：“依赖倒置原则Dependency Inversion Principle”【6】。
要依赖抽象，不要依赖具体类。
PizzaStore是高层组件、比萨实现是低层组件，前者依赖后者。
head first中所有的设计原则在《Head First 设计模式》一书中，提到了以下几种设计原则：
1. 单一职责原则：一个类应该只有一个引起变化的原因。
也就是说，每个类应该只有一个职责，只负责一项功能。
2. 开放封闭原则：软件实体（类、模块、函数等等）应该是可以扩展的，但是不可修改。
也就是说，新的功能应该通过添加新的模块或者子类来实现，而不是修改现有的代码。
3. 里氏替换原则：如果S是T的子类，则程序中使用T类型的对象的地方都可以用S类型的对象来替换，而不会引起任何不期望的后果。
4. 接口隔离原则：客户端不应该依赖它不使用的接口。
接口隔离原则可以降低客户代码与实现细节之间的耦合度，使得客户端更加灵活和易于维护。
5. 依赖倒置原则：高层模块不应该依赖于低层模块，它们都应该依赖于抽象。
抽象不应该依赖于细节，细节应该依赖于抽象。
6. 迪米特法则：一个对象应该对其他对象保持最少的了解。
也就是说，一个对象应当尽可能少的与其他对象直接相互作用，不应该强制具体的对象直接通信，而应该使用一种规约方式（例如抽象类或接口）来进行间接通信。
7. 合成复用原则：尽量使用合成/聚合，而不是继承关系达到软件复用的目的。
以上是《Head First 设计模式》中提到的设计原则，这些原则可以帮助我们设计出更加健壮、可维护和可扩展的软件系统。
Head First 设计模式介绍Head First 设计模式是一本由埃里克·弗里曼（Eric Freeman）、伊丽沙白·弗里曼（Elisabeth Freeman）、考思温·西迪（Kathy Sierra）和贾尼特·贝茨（Bert Bates）合著的图书，该书使用了一种独特的学习方式，通过大量的图表、示例和练习来帮助读者理解和实践面向对象设计模式。
本文档将对 Head First 设计模式进行简要概述，并介绍其中涵盖的几种常见的设计模式。
设计模式概述设计模式是在软件开发过程中经常出现的问题的解决方案。
它们旨在提供一种通用的方法，帮助开发人员解决特定类型的问题。
设计模式有助于提高软件的可重用性、可维护性和可扩展性。
Head First 设计模式一书介绍了23种常见的设计模式，分为三种类型：创建型模式、结构型模式和行为型模式。
•创建型模式：这些模式关注对象的创建过程，包括如何实例化对象和配置对象的创建流程。
•结构型模式：这些模式关注对象之间的组合，以建立更大的结构，并提供对象之间的简化操作。
•行为型模式：这些模式关注对象之间的交互和通信，以实现特定的行为和协作。
以下是 Head First 设计模式中介绍的一些常见设计模式：创建型模式单例模式单例模式确保一个类只有一个实例，并提供一个全局访问点来访问该实例。
通过单例模式，我们可以限制对某个类的实例化，避免多个对象同时存在。
工厂模式工厂模式是一种创建型模式，它定义了一个创建对象的接口，但将具体的实现交给了子类来决定。
工厂模式可以通过将对象的创建和使用解耦，从而提供一种灵活的方法来创建多个对象的实例。
结构型模式适配器模式适配器模式将一个类的接口转换为客户端所期望的另一个接口，从而使两个类能够协同工作。
适配器模式适用于需要将一个类集成到另一个类中，并且不能修改原有类的情况。
装饰器模式装饰器模式允许在不改变现有对象结构的情况下，动态地添加行为。
《Head First设计模式》阅读笔记.第三章
文章分类:Java编程
1.装饰者（Decorator）模式部分
*利用组合（composition）和委托（delegation）可以在运行时实现继承行为的效果，动态地给对象加上新的行为。
*利用继承扩展子类的行为，是在编译时静态决定的；利用组合的做法，可以在运行时动态地扩展对象的行为。
软件设计原则：类应该对扩展开放，对修改关闭。
这就是我们常说的开放-关闭原则。
*开放-关闭原则使类容易扩展，在不修改代码的情况下，通过搭配实现新的行为。
这样的设计可以应对改变，比如增加新功能或需求发生变更。
OO设计技巧：允许系统在不修改代码的情况下，进行功能扩展。
*装饰者模式：动态地将责任加到对象身上。
如果要扩展功能，装饰者模式提供了比继承更有弹性的替代方案。
*装饰者模式中，装饰者可以在被装饰者的行为之前或之后，加上自己的行为，以实现特性的目的。
*装饰者模式的几个缺点：
（1）有时在设计中加入大量的小类，变得不容易理解。
（2）有的客户端代码依赖于特定的类型（这是个比较糟糕的习惯，违反了“针对接口编程，而不是针对实现编程”的设计原则），当服务器端引入装饰者模式时，客户端就会出现状况。
（3）装饰者模式使得实例化组件的复杂度提升。
PS：工厂（Factory）模式和生成器（Builder）模式对于装饰者（Decorator）模式的这些缺点会有所帮助。
*遵循开放-关闭原则设计系统，努力使关闭的部分（不变）和开放的部分（变化）隔离开来。
2.装饰者（Decorator）模式实例
Java代码
1.public abstract class Car {
2. String name = "Unknow Car";
3.
4. public String getName() {
5. return ;
6. }
8. public abstract float cost();
9.}
10.
11.// 标准型Benz汽车
12.public class BenzCar extends Car {
13. public BenzCar() {
14. = "Benz";
15. }
16.
17. @Override
18. public float cost() {
19. return 100 * 10000.00f;
20. }
21.}
22.
23.// 标准型BMW汽车
24.public class BmwCar extends Car {
25. public BmwCar() {
26. = "BMW";
27. }
28.
29. @Override
30. public float cost() {
31. return 50 * 10000.00f;
32. }
33.}
34.
35.// 标准QQ汽车
36.public class QQCar extends Car {
37. public QQCar() {
38. = "QQ";
39. }
40.
41. @Override
42. public float cost() {
43. return 3 * 10000.00f;
44. }
45.}
46.
47.// 配件装饰者
48.public abstract class AccesoryDecorator extends Car {
49. public abstract String getName();
50.}
52.// 安全气囊配件
53.public class AirbagAccesory extends AccesoryDecorator {
54. private Car car;
55.
56. public AirbagAccesory(Car car) {
57. this.car = car;
58. }
59.
60. @Override
61. public String getName() {
62. return car.getName() + ",Airbag";
63. }
64.
65. @Override
66. public float cost() {
67. return car.cost() + 1500;
68. }
69.}
70.
71.// 摄像头配件
72.public class CameraAccesory extends AccesoryDecorator {
73. private Car car;
74.
75. public CameraAccesory(Car car) {
76. this.car = car;
77. }
78.
79. @Override
80. public String getName() {
81. return car.getName() + ",Camera";
82. }
83.
84. @Override
85. public float cost() {
86. return car.cost() + 800;
87. }
88.}
89.
90.// 收音机配件
91.public class RadioAccesory extends AccesoryDecorator {
92. private Car car;
93.
94. public RadioAccesory(Car car) {
95. this.car = car;
96. }
97.
98. @Override
99. public String getName() {
100. return car.getName() + ",Radio";
101. }
102.
103. @Override
104. public float cost() {
105. return car.cost() + 600;
106. }
107.}
Java代码
1.// 测试程序
2.public class Test {
3. public static void main(String[] args) {
4. Car car1 = new RadioAccesory(new AirbagAccesory(new CameraAccesory(new Benz
Car())));
5. printCarInfo(car1);
6.
7. Car car2 = new AirbagAccesory(new CameraAccesory(new BmwCar()));
8. printCarInfo(car2);
9.
10. Car car3 = new RadioAccesory(new QQCar());
11. printCarInfo(car3);
12. }
13.
14. public static void printCarInfo(Car car) {
15. System.out.println("Car Name:" + car.getName() + ",Cost:" + car.cost());
16. }
17.}
测试程序运行结果：
Java代码
1.Car Name:Benz,Camera,Airbag,Radio,Cost:1002900.0
2.Car Name:BMW,Camera,Airbag,Cost:502300.0
3.Car Name:QQ,Radio,Cost:30600.0。
