Scala基礎04-方法與函式
阿新 • • 發佈：2020-12-29
- Scala 有方法與函式，二者在語義上的區別很小。Scala 方法是類的一部分，而函式是一個物件可以賦值給一個變數。換句話來說在類中定義的函式即是方法。
- Scala 中的方法跟 Java 的類似，方法是組成類的一部分。
- Scala 中的函式則是一個完整的物件，Scala 中的函式其實就是繼承了 Trait 的類的物件。
- Scala 中使用 val 語句可以定義函式，def 語句定義方法。
目錄
一、傳名呼叫
object 
二、指定引數名
object Appoint{
def appoint(a:Int,b:Int)={
a*a+ b/b
}
def main(args: Array[String]): Unit = {
println(appoint(2, 3))
println(appoint(3, 2))
println(appoint(a=3, b=2))
println(appoint(b=2, a=3))
}
}
三、動態引數
object strings{ 
四、遞迴函式
object res{
def main(args: Array[String]): Unit = {
println(factorial(10))
}
def factorial(n:Int):Int={
if (n<=1){
1
}else{
n*factorial(n-1)
}
}
}
五、內嵌函式
object triangle {
def triangle(rows: Int): Unit = {
def space(row: Int): Unit = {
for (elem <- 1 to rows - row) {
print(" ")
}
}
def star(row: Int): Unit = {
for (elem <- 1 to 2 * row - 1) {
print("*")
}
println()
}
for (elem <- 1 to rows) {
space(elem)
star(elem)
}
}
def main(args: Array[String]): Unit = {
triangle(8)
}
}
六、高階函式（函式呼叫函式）
object higherFunc{
def main(args: Array[String]): Unit = {
println(a(l, 20))//傳入函式l作為a的引數1,20作為a的引數2
}
//a() 函式使用了另外一個函式 f 和 值 v 作為引數，而函式 f 又呼叫了引數 v
def a(f:Int=>String,v:Int)={
f(v)
}
def l[T](x:T):String={
"--"+x.toString+"--"
}
}
object higherFunc2{
def test(x:Int) = println(x)//基礎函式：傳值（或傳函式的呼叫結果），返回值
def add(x:Int*)=x.reduce(_+_)
def test2(x:(Int,Int)=>Int,y:Int*)={
var sum = 0
for (elem <- y) {
sum = x(sum,elem)
}
sum
}
def main(args: Array[String]): Unit = {
test(add(1,2,3,4))
}
println(test2(_-_,1,2,3,4))
}
七、匿名函式
object anonymous1 {
def main(args: Array[String]): Unit = {
var inc = (x: Int) => x + 1
var a = inc(7)*2
println(a)
println(add(7) * 2)
}
def add(x:Int)={
x+1
}
}
八、庫裡化
- 案例1：
object curry{
def main(args: Array[String]): Unit = {
println(add1(2, 3))
println(add2(2))
println(add2(2)(3))
println(add3(2)(3))
}
def add1(x:Int,y:Int):Int={
x+y
}
def add2(x:Int):Int=>Int={
y:Int=>x+y
}
def add3(x:Int)(y:Int):Int={
x+y
}
}
- 案例2：
object curry2{
//返回值一個函式“(Int,Int)=>Int”,呼叫時就會有兩個引數
def func():(Int,Int)=>Int={
(x:Int,y:Int)=>x+y
}
//func()是一個函式名稱，第二個()是引數
//func()
def func2(t:Char):(Int,Int)=>Int={
(x:Int,y:Int)=> t match {
case t if (t=='+')=>x+y
case t if (t=='*')=>x*y
case t if (t=='-')=>x-y
case t if (t=='/')=>x/y
}
}
def main(args: Array[String]): Unit = {
println(func()(2, 3))
println(func2('*')(2, 6))
println(func2('/')(2, 6))
println(func2('+')(2, 6))
println(func2('-')(2, 6))
}
}
九、隱式引數
object yinshicanshu{
def printTriangle(rows:Int)(implicit up:Boolean=true)={
def printSpace(row:Int)={
for (elem <- 1 to (if(up) rows-row else row-1)) {
print(" ")
}
}
def printStar(row:Int)={
// for (elem <- 1 to (if(up) 2*row-1 else 2*rows+1-2*row)) {
for (elem <- 1 to (if(up) (row<<1)-1 else ((rows-row)<<1) -1)) {
print("*")
}
println()
}
for (elem <- 1 to rows) {
printSpace(elem)
printStar(elem)
}
}
def main(args: Array[String]): Unit = {
implicit val up = false
printTriangle(7)(false)
}
}
十、隱式函式
object yinshiFunc{
case class Student(name:String)
object Student{
//隱式函式，放在被轉化函式的伴生物件裡
implicit def toPlayer(stu:Student)={
new Player(stu.name)
}
implicit def toSinger(stu:Student)={
new Singer(stu.name)
}
def show(implicit age:Int)=println(s"my name is $age")
}
class Player(name:String){
def play()=println(s"this is $name,I can play football")
}
class Singer(name:String){
def sing()=println(s"this is $name,I can sing a song")
}
def main(args: Array[String]): Unit = {
val stu:Student = new Student("henry")
stu.play()//student類裡沒有play方法，沒找到，就去找隱式函式的伴生物件，如果沒有
stu.sing()//student類裡沒有sing方法，沒找到，就去找隱式函式的伴生物件，如果沒有
implicit val age:Int=18
import logic.yinshiFunc.Student._
show
}
}
