售价: ¥438.88
免运费详情
加入Prime可免运费
此商品不能使用“一键下单”
前翻 后翻
正在播放... 已暂停   您正在聆听的 Audible 音频版本的样品。
了解更多信息
查看全部 2 张图片

Scala for the Impatient (2nd Edition) (英语) 平装 – 2016年12月25日

| 天天低价·正品质优
|
分享
| 自营
广告

显示所有 格式和版本 隐藏其他格式和版本
亚马逊价格
全新品最低价 非全新品最低价
平装
¥438.88
¥438.88
 
退换承诺: 此商品支持7天无理由退货 详情

开学早准备,赶快抢购吧:
精选好书每满100减30元,仅限亚马逊指定自营图书(不含进口原版书、进口繁体中文书、第三方卖家商品、电子书)。 点击查看详情>>

click to open popover

无需Kindle设备,下载免费Kindle阅读软件,即可在您的手机、电脑及平板电脑上畅享阅读。

  • 点击此处下载Kindle iOS阅读软件
    iPhone/iPad/Mac
  • 点击此处下载Kindle Android阅读软件
    Android手机或平板电脑

请输入您的手机号码,获取Kindle阅读软件的下载链接。

kcpAppSendButton


基本信息

  • 出版社: Addison-Wesley Professional; 2 (2016年12月25日)
  • 平装: 384页
  • 语种: 英语
  • ISBN: 0134540565
  • 条形码: 9780134540566
  • 商品尺寸: 17.9 x 2.5 x 23 cm
  • 商品重量: 599 g
  • ASIN: 0134540565
  • 用户评分: 分享我的评价
  • 亚马逊热销商品排名: 图书商品里排第713,954名 (查看图书商品销售排行榜)
  • 您想告诉我们您发现了更低的价格?

商品描述

作者简介

Cay S. Horstmann is principal author of Core Java®, Volumes I & II, Tenth Edition (Prentice Hall), as well as a dozen other books for professional programmers and computer science students. He is a professor of computer science at San Jose State University and a Java Champion.

目录

Foreword to the First Edition xvii

Preface xix

About the Author xxi

 

Chapter 1: The Basics 1

1.1 The Scala Interpreter 1

1.2 Declaring Values and Variables 4

1.3 Commonly Used Types 5

1.4 Arithmetic and Operator Overloading 6

1.5 More about Calling Methods 8

1.6 The apply Method 9

1.7 Scaladoc 10

Exercises 15

 

Chapter 2: Control Structures and Functions 17

2.1 Conditional Expressions 18

2.2 Statement Termination 19

2.3 Block Expressions and Assignments 20

2.4 Input and Output 21

2.5 Loops 22

2.6 Advanced for Loops 24

2.7 Functions 25

2.8 Default and Named Arguments 26

2.9 Variable Arguments 26

2.10 Procedures 28

2.11 Lazy Values 28

2.12 Exceptions 29

Exercises 31

 

Chapter 3: Working with Arrays 35

3.1 Fixed-Length Arrays 35

3.2 Variable-Length Arrays: Array Buffers 36

3.3 Traversing Arrays and Array Buffers 37

3.4 Transforming Arrays 38

3.5 Common Algorithms 40

3.6 Deciphering Scaladoc 41

3.7 Multidimensional Arrays 42

3.8 Interoperating with Java 43

Exercises 44

 

Chapter 4: Maps and Tuples 47

4.1 Constructing a Map 48

4.2 Accessing Map Values 48

4.3 Updating Map Values 49

4.4 Iterating over Maps 50

4.5 Sorted Maps 50

4.6 Interoperating with Java 50

4.7 Tuples 51

4.8 Zipping 52

Exercises 52

 

Chapter 5: Classes 55

5.1 Simple Classes and Parameterless Methods 55

5.2 Properties with Getters and Setters 56

5.3 Properties with Only Getters 59

5.4 Object-Private Fields 60

5.5 Bean Properties 61

5.6 Auxiliary Constructors 62

5.7 The Primary Constructor 63

5.8 Nested Classes 66

Exercises 68

 

Chapter 6: Objects 71

6.1 Singletons 71

6.2 Companion Objects 72

6.3 Objects Extending a Class or Trait 73

6.4 The apply Method 73

6.5 Application Objects 74

6.6 Enumerations 75

Exercises 77

 

Chapter 7: Packages and Imports 79

7.1 Packages 80

7.2 Scope Rules 81

7.3 Chained Package Clauses 83

7.4 Top-of-File Notation 83

7.5 Package Objects 83

7.6 Package Visibility 84

7.7 Imports 85

7.8 Imports Can Be Anywhere 85

7.9 Renaming and Hiding Members 86

7.10 Implicit Imports 86

Exercises 87

 

Chapter 8: Inheritance 91

8.1 Extending a Class 91

8.2 Overriding Methods 92

8.3 Type Checks and Casts 93

8.4 Protected Fields and Methods 94

8.5 Superclass Construction 94

8.6 Overriding Fields 95

8.7 Anonymous Subclasses 97

8.8 Abstract Classes 97

8.9 Abstract Fields 97

8.10 Construction Order and Early Definitions 98

8.11 The Scala Inheritance Hierarchy 100

8.12 Object Equality 102

8.13 Value Classes 103

Exercises 105

 

Chapter 9: Files and Regular Expressions 109

9.1 Reading Lines 109

9.2 Reading Characters 110

9.3 Reading Tokens and Numbers 111

9.4 Reading from URLs and Other Sources 111

9.5 Reading Binary Files 112

9.6 Writing Text Files 112

9.7 Visiting Directories 112

9.8 Serialization 113

9.9 Process Control 114

9.10 Regular Expressions 116

9.11 Regular Expression Groups 117

Exercises 118

 

Chapter 10: Traits 121

10.1 Why No Multiple Inheritance? 121

10.2 Traits as Interfaces 123

10.3 Traits with Concrete Implementations 124

10.4 Objects with Traits 125

10.5 Layered Traits 125

10.6 Overriding Abstract Methods in Traits 127

10.7 Traits for Rich Interfaces 127

10.8 Concrete Fields in Traits 128

10.9 Abstract Fields in Traits 130

10.10 Trait Construction Order 130

10.11 Initializing Trait Fields 132

10.12 Traits Extending Classes 133

10.13 Self Types 134

10.14 What Happens under the Hood 135

Exercises 137

 

Chapter 11: Operators 141

11.1 Identifiers 142

11.2 Infix Operators 143

11.3 Unary Operators 143

11.4 Assignment Operators 144

11.5 Precedence 144

11.6 Associativity 145

11.7 The apply and update Methods 146

11.8 Extractors 147

11.9 Extractors with One or No Arguments 149

11.10 The unapplySeq Method 149

11.11 Dynamic Invocation 150

Exercises 153

 

Chapter 12: Higher-Order Functions 157

12.1 Functions as Values 157

12.2 Anonymous Functions 159

12.3 Functions with Function Parameters 160

12.4 Parameter Inference 160

12.5 Useful Higher-Order Functions 161

12.6 Closures 162

12.7 SAM Conversions 163

12.8 Currying 164

12.9 Control Abstractions 166

12.10 The return Expression 167

Exercises 168

 

Chapter 13: Collections 171

13.1 The Main Collections Traits 172

13.2 Mutable and Immutable Collections 173

13.3 Sequences 174

13.4 Lists 175

13.5 Sets 177

13.6 Operators for Adding or Removing Elements 178

13.7 Common Methods 180

13.8 Mapping a Function 182

13.9 Reducing, Folding, and Scanning 184

13.10 Zipping 187

13.11 Iterators 188

13.12 Streams 189

13.13 Lazy Views 190

13.14 Interoperability with Java Collections 191

13.15 Parallel Collections 193

Exercises 194

 

Chapter 14: Pattern Matching and Case Classes 197

14.1 A Better Switch 198

14.2 Guards 199

14.3 Variables in Patterns 199

14.4 Type Patterns 200

14.5 Matching Arrays, Lists, and Tuples 201

14.6 Extractors 202

14.7 Patterns in Variable Declarations 203

14.8 Patterns in for Expressions 204

14.9 Case Classes 205

14.10 The copy Method and Named Parameters 205

14.11 Infix Notation in case Clauses 206

14.12 Matching Nested Structures 207

14.13 Are Case Classes Evil? 208

14.14 Sealed Classes 209

14.15 Simulating Enumerations 209

14.16 The Option Type 210

14.17 Partial Functions 211

Exercises 212

 

Chapter 15: Annotations 215

15.1 What Are Annotations? 216

15.2 What Can Be Annotated? 216

15.3 Annotation Arguments 217

15.4 Annotation Implementations 218

15.5 Annotations for Java Features 219

15.6 Annotations for Optimizations 222

15.7 Annotations for Errors and Warnings 226

Exercises 227

 

Chapter 16: XML Processing 229

16.1 XML Literals 230

16.2 XML Nodes 230

16.3 Element Attributes 232

16.4 Embedded Expressions 233

16.5 Expressions in Attributes 234

16.6 Uncommon Node Types 235

16.7 XPath-like Expressions 235

16.8 Pattern Matching 237

16.9 Modifying Elements and Attributes 238

16.10 Transforming XML 239

16.11 Loading and Saving 239

16.12 Namespaces 242

Exercises 243

 

Chapter 17: Futures 247

17.1 Running Tasks in the Future 248

17.2 Waiting for Results 250

17.3 The Try Class 251

17.4 Callbacks 251

17.5 Composing Future Tasks 252

17.6 Other Future Transformations 255

17.7 Methods in the Future Object 256

17.8 Promises 258

17.9 Execution Contexts 260

Exercises 260

 

Chapter 18: Type Parameters 265

18.1 Generic Classes 266

18.2 Generic Functions 266

18.3 Bounds for Type Variables 266

18.4 View Bounds 268

18.5 Context Bounds 268

18.6 The ClassTag Context Bound 269

18.7 Multiple Bounds 269

18.8 Type Constraints 269

18.9 Variance 271

18.10 Co- and Contravariant Positions 272

18.11 Objects Can’t Be Generic 274

18.12 Wildcards 275

Exercises 275

 

Chapter 19: Advanced Types 279

19.1 Singleton Types 280

19.2 Type Projections 281

19.3 Paths 282

19.4 Type Aliases 283

19.5 Structural Types 283

19.6 Compound Types 284

19.7 Infix Types 285

19.8 Existential Types 286

19.9 The Scala Type System 287

19.10 Self Types 288

19.11 Dependency Injection 289

19.12 Abstract Types 291

19.13 Family Polymorphism 293

19.14 Higher-Kinded Types 296

Exercises 299

 

Chapter 20: Parsing 303

20.1 Grammars 304

20.2 Combining Parser Operations 305

20.3 Transforming Parser Results 307

20.4 Discarding Tokens 308

20.5 Generating Parse Trees 309

20.6 Avoiding Left Recursion 310

20.7 More Combinators 311

20.8 Avoiding Backtracking 314

20.9 Packrat Parsers 314

20.10 What Exactly Are Parsers? 315

20.11 Regex Parsers 316

20.12 Token-Based Parsers 317

20.13 Error Handling 319

Exercises 320

 

Chapter 21: Implicits 323

21.1 Implicit Conversions 324

21.2 Using Implicits for Enriching Existing Classes 324

21.3 Importing Implicits 325

21.4 Rules for Implicit Conversions 326

21.5 Implicit Parameters 328

21.6 Implicit Conversions with Implicit Parameters 329

21.7 Context Bounds 329

21.8 Type Classes 331

21.9 Evidence 333

21.10 The @implicitNotFound Annotation 334

21.11 CanBuildFrom Demystified 334

Exercises 336

 

Index 338


无顾客评论


评论该商品

与其他买家分享您的想法

此商品在美国亚马逊上最有用的商品评论

美国亚马逊: 3.7 颗星,最多 5 颗星 9 条评论
Kevin D. Peterson
3.0 颗星,最多 5 颗星Good content suffers from poorly executed Kindle version
2017年3月19日 - 已在美国亚马逊上发表
已确认购买
17 个人发现此评论有用.
Maryam M.
5.0 颗星,最多 5 颗星Best book for beginners to learn Scala
2017年8月30日 - 已在美国亚马逊上发表
已确认购买
6 个人发现此评论有用.
Austin
5.0 颗星,最多 5 颗星Great for starting with Scala
2018年9月12日 - 已在美国亚马逊上发表
已确认购买
1 个人发现此评论有用.
Lokesh Majji
2.0 颗星,最多 5 颗星Not good for beginners
2018年7月15日 - 已在美国亚马逊上发表
已确认购买
1 个人发现此评论有用.
D.Hebert
5.0 颗星,最多 5 颗星Five Stars
2018年1月10日 - 已在美国亚马逊上发表
已确认购买