反馈文件质量
nexusstc/Java XML 和 JSON 教程（机翻）/8b20d2feb3c6aaadd160f9f6892a1584.epub
Java XML 和 JSON 教程(机翻) 🔍
it-ebooks iBooker it-ebooks, it-ebooks-extra
英语 [en] · 中文 [zh] · EPUB · 0.3MB · 1992 · 📘 非小说类图书 · 🚀/duxiu/lgli/lgrs/nexusstc · Save
描述
Web frameworks are playing a major role in the creation of today's most compelling web applications, because they automate many of the tedious tasks, allowing developers to instead focus on providing users with creative and powerful features. Java developers have been particularly fortunate in this area, having been able to take advantage of Grails, an open source framework that supercharges productivity when building Java–driven web sites. Grails is based on Groovy, which is a very popular and growing dynamic scripting language for Java developers and was inspired by Python, Ruby, and Smalltalk.
Beginning Groovy and Grails is the first introductory book on the Groovy language and its primary web framework, Grails.
This book gets you started with Groovy and Grails and culminates in the example and possible application of some real–world projects. You follow along with the development of each project, implementing and running each application while learning new features along the way.
What you’ll learn
Understand the fundamentals of the open source, dynamic Groovy scripting language and the Grails web framework.
Capitalize upon Grails’ well–defined framework architecture to build web applications faster than ever before.
Improve your web application with cutting–edge interface enhancements using Ajax.
Use Grails’ object–relational mapping solution, GORM, to manage your data store more effectively than ever before.
Take advantage of Groovy to create reporting services, implement batch processing, and create alternative client interfaces.
Deploy and upgrade your Grails–driven applications with expertise and ease.
Discover an alternative client in Groovy as well.
Who this book is for
Java and web developers looking to learn and embrace the power and flexibility offered by the Grails framework and Groovy scripting language.
备用文件名
lgli/Java XML 和 JSON 教程（机翻）.epub
备用文件名
lgrsnf/Java XML 和 JSON 教程（机翻）.epub
备选标题
Beginning Groovy and Grails: From Novice to Professional (Beginning: from Novice to Professional)
备选标题
Beginning Groovy and Grails

Experts Voice in Open Source
备选标题
Neural networks : algorithms, applications, and programming techniques
备选标题
Effective Java: Programming Language Guide (Java Series)
备选标题
Effective Java : [revised and updated for JAVA SE 6
备选标题
Advanced C++ : programming styles and idioms
备选作者
Christopher M. Judd; Joseph Faisal Nusairat; James Shingler; Graeme Rocher
备选作者
Jim Shingler; Joseph Faisal Nusairat; Christopher M Judd
备选作者
Joshua Bloch; [foreword by Guy Steele]
备选作者
Coplien, James O.
备选作者
James O. Coplien
备选作者
James A. Freeman
备选作者
Bloch, Joshua
备用出版商
Apress ; Distributed to the Book trade worldwide by Springer-Verlag
备用出版商
Apress ; Springer-Verlag, distributor
备用出版商
Addison-Wesley Professional
备用出版商
Da Capo Press, Incorporated
备用出版商
Addison-Wesley Pub. Co.
备用出版商
Hachette Books
备用出版商
Basic Books
备用版本
The Java series, 2. ed., 4. print, Upper Saddle River, NJ, 2008
备用版本
Expert's voice in open source, Berkeley, CA : New York, ©2008
备用版本
Computation and neural systems series, Reading, Mass, ©1991
备用版本
The Java series, Boston, Massachusetts, 2001
备用版本
Reading Massachusetts ; Wokingham, 1994
备用版本
United States, United States of America
备用版本
Springer Nature, Berkeley, CA, 2008
备用版本
Reading, Mass, Massachusetts, 1992
备用版本
1st, First Edition, FR, 2008
备用版本
New ed, Berkeley, June 2008
备用版本
New Edition, 1991
备用版本
PS, 1992
备用版本
1, 2001
元数据中的注释
{"content":{"parsed_at":1702197383,"source_extension":"epub"},"isbns":["0201310058","0201548550","1430210451","9780201310054","9780201548556","9781430210450"],"publisher":"iBooker it-ebooks","series":"it-ebooks-extra"}
元数据中的注释
Includes bibliographical references and index.
元数据中的注释
Includes bibliographical references (p. 233-237) and indexes.
元数据中的注释
topic: C₊₊ (Computer program language)
元数据中的注释
Type: 英文图书
元数据中的注释
Bookmarks:
1. (p1) Preface
2. (p2) Contents
3. (p3) Chapter 1: Introduction
3.1. (p4) 1.1 C++: An Evolving Language
3.2. (p5) 1.2 Handling Complexity with Idioms
3.3. (p6) 1.3 Objects for the Nineties
3.4. (p7) 1.4 Design and Language
3.5. (p8) References
4. (p9) Chapter 2: Data Abstraction and Abstract Data Types
4.1. (p10) 2.1 Classes
4.2. (p11) 2.2 Object Inversion
4.3. (p12) 2.3 Constructors and Destructors
4.4. (p13) 2.4 Inline Functions
4.5. (p14) 2.5 Initialization of Static Data Members
4.6. (p15) 2.6 Static Member Functions
4.7. (p16) 2.7 Scoping and const
4.8. (p17) 2.8 Initialization Ordering of Global Objects, Constants, and Static Class Members
4.9. (p18) 2.9 Enforcement of const for Class Object Member Functions
4.10. (p19) 2.10 Pointers to Member Functions
4.11. (p20) 2.11 Program Organization Conventions
4.12. (p21) Exercises
4.13. (p22) References
5. (p23) Chapter 3: Concrete Data Types
5.1. (p24) 3.1 The Orthodox Canonical Class Form
5.2. (p25) 3.2 Scoping and Access Control
5.3. (p26) 3.3 Overloading: Redefining the Semantics of Operators and Functions
5.4. (p27) 3.4 Type Conversion
5.5. (p28) 3.5 Reference Counting: Making Variables Use "Magic Memory"
5.6. (p29) 3.6 Operators new and delete
5.7. (p30) 3.7 Separating Initialization from Instantiation
5.8. (p31) Exercises
5.9. (p32) References
6. (p33) Chapter 4: Inheritance
6.1. (p34) 4.1 Simple Inheritance
6.2. (p35) 4.2 Scoping and Access Control
6.3. (p36) 4.3 Constructors and Destructors
6.4. (p37) 4.4 Class Pointer Conversion
6.5. (p38) 4.5 Type Selector Fields
6.6. (p39) Exercises
6.7. (p40) References
7. (p41) Chapter 5: Object-Oriented Programming
7.1. (p42) 5.1 C++ Run-Time Type Support: Virtual Functions
7.2. (p43) 5.2 Destructor Interaction and Virtual Destructors
7.3. (p44) 5.3 Virtual Functions and Scoping
7.4. (p45) 5.4 Pure Virtual Functions and Abstract Base Classes
7.5. (p46) 5.5 Envelope and Letter Classes
7.6. (p47) 5.6 Functors: Functions as Objects
7.7. (p48) 5.7 Multiple Inheritance
7.8. (p49) 5.8 The Inheritance Canonical Form
7.9. (p50) Exercises
7.10. (p51) Queue Iterator Example
7.11. (p52) Simple Banking Account Application Classes
7.12. (p53) References
8. (p54) Chapter 6: Object-Oriented Design
8.1. (p55) 6.1 Types and Classes
8.2. (p56) 6.2 The Activities of Object-Oriented Design
8.3. (p57) 6.3 Object-Oriented Analysis and Domain Analysis
8.4. (p58) 6.4 Object and Class Relationships
8.5. (p59) 6.5 Subtyping, Inheritance, and Forwarding
8.6. (p60) 6.6 Rules of Thumb for Subtyping, Inheritance, and Independence
8.7. (p61) Exercises
8.8. (p62) References
9. (p63) Chapter 7: Reuse and Objects
9.1. (p64) 7.1 All Analogies Break Down Somewhere
9.2. (p65) 7.2 Design Reuse
9.3. (p66) 7.3 Four Code Reuse Mechanisms
9.4. (p67) 7.4 Parameterized Types, or Templates
9.5. (p68) 7.5 Private Inheritance: Does Inheritance Support Reuse?
9.6. (p69) 7.6 Storage Reuse
9.7. (p70) 7.7 Interface Reuse: Variants
9.8. (p71) 7.8 Reuse, Inheritance, and Forwarding
9.9. (p72) 7.9 Architectural Alternatives for Source Reuse
9.10. (p73) 7.10 Generalizations on Reuse and Objects
9.11. (p74) Exercises
9.12. (p75) References
10. (p76) Chapter 8: Programming with Exemplars in C++
10.1. (p77) 8.1 An Example: Employee Exemplars
10.2. (p78) 8.2 Exemplars and Generic Constructors: The Exemplar Community Idiom
10.3. (p79) 8.3 Autonomous Generic Constructors
10.4. (p80) 8.4 Abstract Base Exemplars
10.5. (p81) 8.5 Toward a Frame Exemplar Idiom
10.6. (p82) 8.6 A Word About Notation
10.7. (p83) 8.7 Exemplars and Program Administration
10.8. (p84) Exercises
10.9. (p85) Exemplar-Based Simple Parser
10.10. (p86) Frame-Based Exemplars
10.11. (p87) References
11. (p88) Chapter 9: Emulating Symbolic Language Styles in C++
12. (p98) Chapter 10: Dynamic Multiple Inheritance
13. (p101) Chapter 11: Systemic Issues
14. (p105) Appendix A: C in a C++ Environment
15. (p116) Appendix B: Shapes Program: C++ Code
16. (p117) Appendix C: Reference Return Values from Operators
17. (p118) Appendix D: Why Bitwise Copy Doesn't Work
18. (p120) Appendix E: Symbolic Shapes
19. (p121) Appendix F: Block-Structured Programming in C++
20. (p129) Index
元数据中的注释
theme: C₊₊ (Computer program language)
元数据中的注释
topic: Java (Computer program language)
元数据中的注释
Bookmarks:
1. (p1) Foreword
2. (p2) Preface
3. (p3) Acknowledgments
4. (p4) 1 Introduction
5. (p5) 2 Creating and Destroying Objects
5.1. (p6) Item 1: Consider providing static factory methods instead of constructors
5.2. (p7) Item 2: Enforce the singleton property with a private constructor
5.3. (p8) Item 3: Enforce noninstantiability with a private constructor
5.4. (p9) Item 4: Avoid creating duplicate objects
5.5. (p10) Item 5: Eliminate obsolete object references
5.6. (p11) Item 6: Avoid finalizers
6. (p12) 3 Methods Common to All Objects
6.1. (p13) Item 7: Obey the general contract when overriding equal s
6.2. (p14) Item 8: Always override has hCode when you override equal s
6.3. (p15) Item 9: Always override toSt ri ng
6.4. (p16) Item 10: Override cl one judiciously
6.5. (p17) Item 11: Consider implementing Comparabl e
7. (p18) 4 Classes and Interfaces
7.1. (p19) Item 12: Minimize the accessibility of classes and members
7.2. (p20) Item 13: Favor immutability
7.3. (p21) Item 14: Favor composition over inheritance
7.4. (p22) Item 15: Design and document for inheritance or else prohibit it
7.5. (p23) Item 16: Prefer interfaces to abstract classes
7.6. (p24) Item 17: Use interfaces only to define types
7.7. (p25) Item 18: Favor static member classes over nonstatic
7.8. (p26) 5 Substitutes for C Constructs
7.9. (p27) Item 19: Replace structures with classes
7.10. (p28) Item 20: Replace unions with class hierarchies
7.11. (p29) Item 21: Replace enum constructs with classes
7.12. (p30) Item 22: Replace function pointers with classes and interfaces
8. (p31) 6 Methods
8.1. (p32) Item 23: Check parameters for validity
8.2. (p33) Item 24: Make defensive copies when needed
8.3. (p34) Item 25: Design method signatures carefully
8.4. (p35) Item 26: Use overloading judiciously
8.5. (p36) Item 27: Return zero-length arrays, not nulls
8.6. (p37) Item 28: Write doc comments for all exposed API elements
9. (p38) 7 General Programming
9.1. (p39) Item 29: Minimize the scope of local variables
9.2. (p40) Item 30: Know and use the libraries
9.3. (p41) Item 31: Avoid fl oat and double if exact answers are required
9.4. (p42) Item 32: Avoid strings where other types are more appropriate
9.5. (p43) Item 33: Beware the performance of string concatenation
9.6. (p44) Item 34: Refer to objects by their interfaces
9.7. (p45) Item 35: Prefer interfaces to reflection
9.8. (p46) Item 36: Use native methods judiciously
9.9. (p47) Item 37: Optimize judiciously
9.10. (p48) Item 38: Adhere to generally accepted naming conventions
10. (p49) 8 Exceptions
10.1. (p50) Item 39: Use exceptions only for exceptional conditions
10.2. (p51) Item 40: Use checked exceptions for recoverable conditions and run-time exceptions for programming errors
10.3. (p52) Item 41: Avoid unnecessary use of checked exceptions
10.4. (p53) Item 42: Favor the use of standard exceptions
10.5. (p54) Item 43: Throw exceptions appropriate to the abstraction
10.6. (p55) Item 44: Document all exceptions thrown by each method
10.7. (p56) Item 45: Include failure-capture information in detail messages
10.8. (p57) Item 46: Strive for failure atomicity
10.9. (p58) Item 47: Don't ignore exceptions
11. (p59) 9 Threads
12. (p66) 10 Serialization
13. (p71) References
14. (p72) Index of Patterns and Idioms
15. (p73) Index
元数据中的注释
theme: Java (Computer program language)
备用描述
<p><p> <ul><li>recipient Of Computer Language 1991 Jolt Cola Productivity Award <li>one Of Joop Magazine's Top Ten Books Of The Decade (three Years In A Row) <li>a 1992 Stacey's Best-seller <li>continued Critical Acclaim In October 1995 Dr. Dobb's </ul> <p>written By An Expert In C++, Advanced C++ Programming Styles And Idioms Looks At The Design Features Of The C++ Programming Language. Assuming A Background In The Syntax Of C++, Coplien Shows How To Become An Expert C++ Programmer By Learning The Idioms Of The Language. His Approach Is Organized Around The Abstractions That C++ Supports&#58; Abstract Data Types, Combining Types In Inheritance Structures, Object-oriented Programming, And Multiple Inheritance. Using Small, But Rich Examples, He Shows How These Abstractions Can Be Combined To Use The Language Effectively. Experienced C++ Programmers Will Appreciate The Comprehensive Coverage Of Release 3.0.</p> <h3>booknews</h3> <p>assuming A Background In C++ Basics, This Book Helps Programmers To Develop Their Programming Expertise By Giving A Feel For The Styles And Idioms Of The Language. The Approach Is Organized Around The Abstractions That C++ Supports: Abstract Data Types, Combining Types In Inheritance Structures, Object-oriented Programming, And Multiple Inheritance. Also Explored Are Idioms That The Core Of The C++ Language Does Not Support Directly, Such As Virtual Constructors, Prototype Objects, And Advanced Garbage Collection Techniques. Annotation C. Book News, Inc., Portland, Or (booknews.com)</p>
备用描述
Effective Java is an explicit (and acknowledged) homage to Scott Meyer's Effective C++. Josh Bloch shares the programming practices of the most expert Java programmers with the rest of the programming community. Distilling the habits of experienced programmers into 50 short stand-alone essays, Bloch has laid out the most essential and effective Java rules, providing comprehensive descriptions of techniques. The essays address practical problems that all Java programmers encounter, presents specific ways to improve programs and designs, and also shows how to avoid traps in Java programming. An enormously useful book, each essay contains top notch code examples and insightful "war stories" that help capture the students' attention
备用描述
A textbook for a graduate or advanced undergraduate course in neural networks for computer-science or engineering students. Presumes the standard calculus, differential equations, and advanced mathematics acquired in the first three years of an engineering curriculum. Includes models inspired by, but not found by, studies of the brain. Annotation c
备用描述
1. Introduction -- 2. Creating And Destroying Objects -- 3. Methods Common To All Objects -- 4. Classes And Interfaces -- 5. Substitutes For C Constructs -- 6. Methods -- 7. General Programming -- 8. Exceptions -- 9. Threads -- 10. Serialization. Joshua Bloch ; [foreword By Guy Steele]. Includes Bibliographical References (p. 233-237) And Indexes.
备用描述
Offers instructions for working with the Groovy programming language and the Grails Web framework, covering such topics as building a user interface, security, Web 2.0, reporting, batch processing, and deploying and upgrading applications.
备用描述
A new edition of this title is available, ISBN-10: 0321356683 ISBN-13: 9780321356680
备用描述
Keine Beschreibung vorhanden.
Erscheinungsdatum: 23.06.2008
开源日期
2022-08-24
更多信息……

🚀 快速下载

成为会员以支持书籍、论文等的长期保存。为了感谢您对我们的支持，您将获得高速下载权益。❤️

🐢 低速下载

由可信的合作方提供。 更多信息请参见常见问题解答。 （可能需要验证浏览器——无限次下载！）

所有选项下载的文件都相同，应该可以安全使用。即使这样，从互联网下载文件时始终要小心。例如，确保您的设备更新及时。
显示外部下载
  • 对于大文件，我们建议使用下载管理器以防止中断。
    推荐的下载管理器：Motrix
  • 您将需要一个电子书或 PDF 阅读器来打开文件，具体取决于文件格式。
    推荐的电子书阅读器：Anna的档案在线查看器、ReadEra和Calibre
  • 使用在线工具进行格式转换。
    推荐的转换工具：CloudConvert和PrintFriendly
  • 您可以将 PDF 和 EPUB 文件发送到您的 Kindle 或 Kobo 电子阅读器。
    推荐的工具：亚马逊的“发送到 Kindle”和djazz 的“发送到 Kobo/Kindle”
  • 支持作者和图书馆
    ✍️ 如果您喜欢这个并且能够负担得起，请考虑购买原版，或直接支持作者。
    📚 如果您当地的图书馆有这本书，请考虑在那里免费借阅。