文文x的博客

package com.scala.A/** * 匿名函数至简原则 * */object scala_niming_function_03 { def main(args: Array[String]): Unit = { //1.定义一个函数（函数名称为f1,参数为名为op的匿名函数标签，函数的返回值为Unit），函数的参数为一个匿名函数：匿名函数的参数为两个int类型，输出也为int类型 def f1(op: (Int, Int) => Unit): Unit = {

package com.scala.A/** * 控制抽象，实现自定义while循环 **/object scala_function_05_1 { def main(args: Array[String]): Unit = { var n = 10 /** * 1）常规的while循环 **/ while (n >= 1) { println(n) n = n - 1 } /** * 2)

package com.scala.A//----------------------------------------------------------------------------------------------------------------------/**函数柯里化&&闭包(必须要掌握)闭包的基本概念和底层原理闭包是函数式编程的标配(java中使用接口和内部类实现，java1.8后也借鉴了scala的闭包)1）说明闭包：如果一个

package com.scala.A//匿名函数/**1)说明没有名字的函数就是匿名函数。(x:Int)=>{函数体} x：表示输入参数；Int：表示输入参数类型；函数体：表示具体代码逻辑2）案例实操传递匿名函数至简原则：（1）参数的类型可以省略，会根据形参进行自动的推导（2）类型省略之后，发现只有一个参数，则圆括号可以省略；其他情况：没有参数和参数超过 1 的永远不能省略圆括号。（3）匿名函数如果只有一行，则大括号也可以省略（4）如果参数只出现一次，则参数省略且后面参数

package com.scala.Aimport scala.annotation.tailrec/** * 递归 * 1）说明 * 一个函数/方法在函数/方法体内又调用了本身，我们称之为递归调用 * 2）案例实操 **/object scala_function_04 {//---------------------------------------------------------------------------------------------------------

package com.scala.A/** * 控制抽象(主要争对函数参数)：值调用和名调用 **/object scala_function_05_0 { def main(args: Array[String]): Unit = { //------------------------------------------------------------------------------------------------------------------ /**

package com.scala.A/** 惰性加载 * 当函数返回值被声明为 lazy 时，函数的执行将被推迟，直到我们首次对此取值，该函数才会执行。这种函数我们称之为惰性函数 * *//** * 使用lazy声明的变量只有在使用的时候才会进行初始化。在Scala中，通过使用保护式来实现惰性值。当客户代码引用了惰性值时，保护式会拦截引用并检查此时是否需要初始化惰性。 * 由于保护式能够确保惰性在第一次访问之前便已初始化，因此增加保护式检查只有当第一次引用惰性值时才是必要的。 * 由于，

package com.scala.A/** * 函数作为值、参数、返回值传递 * */object scala_function_01 { def main(args: Array[String]): Unit = { def f(x: Int): Int = { //有参数，有返回值 println("f1被调用") x + 1 }//---------------------------------------------------------

package com.scala.A/**闭包的具体应用/object scala_function_03_1 {def main(args: Array[String]): Unit = {//------------------------------------------------------------------------------------------------------------------/*常规逻辑两个变量相加的函数如果是想计算两万个数相加呢

package com.scala.A/** * 函数作为值、参数、返回值传递 * */object scala_function_01 { def main(args: Array[String]): Unit = { def f(x: Int): Int = { //有参数，有返回值 println("f1被调用") x + 1 }//---------------------------------------------------------

package com.scala.A/** * 函数柯里化：把一个参数列表的多个参数，变成多个参数列表。 * 以前当一个函数有多个参数列表的时候，就是需要用逗号分隔参数列表 * 柯里化(来源于没过一个数学家的人名，currying)：每一层调用的时候只有一个参数 **/object scala_function_03_2 { def main(args: Array[String]): Unit = { //------------------------------------

package com.scala.functionobject test05_Lambda { def main(args: Array[String]): Unit = { val fun=(name:String)=>{ println(name) } fun("Alisa") //定义一个函数，以函数作为参数输入 //值以及定义好了（Alisa2），你要用这个值进行什么操作（println） def f1(func: Stri

package com.scala.functionobject test05_Lambda { def main(args: Array[String]): Unit = { val fun=(name:String)=>{ println(name) } fun("Alisa") //定义一个函数，以函数作为参数输入 //值以及定义好了（Alisa2），你要用这个值进行什么操作（println） def f1(func: Str

package com.scala.functionobject test04_Simplify { def main(args: Array[String]): Unit = { def f0(name:String):String={ return "我的名字叫"+name } println(f0("文鑫0")) //至简原则 //(1)return可以省略,scala会使用函数体的最后一行最为返回值 def f1(name:Str

package com.scala.functionobject test03_FunctionParameter { def main(args: Array[String]): Unit = { //可变参数 def f1(str:String*):Unit={ println(str) } f1("文鑫") f1("文鑫","文鑫2","文鑫3") //如果参数列表中有多个参数，那么可变参数一定放置在最后 def f2(st

package com.scala.hanshuobject test02_FunctionDefine { def main(args: Array[String]): Unit = { //没有参数，也没有返回值好 def f1():Unit={ println("1.无参，无返回") } f1() println(f1()) println("===========================================")

Unit类型（等同于Java中的void）、Null类型、Nothing类型

整数类型package com.scala.BlLxobject test_DataType { def main(args: Array[String]): Unit = { //1.整数类型 val a1:Byte =127 val a2:Byte = -128 //error: val a2:Byte = 128 val a3=12 //整数默认类型为Int //error: val a4=111112235565643 //长整型数

Java数据类型Scala数据类型

package com.scala.BlLximport java.io.{File, PrintWriter}import scala.io.Sourceobject FileIo { def main(args: Array[String]): Unit = { //从文件中读取数据 // Source.fromFile("D:\\IDEAproject\\scalaProject\\scala02\\src\\main\\resources\\testDate.t

package com.scala.BlLximport scala.io.StdInobject test_StdIn { def main(args: Array[String]): Unit = { println("请输入你的银行卡账号：") val zh = StdIn.readLine() println("请输入你的银行卡密码：") val passWd=StdIn.readLine() println("账号为："+zh+""+"密码为："

package com.scala.BlLxobject TestCharType { def main(args: Array[String]): Unit = { var name: String = "wenXin" var age: Int = 18 //(1)字符串，通过+连接 println(name + "今年" + age + "岁") //*用于将一个字符串复制多次拼接 println(name * 3 + "今年" + age +

package com.scala.BlLximport com.scala.example.Studentobject test01 { def main(args: Array[String]): Unit = { //声明一个变量的通用语法 var a1: Int=20 //(1)声明变量时，类型可以省略，编译器自动推导，也就是类型推导 //[:int省略] var a2=10 val b2=10 var a3="age" //.

package com.scala.exampleclass Student(name:String,age:Int) { def printInfo():Unit={ println(this.name+" "+this.age+" "+Student.school) //可以省略this println(name+" "+age+" "+Student.school) }}//引入一个伴生对象object Student{ val school:String

package com.scala.example/*object:关键字，声明一个单例对象（伴生对象）* */object HelloScala {/**main方法：从外部可以直接调用执行的方法* def 方法名称（参数名称: 参数类型）: 返回值类型={方法体}* */ def main(args: Array[String]): Unit = { println("hello scala 1") System.out.println("hello scala

scala语言特点：