- 方法和函式的作用幾乎是一樣的,但是函式在使用的程序中更加靈活和多樣化
- scala中函式是頭等公民 . 可以作為方法的回傳值和引數使用
- scala是一個集面向物件和面向函式于一身的編程語言 , 靈活的函式是函式式編程的一種體現
- 函式的使用使代碼更加簡潔和靈活
函式
scala中一種函式式編程語言 ,函式是scala中的頭等公民,建議優先使用函式 , 函式實作的功能和方法一樣 ,但是我們可以把函式理解成一種特殊的業務邏輯物件 ,所以函式可以作為引數和回傳值.... 函式也是用來處理資料的代碼封裝
函式的定義
方式一：
val / var 函式名稱=（函式的引數串列） => 函式體
舉例：
val add = (x: Int, y: Int) => {
x + y
}
val parseStr = (str: String) => {
str.toUpperCase()
}
// 函式體中的內容只有一行代碼可以省略大括號
var product = (x:Double) => x*x
方式二：
val / var 函式名稱：（輸入引數型別）=> 回傳值型別 = （引數的參考）=> 函式體
val add2:(Int,Int)=>Int=(x,y)=>{
x+y
}
add2 函式名
(Int ,Int) 要處理的引數型別串列
=>Int 函式處理完資料的回傳值型別
=(x,y) 傳入實際引數的接收變數名
{x+y} 函式體 運算求和
注意: 代碼塊的最后一行是函式的回傳值 ,需要和=>(Int)型別保持一致
分類
- 函式 1：無參，無回傳值
- 函式 2：無參，有回傳值
- 函式 3：有參，無回傳值
- 函式 4：有參，有回傳值
- 函式 5：多參，無回傳值
- 函式 6：多參，有回傳值
def main(args: Array[String]): Unit = {
// 函式 1：無參，無回傳值
val test1 ={
println("無參，無回傳值")
}
test1()
// 函式 2：無參，有回傳值
val test2={
"無參，有回傳值"
}
println(test2())
// 函式 3：有參，無回傳值
val test3 =(s:String)=>{
println(s)
}
test3("jinlian")
// 函式 4：有參，有回傳值
val test4 = (s:String)=>{
return s+"有參，有回傳值"
}
println(test4("hello "))
// 函式 5：多參，無回傳值
val test5 = (name:String, age:Int)=>{
println(s"$name, $age")
}
test5("dalang",40)
// 函式 6：多參，有回傳值
val test6 = (name:String, age:Int)=>{
"名字是:" + name + ",年齡是：" + age
}
}
函式的本質
函式的本質其實就是java中寫了 一個介面，然后函式體就是這個介面的具體實作
代碼示例:
//寫一個介面
package com.doit;
public interface Function2<T,U> {
public U apply(T t,T t1);
}
// 介面的實作類
Function2<Integer, Integer> func = new Function2<Integer, Integer>() {
@Override
public Integer apply(Integer integer, Integer t1) {
return integer + t1;
}
};
練一練：
需求1：定義一個函式，傳入一個值,如果這個值是三位數，則判斷是不是水仙花數,回傳布爾型別的值，如果這個值不是一個三位數，就回傳一個字串"輸入的數字不合法,需要的數字范圍是100-999"
package com.doit.day01.day02
import scala.math.pow
/**
* 定義一個函式，傳入一個值,如果這個值是三位數，
* 則判斷是不是水仙花數,回傳布爾型別的值，如果這個值不是一個三位數，
* 就回傳一個字串"輸入的數字不合法,需要的數字范圍是100-999"
*/
object Demo_Test {
def main(args: Array[String]): Unit = {
val value = https://www.cnblogs.com/paopaoT/archive/2023/06/16/flower(123)
println(value)
}
val flower = (num: Int) => {
if (num < 100 || num > 999) {"輸入的數字不合法,需要的數字范圍是100-999"
} else {
val unit = num % 10
val tens = num / 10 % 10
val hundreds = num / 100 % 10
val res = (pow(unit, 3) + pow(tens, 3) + pow(hundreds, 3)).toInt
if (res == num) {
true
} else {
false
}
}
}
}
需求二：將上面的函式，用java的介面也寫一遍，了解下函式的本質
//介面
package com.doit;
public interface Function1<U,T> {
T apply(U u);
}
//實作
package com.doit;
import static java.lang.Math.pow;
public class Demo {
public static void main(String[] args) {
//實作介面
Function1<Integer, Object> res = new Function1<Integer, Object>() {
@Override
public Object apply(Integer num) {
if (num < 100 || num > 999) {
return "輸入的數字不合法,需要的數字范圍是100-999";
} else {
int unit = num % 10;
int tens = num / 10 % 10;
int hundreds = num / 100 % 10;
int res = (int) (pow(unit, 3) + pow(tens, 3) + pow(hundreds, 3));
if (res == num) {
return true;
} else {
return false;
}
}
}
};
//呼叫apply方法傳入引數獲取到最終結果
Object apply = res.apply(1);
System.out.println(apply);
}
}
需求3：定義一個函式，功能是獲取mysql的連接
//定義一個函式，功能是獲取mysql的連接
val getMysqlConn = (url:String,user:String,passWord:String)=>{
classOf[com.mysql.jdbc.Driver]
val connetcion = DriverManager.getConnection(url,user,passWord)
connetcion
}
val conn: Connection = getMysqlConn("jdbc:mysql://localhost:3306/test01", "root", "123456")
val pps: PreparedStatement = conn.prepareStatement("select * from resume_info")
val res: ResultSet = pps.executeQuery()
while (res.next()){
val id: Int = res.getInt(1)
val jobName: String = res.getString(2)
val date: String = res.getString(3)
val num: Int = res.getInt(4)
println(s"$id , $jobName ,$date ,$num")
}
方法
方法是邏輯片段的封裝 ,可以處理一個或者多個資料 , 可以有回傳值也可以沒有沒有回傳值 ,提高了代碼的復用性
方法的定義
def functionName ([引數串列]) : [return type] = {
function body
return [expr]
}
沒有等號和方法體的方法稱為抽象方法,抽象方法定義在抽象類和特質中
代碼示例：
// 定義一個方法 有兩個引數 有回傳值
def add(x:Int , y:Int):Int={
val sum = x + y
sum
// return 可以省略 , 代碼塊的最后一行就是這個方法的回傳值
// return sum
}
/**
* 定義一個沒有引數沒有回傳值的方法 Unit關鍵字代表沒有回傳值 類似于java中的void
*/
def show()={
println("show......")
}
/**
* 如果方法沒有引數 方法后面的() 可以省略 ,注意在呼叫的時候也不要書寫小括號
*/
def show2={
println("show......")
}
// 在抽象類或者特質中定義抽象方法
def m1
方法的呼叫
方法的呼叫和java中的呼叫方式不太一樣，如果方法定義在object中 在本類直接方法名呼叫 在其他類中呼叫 object 物件名呼叫，如果方法定義在普通的class 類中 , 本類之間直接呼叫! 其他類中new 類 .方法呼叫
方法總結
注意方法的引數和回傳值可以是函式 ,這樣的方法稱為高階函式 ,高階函式中詳細講解
- 定義方法的關鍵字，def
- 方法的回傳值，最后一行的內容，如果是回圈,列印，那么回傳值是 Unit
- 如果空參方法，定義的時候有()，呼叫的時候可以省略()，但是如果定義的時候沒有(),呼叫方法的時候，不能加()
- 方法的回傳值型別，可以省略，但是特殊情況下，必須加上：
? 方法有 return 關鍵字
? 遞回呼叫的方法，
代碼示例：
val f = (x:String)=>{x}
f
def show(x:String) :Unit ={
x
}
show
練一練：
需求一：定義一個方法，傳入一個1-9中任意的整數，如果這個整數是在1-9內，那么就列印九九乘法表中到第幾行，如果傳進去的不是一個1-9的數，列印：干啥呢，不好好聽課，要傳1-9的整數
package com.doit.day01.day02
import scala.math.pow
/**
* 需求一：定義一個方法，傳入一個1-9中任意的整數，
* 如果這個整數是在1-9內，那么就列印九九乘法表中到第幾行，
* 如果傳進去的不是一個1-9的數，列印：干啥呢，不好好聽課，要傳1-9的整數
*/
object Demo_Test {
def main(args: Array[String]): Unit = {
multiplyTable(11)
}
def multiplyTable(num:Int)={
if(num<1 || num >9){
println("干啥呢，不好好聽課，要傳1-9的整數")
}else {
for(i <- 1 to num ;j <- 1 to i){
print(s"${i} * ${j} = ${i*j}\t")
if(i==j) println()
}
}
}
}
需求二：寫一個二分查找的方法,傳入一個陣列，再傳入一個整數，去查找這個整數是不是在這個陣列中，如果在，就回傳他的索引位置，如果不在，就回傳：對不起，你查找的數不存在
package com.doit.day01.day02
import scala.util.control.Breaks
/**
* 需求二：寫一個二分查找的方法,傳入一個陣列，再傳入一個整數，
* 去查找這個整數是不是在這個陣列中，
* 如果在，就回傳他的索引位置，如果不在，就回傳-1
*/
object Demo_Test {
def main(args: Array[String]): Unit = {
val arr: Array[Int] = Array(1,2,3,4,5,6,7,8,9)
val arr1: Array[Int] = Array()
println(binarySearch(arr, 9))
}
def binarySearch(arr: Array[Int], num: Int) = {
//二分查找的數必須是有序的,先給陣列排個序
// arr.sortWith((i: Int, j: Int) => {i < j})
//這種方式也可以
// arr.sortWith(_ < _)
var res = -1
//首先判斷這個陣列的長度是不是0，如果是0，代表陣列中沒有元素，直接回傳-1
if (arr.length == 0) {
res
} else {
// 起始位置索引
var start = 0
// 檢索的最后一個元素
var end = arr.length - 1
//如果開始指標小于等于結束指標的時候，就要一直查找
Breaks.breakable(
while (start <= end) {
//二分找到中間的數
val midd = (start + end) / 2
//如果中間的那個數大于查詢的數
if (arr(midd) > num) {
end = midd - 1
} else if (arr(midd) < num) {
start = midd + 1
} else {
res = midd
Breaks.break()
}
}
)
res
}
}
}
函式和方法
相互轉換
def add(x: Int, y: Int) = {
x + y
}
// 將方法轉換成函式
val f = add _
當我們將方法作為參傳遞的時候 ,其實底層是將方法自動轉換成函式
區別
在函式式編程語言中，函式是“頭等公民”，它可以像任何其他資料型別一樣被傳遞,函式可以當成值來進行傳遞，方法的引數和回傳值都可以是函式， 函式和變數，類，物件， 是一個級別的，
區別和聯系：
? 方法用 def 關鍵字定義，函式的標識 =>
? 方法不能作為最終的運算式存在，但是函式可以，回傳函式的簽名資訊
? 方法和函式呼叫的時候都需要顯示的傳入引數
? 函式可以作為方法的引數，和回傳值型別，
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/555347.html
標籤：其他
上一篇：lua中 . 和 : 的區別
下一篇：返回列表