Scala的简单学习一

一相关知识

1.1 scala的安装

1.在idea中导入依赖，并在Idea下载scala插件

1.2 scala基础知识点

1.scala代码中一行语句的结束是以换行符为标准，可以不用写分号

2.class是一个普通的类，object相当于一个单例对象，object类中的方法相当于加上一个static关键字

二基础知识

2.1 基本数据类型

Byte、Short、Int、Long、Float、Double、Char、Boolean

2.2 定义变量常量

var 变量名:数据类型=数值

val 变量名:数据类型=数值

注意：定义了变量后续使用不需要指明类型

package com.shujia.day01object Demo1 {def main(args: Array[String]): Unit = {println("hello world")var a: Int = 10val b: Int = 19var c: String = "hello"println(a)println(b)}}

2.3 获取数据类型

变量名.getClass 或者变量名.getClass.getSimpleName方法查看数据类型

package com.shujia.day01object Demo1 {def main(args: Array[String]): Unit = {println("hello world")var a: Int = 10val b: Int = 19var c: String = "hello"println(a)println(b)println(a.getClass.getSimpleName) //intprintln(c.getClass)//class java.lang.String}}

2.4 字符串拼接

1.scala提供了一个方法类似拼接的方式语法 s"${xx}"

package com.shujia.day01object Demo1 {def main(args: Array[String]): Unit = {println("hello world")var a: Int = 10val b: Int = 19var c: String = "hello"println(a)println(b)println(a.getClass.getSimpleName) //intprintln(c.getClass)//class java.lang.Stringvar str:String=s"${a}|${b}"println(str)//10|19}}

2.数组里面有个方法可以将数组里面的元素拼接

数组.mkString(拼接符号)

2.5 控制语句

2.5.1 选择语句

if else语句

package com.shujia.day01import java.util.Scannerobject Demo2 {def main(args: Array[String]): Unit = {val sc: Scanner = new Scanner(System.in)println("请输入您的年龄")val age: Int = sc.nextInt()if(age<18){println("未成年")}else{println("成年")}}}

while 循环

注意：scala里面不支持++与--的

package com.shujia.day01import java.util.Scannerobject Demo2 {def main(args: Array[String]): Unit = {val sc: Scanner = new Scanner(System.in)println("请输入您的年龄")val age: Int = sc.nextInt()if(age<18){println("未成年")}else{println("成年")}val array1: Array[Int] = Array(11, 22, 33, 44, 55)var i: Int = 0while (i<array1.length){println(array1(i))i += 1}}}

2.5.2 循环语句

1.注意Scala里面没有for循环，他只适用于遍历各个容器

2.容器for循环

   val array1: Array[Int] = Array(11, 22, 33, 44, 55)var i: Int = 0while (i<array1.length){println(array1(i))i += 1}for (elem <- array1) {println(elem)}

3.不是容器的for循环

to：表示可以取到右边的

util：表示取不到右边的

 for (e <- 1 to 10){println("hello world")}for (e <- 1 until  10){println("hello world")}

2.5.3 控制条件

1.Scala里面的break countie 是没有的需要导包

import scala.util.control.Breaks._ // _相当于java中的*

2.Scala里面break 需要抛出异常

  breakable{for (e <- 1 until  10){if (e==5){break}println(e)}}

2.6 IO流

2.6.1 读文件

1.Scala里面有一个 Source类读取文件

2.Source的对象的getLines获取的是迭代器对象

package com.shujia.day01import scala.io.{BufferedSource, Source}object Demo3IO {def main(args: Array[String]): Unit = {//获取文件对象val bs: BufferedSource = Source.fromFile("scala/data/demo")//创建读文件的迭代器val lines: Iterator[String] = bs.getLines()for (elem <- lines) {println(elem)}}}

2.6.2 写文件

1.Scala里面木单独的类写文件，只能依靠Java里面的方法

val bw = new BufferedWriter(new FileWriter("scala/data/out1.txt"))bw.write("hello world1")bw.newLine()bw.write("hello world2")bw.close()

2.7 函数

2.7.1函数的定义

1.定义在object里面的叫函数，定义在class里面的叫方法

2.主函数

* def: 定义函数或者方法的关键字

* main: 函数名 main函数是被java虚拟机所特有识别的程序入口

* args: 参数名

* Array[String]: 参数的数据类型

* Unit: 返回值类型相当于java中的void

3.函数可以在object任意一个位置定义

2.7.2 函数的调用

在object对象内部，函数相当于加了一个static，将来调用的时候，可以使用object对象名进行调用

在同一作用域中，调用时可以不加对象名

package com.shujia.day02object Demo4Func {def main(args: Array[String]): Unit = {/** def: 定义函数或者方法的关键字* main: 函数名 main函数是被java虚拟机所特有识别的程序入口* args: 参数名* Array[String]: 参数的数据类型* Unit: 返回值类型 相当于java中的void*/println(add(2,4))println(Demo4Func.add(2,4))}//定义一个add函数def add(a:Int,b:Int):Int={return a+b}
}

2.7.3 函数的简写

1、如果函数体中最后一行语句作为返回值的时候，return可以省略不写

2、如果函数体中只有一行语句实现，那么大括号也可以不用编写

3、函数的返回值可以进行自动类型推断，可以省略不写

4、如果函数没有参数列表的话，()也可以省略不写，def add5 = println("好好学习，天天向上")

  //函数最后一句是返回的话，return可以不写def add1(x: Int, y: Int): Int = {x + y}//如果函数体中只有一行语句实现，那么大括号也可以不用编写def add2(x:Int,y:Int):Int=x+y//函数的返回值可以进行自动类型推断，可以省略不写def add3(x:Int,y:Int)=x+y//如果函数没有参数列表的话，()也可以省略不写def add4=println("hello")

5.如果函数只有一个参数，那么调用的时候可以简写

直接所属object 方法名参数

  def add6(x: Int): Int = {x+200}
println(Demo4Func add6 3)

2.7.4 函数的递归

 def jieCheng(i: Int): Int = {if (i == 1) {1} else {i * jieCheng(i - 1)}}

2.6 异常

1.scala默认处理异常的方式是向外抛,如果出错，后续代码不会执行

2.scala处理异常的另一种方式和java一样，也是try..catch..但是和java的写法不太一样

package com.shujia.day02import java.io.FileNotFoundExceptionobject Demo5Exception {def main(args: Array[String]): Unit = {try {//      val br = new BufferedReader(new FileReader("scala/data/sssss")) // FileNotFoundException//      val array1: Array[Int] = Array(11, 22, 33) // ArrayIndexOutOfBoundsException//      println(array1(4))Class.forName("com.shujia.Demo")} catch {//模式匹配case e:FileNotFoundException => println("文件找不到异常")case e:ArrayIndexOutOfBoundsException => println("数组索引越界异常")//      case e:Exception => e.printStackTrace()case _ => println("其他异常")}finally {//无论有没有对应的case捕获，都会执行println("finally")}println("over")}}

3.其中的匹配模式在后面会说到

三进阶知识

3.1 类与对象

3.1.1相关知识

1.有一个共同的父类 object

2.使用单例对象

3.1.2 构造方法

1.在new对象的时候，构造方法必须手动创造，并重载，并放在开头写

class Student {println("好好学习天天向上")def this(x:Int,y:Int) {this()println(x+y)}}object Demo6Object {def main(args: Array[String]): Unit = {val student = new Student(10,20)}}
//好好学习天天向上
30

3.1.3 成员变量

1.创建成员变量默认语法

var _变量名:类型=_

2._表示占位符，将来可以传值进去

package com.shujia.day02class Student2 {//定义成员变量private var _name: String = _private var _age: Int = _//构造方法def this(name:String,age:Int) {this()this._name=namethis._age=age}override def toString = s"姓名${_name},年龄${_age}"
}

3. 私有成员变量

不提供get set方法需要我们自己写

set有参数无返回值，get无参数有返回值

package com.shujia.day02class Student2 {//定义成员变量private var _name: String = _private var _age: Int = _//构造方法def this(name:String,age:Int) {this()this._name=namethis._age=age}//只有一条语句大括号可以省略def setName(name:String):Unit =this._name//没有参数 小括号可以不用写def getName:String=this._namedef setAge(age:Int):Unit=this._agedef getAge: Int =this._ageoverride def toString = s"姓名${_name},年龄${_age}"
}

4.创建类的时候传参

package com.shujia.day02class Student3 (name:String,age:Int){//定义成员变量private var _name: String = nameprivate var _age: Int = ageprivate var _ad:String=_def this(name:String,age:Int,ad:String) {this(name,age)this._ad=ad}override def toString = s"姓名${_name},年龄${_age}，地址${_ad}"}

这个在new对象的时候可以传2个值页可以传三个值，如果是两个值，定义class时没有传入的默认是null值，

3.1.4 成员方法

太简单不说了

3.2 继承

跟java差不多，无需多言

3.3 伴生对象

1.object与class 创建的类的名字相同，class创建的类叫伴生对象

2.object创建的对象无法new出来。但是可以通过apply方法创建对象

package com.shujia.day02object Demo7Apply {def main(args: Array[String]): Unit = {val phone2 = new Phone2("华为", 8000)println(phone2)val phone1: Phone2 = Phone.apply("苹果", 10000)println(phone1)}
}object Phone {def apply(kind: String, price: Int): Phone2 = new Phone2(kind, price)
}class Phone2(kind: String, price: Int) {override def toString = s"品牌:${kind}, 价格:${price}"
}

3.4 样例类

1.与普通的类的区别：

普通的类需要重写toString方法才能获取值，要不然打印的是地址值

默认不能修改值，需要修改，将case定义类的时候用var

2.在case定义类的时候可以暂时给定一个默认值用var修饰，后面创建对象的时候可以改

package com.shujia.day02object Demo8Cass {def main(args: Array[String]): Unit = {val u1 = new User("慌", 19)println(u1)//com.shujia.day01.User@2a18f23cu1.ad="安全"println(u1)}
}//class User(name:String,age:Int)case class User(var str: String, i: Int,var ad:String="合肥");

四面向函数式编程

4.1 函数作为参数

4.1.1 基础知识

1.将函数看作对象

2.使用 =>确定类型

4.1.2 函数作为值复制给变量

package com.shujia.day02object Demo9Func {def main(args: Array[String]): Unit = {//创建一个函数将字符串变成int类型def strToInt(str:String):Int={str.toInt}val i1: Int = strToInt("1000")println(i1)//1000//定义一个变量接收这个函数，刚刚好这个变量的类型也是字符串变成int类型val strToIntTemp : String=>Int =strToIntval i2: Int = strToIntTemp("2000")println(i2)//2000}}

4.1.3 参数是函数的函数

1.传入的是参数是啥类型的函数，啥类型是你目标参数需要的

 //定义一个参数是函数的函数/*** 定义了一个fun函数，函数的参数是一个参数为String类型返回值是Int类型的函数*/def fun(f:String=>Int):Unit={val i3: Int = f("3000")println("这是fun函数")println(i3)}//定义一个参数是String类型的，返回值是Int类型的函数def method1(str:String):Int={println("这是method1函数")str.toInt+1000}//调用fun函数fun(method1)

4.1.4 使用匿名函数改写

没有名字的函数

语法：

(参数列表)=> 返回值类型

1.匿名函数可以用一个变量接收，然后再传入主体函数中

2.匿名函数的返回值类型可以自动判断，不需要标明，标明就错了

3.当主体函数只有一句话的时候，可以直接传入匿名函数

4.匿名函数的参数类型也可以不写，但是会有警告，最好写上

5.当匿名函数中传入的参数只用了一次，且主体函数只有一句话的时候，可以用下划线代替匿名函数的参数

    //创建匿名函数//val f1: String => Int  定义了一个变量是类型是String转化成Int类型//(s: String) => s.toInt   创建了一个匿名函数，这函数的作用就是将String变成Int//(s: String) => s.toInt  这里的匿名函数也是简写的，因为函数的主体只有一句话，可以省区大括号，如果还想添加其他的，要加上大括号//(s: String) => s.toInt 在匿名函数中 返回值的类型不需要写，会自动判断的
//    val f1: String => Int = (s: String):Int => {s.toInt}//这样会报错val f1: String => Int = (s: String) => {s.toInt}//调用fun函数fun("80",f1)//当函数只有一行的时候，可以直接传入匿名函数fun("88",(s:String)=>{s.toInt})//lambda表达式的参数类型可以进行自动推断,不推荐这样，因为会有警告，最好加入匿名函数的参数类型fun("22", s => s.toInt)//如果传入的函数参数有且仅只用了一次的话，可以直接使用_代替fun("22", _.toInt)

4.1.5 实例

package com.shujia.day02object Demo10Func {def main(args: Array[String]): Unit = {//定义一个数组val array: Array[Int] = Array(11, 22, 33, 44, 55, 66, 77, 88, 99)//1 之前的for遍历数组for (elem <- array) {println(elem)}println("="*100)//使用foreach函数遍历//f: A => U ,参数是有类型的，返回值无类型的array.foreach(f)//定义一个函数f，参数是有类型的，返回值无类型的def f(i:Int): Unit ={println(i)}println("="*100)//使用匿名函数array.foreach((i:Int)=>{println(i)})//参数类型不写
//    array.foreach(i=>{println(i)})//会有警告，最好加上类型//用_代替参数array.foreach(println(_))//使用Scala自动any类中的方法//以后遍历数组就这样写array.foreach(println)}}

4.2 函数作为返回值

4.2.1 参数与返回值都是函数

1.调用函数得到也是一个函数

//定义一个参数类型是String->Int的函数，返回值是一个参数列表为String->Int类型的函数def fun(f:String=>Int):String=>Int={println("好好学习天天向上")f}//使用匿名函数调用了fun函数，因为fun函数有返回值，所以用一个变量接收，刚刚好这个变量又是函数，可以调用val show: String => Int = fun((s: String) => s.toInt)//调用show函数println(show("1000"))

4.2.2 只有返回值是函数

1.返回值是啥类型，就要在内部创建一个改样类型的函数。

2.返回值直接写内部创建函数的函数名

3.调用函数得到也是一个函数

4.对于这种的可以直接简化

5.好处：传值可以分开，当函数原本一次性传递多个参数的时候，现在改成分开传递参数的形式，增加了函数的灵活性和可复用性，scala的函数柯里化：函数的返回值依旧是一个函数，继续传参

   //定义一个参数类型为String，返回值是参数列表是String->Int的函数def fun1(str:String):String=>Int={//因为这里的返回值是参数列表是String->Int的函数，需要在fun1里面创建一个这样的函数def show1(s:String):Int={str.toInt+s.toInt}//需要返回一个参数列表是String->Int的函数show1}//上面函数的简写形式def fun2(str: String)(str1: String): Int = {str.toInt+str1.toInt}//调用fun2函数println(fun2("1000")("1000"))//调用fun1函数val get: String => Int = fun1("1000")//这是函数val i: Int = get("1000")println(i)//简化写法val i1: Int = fun1("1000")("1000")println(i1)

6.偏函数：中间由scala产生的函数，称之为偏函数

def fun3(str1:String,str2:String):Int={str1.toInt+str2.toInt}//偏函数val show3: String => Int = fun3("10", _)println(show3("10"))println(show3("20"))println(show3("30"))