Scala for the Impatient

Name: Scala for the Impatient
Author: Cay Horstmann
ISBN: 978-0-13-454064-1

Cay Horstmann(Autor*in)

Addison Wesley (Verlag)

2. Auflage

Erschienen am 28. Dezember 2016

384 Seiten

E-Book

PDF mit Wasserzeichen-DRM

Systemvoraussetzungen

978-0-13-454064-1 (ISBN)

0,00 €inkl. 7% MwSt.

Systemvoraussetzungen

für PDF mit Wasserzeichen-DRM

E-Book Einzellizenz

Als Download verfügbar

Beschreibung

Interest in the Scala programming language continues to grow for many reasons. Scala embraces the functional programming style without abandoning the object-oriented paradigm, and it allows you to write programs more concisely than in Java. Because Scala runs on the JVM, it can access any Java library and is interoperable with familiar Java frameworks. Scala also makes it easier to leverage the full power of concurrency.

Written for experienced Java, C++, or C# programmers who are new to Scala or functional programming, Scala for the Impatient, Second Edition, introduces the key Scala concepts and techniques you need in order to be productive quickly. It is the perfect introduction to the language, particularly for impatient readers who want to learn the fundamentals of Scala so they can start coding quickly. It doesn't attempt to exhaustively list all the features of the language or make you suffer through long and contrived examples. Instead, carefully crafted examples and hands-on activities guide you through well-defined stages of competency, from basic to expert.

This revised edition has been thoroughly updated for Scala 2.12 and reflects current Scala usage. It includes added coverage of recent Scala features, including string interpolation, dynamic invocation, implicit classes, and futures. Scala is a big language, but you can use it effectively without knowing all of its details intimately. This title provides precisely the information that you need to get started in compact, easy-to-understand chunks.

Get started quickly with Scala's interpreter, syntax, tools, and unique idioms
Master core language features: functions, arrays, maps, tuples, packages, imports, exception handling, and more
Become familiar with object-oriented programming in Scala: classes, inheritance, and traits
Use Scala for real-world programming tasks: working with files, regular expressions, and XML
Work with higher-order functions and the powerful Scala collections library
Leverage Scala's powerful pattern matching and case classes
Create concurrent programs with Scala futures
Implement domain-specific languages
Understand the Scala type system
Apply advanced "power tools," such as annotations, implicits, and type classes

Register your product at informit.com/register for convenient access to downloads, updates, and corrections as they become available.

Weitere Details

Weitere Ausgaben

Person

Inhalt

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

Systemvoraussetzungen

Als PDF speichern Als Link merken