61c02dc478e51a0828eaa771d4f943ccde528cc2.jpg

Scala 开发教程.jpg

Scala 基础

• 定义变量

# 字符串常变量
val girl = "诸叶"
# 字符串变量
var weapon = "俱利伽罗丸"

• 定义函数

# 有返回值
def transform(rouge:Boolean) : String ={if (rouge) "崩国的红夜叉"
else"无变化"
}
# 无返回值
def skill() = println("红龙破")

• 判断

var modern = true
val current = if (modern) "现代" else "战国时代"

• 循环

# while
val girls = Array("永远","刹那","诸叶")
var i = 0
while (i < 3) {println(girls(i))i += 1
}
# for
for (girl <- girls)println(girl)
# foreach
girls.foreach(println)

• 数组

val weapons = Array("菊十文字","兼光之巴","俱利伽罗丸")
for(i <- 0 to 2)print(weapons(i))

• 列表

# 定义
val pearls = List("银色珍珠","金色珍珠","红色珍珠")
# 打印
print(pearls)
# 取List的首元素
pearls.head
# 判断List是否为空
pearls.isEmpty
# 取除首元素之外的List的其它元素
pearls.tail
# 逆转List中元素的顺序
pearls.reverse
# 返回除前1个元素的List余下的元素
pearls drop 1
# 返回List的前1个元素
pearls take 1
# 把一个List在指定位置分成两个List
pearls splitAt 1
# 展开List
pearls.flatten
# zip
pearls.indices zip pearls
pearls zip List(1,2,3)
# unzip
pearls.zipWithIndex.unzip
# 显示List的正规字符表示
pearls.toString
# 格式化List显示
pearls.mkString
# map
pearls map(_+"x1")
pearls map(_.length)
# flatMap
pearls flatMap(_.toList)
# 过滤List
pearls filter (_=="银色珍珠")

• 元组

val fathers = ("杀生丸","犬夜叉")
print(fathers._1)

• 集合

# Set
var girls = Set ("诸叶","刹那")
girls += "永远"
print(girls.contains("芽衣"))
# Map
val weapons = Map( "永远" -> "菊十文字","刹那" -> "兼光之巴","诸叶" -> "俱利伽罗丸")
print(weapons("永远"))

• 读取文件

import scala.io.Source
var file_content = Source.fromFile(文件路径)

• 异常处理

import java.io.FileReader
import java.io.FileNotFoundException
import java.io.IOException
try {val f = new FileReader(文件路径)
} catch {# 处理不存在的文件case ex: FileNotFoundException =># 处理IO错误case ex: IOException =>
}

类和对象

• 类

# 定义
class Weapon (w1:String, w2:String, w3:String) {print(w1+"\n"+w2+"\n"+w3)
}
# 调用
new Weapon("菊十文字", "兼光之巴", "俱利伽罗丸")

• 对象

# 定义
object Pearl {print("七彩珍珠")
}
# 调用
Pearl

• toString

# 定义
class Weapon (w1:String, w2:String, w3:String) {override def toString = w1+"\n"+w2+"\n"+w3
}
# 调用
new Weapon("菊十文字", "兼光之巴", "俱利伽罗丸")

• require

# 定义
class RedPearl (color:String) {require(color == "红色")override def toString = "红色珍珠"
}
# 调用
new RedPearl("红色")

• 成员变量

# 定义
class Pearl (c:String) {val color = coverride def toString = c+"珍珠"
}
# 调用
val p = new Pearl("金色")
p.color

• 私有成员变量

# 定义
class Pearl (c:String) {# 不能被访问private val color = coverride def toString = c+"珍珠"
}
# 调用
new Pearl("银色")

• 辅助构造函数

# 定义
class Pearl (p:String, n:String) {override def toString = p+"x"+ndef this(p:String) = this(p, "1")
}
# 调用
new Pearl("银色珍珠")

• 私有成员方法

# 定义
class Girl (name:String) {val pearl = getPearl(name)override def toString = pearlprivate def getPearl(name:String):String =if (name == "永远") {"银色珍珠"} else if (name == "刹那") {"金色珍珠"} else if (name == "诸叶") {"红色珍珠"} else {"未知"}
}
# 调用
new Girl("永远")

• 隐式参数

# 定义
class GoldPearl (implicit n:Int) {override def toString = "红色珍珠x"+n
}
# 调用
implicit val n = 1
new GoldPearl()

函数

• 成员函数

# 定义
import scala.io.Source
object Girl {def weapon(w:String) {skill(w)}private def skill(w:String){print(w+"-旋风阵")}
}
# 调用
Girl.weapon("兼光之巴")

• 局部函数

# 定义
import scala.io.Source
object Girl {def weapon(w:String) {def skill(){print(w+"-旋风阵")}skill()}
}
# 调用
Girl.weapon("兼光之巴")

• 函数字面量

val skills = (_:String )+"+"+(_:String)
skills("旋风阵", "红龙破")

• 闭包函数

# 定义
def attack(weapon:String) = (skill:String) => weapon+"-"+skill
# 调用
val attack1 = attack("兼光之巴")
attack1("旋风阵")
val attack2 = attack("俱利伽罗丸")
attack2("红龙破")

• 重复参数

# 定义
def attack(skills:String *) = for (skill <- skills) println(skill)
# 调用
attack("旋风阵", "破魔之箭")

• 命名参数

# 定义
def attack(weapon:String, skill:String) :String = weapon+"-"+skill
# 调用
attack(weapon="兼光之巴", skill="旋风阵")

• 缺省参数

# 定义
def attack(weapon:String="兼光之巴", skill:String="旋风阵") :String = weapon+"-"+skill
# 调用
attack(skill="宿蛾之月")

• 递归函数

def travel(times:Int):Int = {if (times == 0)0elsetravel(times-1)
}

• 柯里化函数

# 定义
def attack(weapon:String)(skill:String) = weapon+"-"+skill
# 调用
attack("兼光之巴")("宿蛾之月")

• 传名参数

def travel(times:()=>Int) =if(times() > 0)print("可以穿越")
travel(()=>1)

组合和继承

• 抽象类

abstract class Weapon {def skills: Array[String]val count = skills.length
}

• 扩展类

# 定义
class Sword(s: Array[String]) extends Weapon {def skills: Array[String] = s
}
# 调用
val s = new Sword(Array("宿蛾之月","旋风阵"))
s.skills
s.count

• 参数化成员变量

# 定义
class Sword(val skills: Array[String]) extends Weapon {}
# 调用
val s = new Sword(Array("红龙破"))
s.skills
s.count

• 修饰参数化成员变量

# 定义
class Pearl {val color = "colorless"
}
class RedPearl (override val color: String,private val master: String
) extends Pearl
val rp = new RedPearl("red","诸叶")
# 调用
rp.color
rp.master // 不能访问

• 多态和动态绑定

# 定义
abstract class Weapon {def create() {println("制造武器")}
}
class Sword extends Weapon {override def create() {println("制造刀")}
}
class Spear extends Weapon
# 调用
val s = new Sword
s.create
val s = new Spear
s.create

• final 修饰类成员

abstract class Weapon {final def create() {println("制造武器")}
}

• final 修饰类

final abstract class Weapon {def create() {println("制造武器")}
}

Trait

• 定义 trait

trait attack {def skill() {println("技能")}
}

• 类混合 trait

# 定义
trait attack {def skill() {println("苍龙破")}
}
class Weapon {}
class Sword extends Weapon with attack{override def toString = "菊十文字"
}
# 调用
val s = new Sword
s.skill

包

• package

package backpack {package study {class Student {var hb = new HistoryBook}class HistoryBook}class Bicycle {val s = new study.Student}class Classmates {class Classmate {def addBicycle() {new Bicycle}}}
}

• import

package backpack
abstract class Pearl(val name: String,val color:String
)
object Pearls{object RedPearl extends Pearl("RedPearl","red")object SliverPearl extends Pearl("SliverPearl","sliver")object GoldPearl extends Pearl("GoldPearl","gold")val all = List(RedPearl,SliverPearl,GoldPearl)
}
// 导入Pearl对象
import backpack.Pear
// 导入backpack的所有成员
import backpack._
// 导入backpack中Pearl对象的所有成员
import backpack.Pearl._
// 隐藏Pearl对象中的GoldPearl
import backpack.Pearl.{GoldPearl}
// 重命名对象
import backpack.Pearl.{GoldPearl => YellowPearl}
// 重命名包
import backpack.{Pearl => P}

访问修饰符

• private

class Modern {class Home {private def travel(){println("穿越")}class Tree {travel() // 可以访问}}(new Home).travel() // 不能访问
}

• protected

class Ancient{class Tree {protected def travel() {println("穿越")}}class Well extends Tree{travel() // 可以访问}class Foreast{(new Tree).travel() // 不能访问}
}