[Scala] 学习Scala 语言
--------------------------------------------------------------------------
1
介绍
-----
Scala 是一种支持函数式编程风格与面向对象编程风格的静态类型语言.它基于JVM运行, 最终编译为Java字节码.因此对JAVA程序员非常易于掌握.
2
Scala VS Java
--------------
全面对象化的类型系统
Any - AnyVal (Unit, Boolean Byte Char Short Int Long Float Double)
- AnyRef (Option, Some, None, ..)
PS:
Scala 的 String 使用java.lang.String, 即支持Java类型系统.
Scala 的 Unit 相当于 Java的 void.
Scala 新增加: None, Some, Option.
至此,类型系统全面对象化.
3
简化的 for 语句
for (i <- 0 to 4) println(i) // loop 5 times(0-4)
for (i <- 0 until 4) println(i) // loop 4 times(0-3)
for (c <- "hello") print(c) // h e l l o
for (a <- List(1,2,3)) print(a) // 1 2 3
简化的 嵌套 for 语句
for(i <- 1 until 4 ; j <- 1 to 3) print(i,j)
// 1,1 1,2 1,3, 2,1 2,2 2,3 3,1, 3,2, 3,3
带条件的 for 语句
for ( a <- List(1,2,3) if a > 1) print(a)
4
函数(方法/字段)定义 def
val a:Int = 0 // 常量
var i:Int = 0 // 变量
def max(x: Int, y: Int): Int = {
if (x > y) x
else y
}
max(1, 2) // 2
4
类定义, 接口, 继承,组合
trait Drawable {
def render() = {
// ...
}
}
class Point(val x:Int,val y:Int) extends Any with Drawable{
def +(p:Point):Point = {
new Point(x + p.x,y + p.y)
}
def render() = {
}
}
case class Circle(val x:Int,val y:Int, val r:Int) extends Point(x, y) with Drawable {
override def +(r:Circle):Circle = {
Nothing
}
override def render() = {
}
}
val p1 = new Point(1, 1)
val p2 = new Point(2, 2)
val p3 = p1.+(p2)
// or like this "DSLs", 这样非常好理解.
val p4 = p1 + p2 // 只有一个参数才能这样写
case 类定义
sealed class HttpMethod {
case class Get
case class Post
case class Put
case class Head
case class Delete
}
match {
case Get =>
case Post =>
case Put =>
case Head =>
case Delete =>
case _ => None
}
PS: 注意构造参数使用的是: val; case 类不需要new,因为编译器会生成工厂方法来创建对象且会重写 hashcode, equals方法用于模式匹配.
5
val vs var vs const
val 相当于常量, var 相当于变量, const 常数.
6
pattern match
模式匹配与 match 语句
def decode(n:Int){
println(n match {
case 1 => "One"
case 2 => "Two"
case 5 => "Five"
case _ => "Error"
}
)
}
decode(1) // One
decode(3) // Error
PS: match 没有穿透问题, 避免了潜在的缺陷. 模式匹配支持字符串, case类, 常量, 集合.
_ 通配符
_* 匹配0-N个集合元素
* 匹配0-N个
7
类型推断
自动默认类型推断,同JAVA规则
val i = 3;
i 推断为 Int.
当推断有多种选择时,也可以显式指明
val i:Short = 3; // Short
val j:Int = 3; // Int
8
一切皆是对象
函数也是对象, 也可以作为参数传递, 返回值, 变量引用.
def sqrt(x:Int) = x * x
等价于
Function1(A,B)
等价于
apply(A):B
匿名函数
(x:Int) = x * x
高阶函数
def sum(f:Int=>Int, a:Int, b:Int):Int = {
if (a > b) 0
else f(a) + sum(f(a+1), a+1, b)
}
sum((x:Int) => x * x, 1, 3) // 14
曲里化
def sum(f:Int=>Int)(a:=>Int)(b:=>Int) = { // a:=>Int 命名参数,Call By Name
if (a > b) 0
else f(a) + sum(f(a+1), a+1, b)
}
(Int=>Int)=>Int=>Int=> { // Int=>Int 第一个函数调用, Int=>Int
if (a > b) 0
else f(a) + sum(f(a+1), a+1, b)
}
val lst=List(1,7,2,8,5,6,3,9,14,12,4,10) // lst 常量引用一个List对象
9
强大的泛型 [T]
编译期决定类型, 不需要强制转换.
[+T] :协变
[-T] :逆变
<: extends // <? extends T>
>: super // <? super T>
方法泛型:
override final def map[B](f : (A) => B) : List[B]
f : (A) => B
这个参数f 类型是一个偏函数, 因为有 =>
(A) : 函数参数列表
偏函数是指一个不完整的函数, 它没有函数名,甚至过参数列表也可以没有.
def f(x):Unit = println(x) // 函数
(x) => println(x) // 偏函数
def f():Unit = println(2+2) // 函数
() => println(2+2) // 偏函数
println(2+2) // 偏函数 或 叫函数字面量, 借贷模式作回调
用．
{ println(2+2) } // 偏函数 或 叫函数字面量, 借贷模式作回调
10
Tuple 元组, 可以包含混合类型元素. 使用 _index 访问（注意要带下划线，与列表不同）,index 从 1 开始. List是从0开始.
(x) // 1元
(x, y) // 2元
(x, y, z) // 3元
(3, 'c')
List
List(1, 2, 3) === Tuple(1, List(2, 3)) // head 1 tail (2,3)
=== Tuple(1, 2, 3)
Map
Map("one" -> 1, "two" -> 2, "three" -> 3)
10
::
:::
List(1,2)::List(3,4) // List(List(1,2), 3, 4)
List(1,2):::List(3,4) // List(1,2, 3, 4)
11
=> pattern match
12
''' 字符串引用
13
`v` 变量
14
包
package cn.bisoft.scala {
const PI = 3.14
class A
class B
class C private
}
import cn.bisoft.scala._
or
import cn.bisoft.scala.{A, B}
or
import cn.bisoft.scala.PI
15
yield
val lst = List(1, 7, 13)
for {i <- lst; j <- lst if isOdd(i * j)} yield i * j
// List(1, 7, 13, 7, 49, 91, 13, 91, 169)
16
Nil 空集合
None
Null
Nothing exception
17
dock type
18
trait 接近于接口,但 trait 可以定义方法体。
scala 可以在一个class实例化的时候织入一个trait.
在scala中，实现trait用extends t1 with t2 with t3 ...
19
actor
来自 erlang 语言的概念, 很强大的东西,很多网页游戏的服务器就是用 erlang 开发的,用于支持高并发.scala 目前的标准实现为 Akka.
import scala.actors.Actor.actor
import scala.actors.Actor.receive
import scala.actors.Actor
object Main {
var count:Long = 0L
val msg1:String = "大兵: 老爷, 他鼻子是自己咬烂的!"
val msg2:String = "奇志: 我何事咬得到我自己的鼻子了!"
val msg3:String = "大兵: 他站凳子上咬烂的!"
val actorQZ:Actor = actor {
while(true) {
receive {
case s:String => {
println(s)
count += 1
actorDB ! count + msg2
}
}
}
}
val actorDB:Actor = actor {
actorQZ ! msg1
while(true) {
receive {
case s:String => {
println(s)
actorQZ ! msg3
}
}
}
}
def main(args: Array[String]) = {
}
}
package base
/**
* 分数
*/
class Rational(cN:Int, cD:Int) {
// -----------------------------------------------------------
/// constructor area
// require(cD != 0) // 先决条件，错误抛出异常
if (cD == 0) throw new IllegalArgumentException("cD must not be 0")
// 最大公约数
lazy val g:Int = gcd(cN.abs, cD.abs)
// 字段，默认私有
lazy val n:Int = cN / g // 分子
lazy val d:Int = cD / g // 分母
//子构造器
def this(cN:Int) = this(cN, 1)
// ----------------------------------------------------------
/// method area
// 重写
override def toString() = if (d.abs == 1) n + "" else n + "/" + d
def +(that:Rational) = new Rational(n * that.d + that.n * d, d * that.d)
def -(that:Rational) = new Rational(n * that.d - that.n * d, d * that.d)
def *(that:Rational) = new Rational(n * that.n, d * that.d)
def /(that:Rational) = new Rational(n * that.d, d * that.n)
// 私有方法,求最大公约数
private[this] def gcd(a:Int, b:Int):Int = if (b == 0) a else gcd(b, a % b)
}
object Rational {
/// 隐式类型转换, 必须定义在伴生对象中
implicit def intToRational(v:Int) = new Rational(v)
def main(args:Array[String]) = {
val r1 = new Rational(1, 5)
println(r1) // 1/5
val r2 = new Rational(8, 9)
println(r2) // 8/9
val r3 = r1 * 2
println(r3) // 2/5
val r4 = 2 * r2
println(r4) //16/9
}
}
分享到：
相关推荐
Scala是一种强大的多范式编程语言，它融合了面向对象和函数式编程的特性，被广泛应用于大数据处理...通过深入学习和实践，你不仅可以掌握Scala语言，还能有效利用Scala在大数据分析和处理项目中发挥出Spark的强大性能。
让我们深入了解一下Scala语言的关键概念和特性。 首先，Scala运行在Java虚拟机（JVM）上，这意味着它可以无缝地与Java库集成，同时也享受到了JVM的高性能和跨平台兼容性。它的语法设计简洁而富有表达力，使得代码...
总的来说，"学习scala好的项目"提供了一个全面的平台，让初学者能够系统地学习Scala语言，并结合Spark进行大数据处理实践。通过这个项目，学习者不仅能掌握Scala的基本语法和概念，还能熟悉Spark框架的应用，从而在...
这个压缩包“scala学习资料（带书签）”提供了一个全面的学习路径，从基础到高级，帮助你深入理解和掌握Scala语言。 **入门篇** 1. **基础语法**：Scala的基础包括变量声明、类型系统、控制结构（如if/else、循环）...
Scala也是一种函数式语言，其函数也能当成值来使用。Scala提供了轻量级的语法用以定义匿名函数，支持高阶函数，允许嵌套多层函数，并支持柯里化 。Scala的Case Class及其内置的模式匹配相当于函数式编程语言中常用的...
### Scala学习笔记(全) #### 一、Scala概述与特点 Scala是一种多范式的编程语言，旨在集成面向对象编程和函数式编程的各种特性。它运行于Java平台（Java虚拟机JVM），并且能够完全兼容所有的Java程序。这使得Scala...
Scala 语言的学习资源： 1. Scala 官方文档：Scala 官方文档提供了详细的语言规范和使用文档。 2. Scala 学习教程：Scala 学习教程提供了详细的学习资源，包括视频、文档和实践项目。 3. Scala 社区：Scala 社区是...
同时，Scala还能无缝集成Java代码，允许开发者利用已有的Java库，降低了学习和迁移成本。 总的来说，Scala是一种旨在解决多核时代编程挑战的现代编程语言，它的强大类型系统、面向对象和函数式编程的融合，以及对...
《Scala语言规范》是理解这种语言的基础，特别是对于那些想要深入学习Apache Spark或其他基于Scala的大数据处理框架的开发者来说，这本书具有极高的价值。 1. **类型系统**：Scala的类型系统是静态的，这意味着在...
首先，Scala语言的官方网站***是学习Scala的起点。这个网站提供了关于Scala语言的最新信息、文档、教程以及API参考。对于初学者来说，官网提供的“Getting Started”指南是学习Scala语法和基础概念的重要资源。通过...
Scala是一种强大的多范式编程语言，它融合了面向对象和函数式编程的特性，由Martin Odersky在2003年设计...通过学习这些内容，开发者可以掌握Scala语言，并能将其应用于各种复杂项目中，实现高效、可靠的软件解决方案。
本教程旨在帮助初学者深入理解Scala语言，并掌握其核心概念和最佳实践。 首先，Scala的基础语法与Java有许多相似之处，因为它们都是基于JVM的语言。然而，Scala引入了许多创新特性，如模式匹配、高阶函数、匿名函数...
《Scala语言核心编程》是尚硅谷教育机构韩顺平老师主讲的一门课程，主要针对Scala这门多范式编程语言进行深入讲解。Scala是一种静态类型的编程语言，它融合了面向对象和函数式编程的概念，设计目标是提供一种简洁、...
这个"scala学习帮助文件"包含了Scala编程的第一发行版，第六版本的详细内容，是学习Scala语言的宝贵资源。 在 Scala 编程中，基础概念包括变量、常量、数据类型（如基本类型Int、Double、String，以及类类型和集合...
Scala语言规范-Scala 是一门类 Java 的编程语言，它结合了面向对象编程和函数式编程。 Scala 是纯面向对象的，每个值都是一个对象，对象的类型和行为由类定义，不同的类可以通过混入(mixin)的方式组合在一起。 Scala...
这个"scala学习-project.zip"压缩包很可能是为了帮助初学者或者开发者深入理解Scala语言而设计的一个实践项目。下面，我们将深入探讨Scala的一些核心概念和关键知识点。 1. **基础语法**：Scala的语法与Java有些...
### Scala学习之路（一）—— 开发环境搭建与首个程序 #### 一、Scala简介 Scala是一种多范式编程语言，旨在实现可扩展性，并融合了面向对象编程和函数式编程的最佳...这些基础对于后续深入学习Scala语言至关重要。
在尚硅谷出版的《大数据之Scala语言核心编程》中，首先介绍了学习Scala语言的原因和Scala语言诞生的小故事。Scala诞生是为了提供一种更加简洁高效的编程方式，能够在同一套系统中处理结构化和非结构化数据。该书中还...