初识Scala编程：面向对象与函数式编程结合的魅力

需积分: 6 172 浏览量更新于2024-07-17 收藏 2.57MB PDF 举报

"essential-scala.pdf" 《Essential Scala》是一本专为首次接触Scala的有经验开发者编写的指南。本书旨在帮助读者利用他们已有的编程技能掌握Scala这门结合了面向对象和函数式编程特点的语言。书中内容涵盖了一系列关键主题，从安装Scala环境开始，逐步引导读者进入Scala的世界。首先，作者Noel Welsh和Dave Gurnell介绍了如何设置Scala的开发环境，包括启动Scala Console和配置Scala IDE，这对于任何新语言的学习都是至关重要的第一步。在深入探讨编程基础时，书中详细讲解了表达式、类型和值的概念。表达式在Scala中是计算的基本单元，而类型系统则确保了代码的安全性。理解Scala中的值（如常量和变量）及其与表达式的交互，是编写正确无误代码的基础。接下来，读者将学习Scala的类和对象，这是其面向对象特性的核心。Scala的类可以包含数据和行为，而对象则可以作为单例，提供全局访问点。此外，函数式编程的特性，如高阶函数、不可变数据结构和模式匹配，也将被逐一介绍。这些特性使得Scala在处理复杂逻辑和并发问题时尤为高效。函数式编程的另一个重要方面是递归，书中的章节会解释如何在Scala中定义和使用递归函数，以及如何避免常见的陷阱，如无限循环。另外，Scala的类型推断机制简化了类型声明，但同时也需要理解其工作原理，以避免可能的混淆。除此之外，书中的其他章节还将讨论集合库、异常处理、模块化设计以及Scala与其他Java平台技术（如JVM和Akka）的集成。Scala的宏（Macro）和元编程能力也将得到讨论，这使得Scala能够进行更高级的代码生成和优化。最后，书中还会介绍测试和调试Scala代码的方法，这对于保证软件质量至关重要。通过学习本书，开发者不仅能够理解Scala的基本概念，还能掌握编写高效、可维护的Scala代码的技巧。《Essential Scala》是一本全面而实用的教程，对于希望深入了解并掌握Scala这一强大编程语言的专业人士来说，是一份不可或缺的资源。

16 CHAPTER 1. GETTING STARTED

Create your ﬁrst Scala Worksheet by selecng the File Menu and choosing New > Scala Worksheet:

Enter a Worksheet name of FirstSteps and click Finish. A new ﬁle called FirstSteps.sc should appear in

the tree view on the le of the main window, and should open it in the main editor in the middle:

Note that the object on the le contains a single line of Scala code:

println("Welcome to the Scala worksheet")

for which Eclipse is displaying the corresponding output on the right:

Welcome to the Scala worksheet

Chapter 2

Expressions, Types, and Values

In this chapter we look at the fundamental building blocks of Scala programs: expressions, types, and values.

Understanding these concepts is necessary to build a mental model of how Scala programs work.

2.1 Your First Program

In the Scala console or worksheet enter "Hello world!" and press return (in the console) or save the work-

sheet. You should see an interacon similar to this:

"Hello world!"

// res: String = Hello world!

There is a lot to say about this program. It consists of a single expression, and in parcular a literal expression or

literal for short.

Scala runs, or evaluates, our program. When we evaluate a program in the Scala console or worksheet we are

told two pieces of informaon: the type of the program, and the value it evaluates to. In this case the type is

String and the value is "Hello world!".

Although the output value “Hello world!” looks the same as the program that created it, there is a diﬀerence

between the two. The literal expression is the program text we entered, while what the console prints is the

result of evaluang that program. (Literals are so-named because they literally look like what they evaluate to.)

Let’s look at a slightly more complex program

"Hello world!".toUpperCase

// res: String = HELLO WORLD!

This program extends our ﬁrst example by adding a method call. Evaluaon in Scala proceeds le to right. First

the literal "Hello world!" is evaluated, as in the ﬁrst example. Then the method toUpperCase is called on

the result. This method transforms a string value to its upper case equivalent and returns this new string. This

is the ﬁnal value we see printed by the console.

Once again the type of this program is String, but in this case it evaluates to "HELLO WORLD!"

2.1.1 Compile-me and Run-me

There are two disnct stages that a Scala program goes through: ﬁrst it is compiled, and if it compiles successfully

it can then be run or evaluated. We refer to the ﬁrst stage as compile-me and the laer as run-me.

20 CHAPTER 2. EXPRESSIONS, TYPES, AND VALUES

When using the Scala console our programs are evaluated as soon as they compile, which gives the appearance

that there is only one stage. It is important to understand that compile- and run-me really are disnct, as it is

this disncon that allows us to properly understand the diﬀerence between types and values.

Compilaon is a process of checking that a program makes sense. There are two ways in which a program must

“make sense”:

1. It must be syntaccally correct, meaning the parts of the program must be arranged according to the

grammar of the language. An example English sentence that is not syntaccally correct is “on cat mat sat

the”. An example syntaccally incorrect Scala program is

toUpperCase."Hello world!"

// error: identifier expected but string literal found.

// toUpperCase."Hello world!"

// ^

2. It must type check, meaning it must obey certain constraints on what a sensible program is. An example

English sentence that is syntaccally correct but fails to make sense is “the mat sat on the cat”. A simple

program that would fail to type check is trying to convert a number to uppercase.

2.toUpperCase

// error: value toUpperCase is not a member of Int

// 2.toUpperCase

// ^

The concept of upper and lowercase doesn’t make sense for numbers, and the type system will catch this error.

If a program passes the checks at compile-me it may then be run. This is the process of the computer per-

forming the instrucons in the program.

Even though a program successfully compiles it can sll fail at run-me. Dividing an integer by zero causes a

run-me error in Scala.

2 / 0

// java.lang.ArithmeticException: / by zero

The type of integers, Int, allows division so the program type checks. At run-me the program fails because

there is no Int that can represent the result of the division.

2.1.2 Expressions, Types, and Values

So what exactly are expressions, types, and values?

Expressions are part of a program’s text—what we type into a ﬁle, or the console or worksheet. They are the

main components of a Scala program. We will see other components, namely deﬁnions and statements, in due

course. Expressions exist at compile-me.

The deﬁning characterisc of an expression is that it evaluates to a value. A value is informaon stored in the

computer’s memory. It exists at run-me. For example, the expression 2 evaluates to a parcular sequence of

bits in a parcular locaon in the computer’s memory.

We compute with values. They are enes that our programs can pass around and manipulate. For example,

to compute the minimum of two numbers we might write a program like

剩余244页未读，继续阅读

macsehai

粉丝: 0

初识Scala编程：面向对象与函数式编程结合的魅力

jackson-module-scala_2.11-2.6.7.1-API文档-中英对照版.zip

flink-1.19.0-bin-scala-2.12.tgz flink-1.16.3-bin-scala-2.12.tgz

scala-2.12.14.zip&scala-2.12.11.tgz Linux版本压缩包.rar

Programming-in-Scala-2nd.pdf

beginners-guide-to-scala.pdf

Learning-Scala-Practical-Functional-Programming-for-the-JVM.pdf

rh-scala210-scala-2.10.6-2.4.el7.noarch.rpm

rh-scala210-ant-scala-2.10.6-2.4.el7.noarch.rpm

scalatest-1.0.1-for-scala-2.8.0.Beta1-NQRFPT.jar

rh-scala210-scala-apidoc-2.10.6-2.4.el7.noarch.rpm

最新资源