目录
15-01-Scala语言简介
15-02-Scala中的数据类型和变量常量
scala> var s1:String = "Hello World"
s1: String = Hello World
字符串的插值操作：相当于拼加字符串
scala> "My name is Tom and ${s1}"
res1: String = My name is Tom and ${s1}
scala> s"My name is Tom and ${s1}"
res2: String = My name is Tom and Hello World
15-03-Scala的函数
scala> def sum(x:Int,y:Int):Int = x + y
sum: (x: Int, y: Int)Int
scala> sum(10,20)
res5: Int = 30
scala> var a = sum(10,20)
a: Int = 30
scala> def myFactor(x:Int):Int = {
| //采用阶乘
| if(x <= 1)
| 1
| else
| //执行递归
| x*myFactor(x-1)
| }
myFactor: (x: Int)Int
scala> myFactor(5)
res6: Int = 120
15-04-Scala的循环
package day01
import sun.org.mozilla.javascript.internal.ast.Yield
object A03 {
def main(args: Array[String]): Unit = {
var list = List("tom", "jerry", "mary");
for (s <- list) {
println(s);
}
println("------------------");
for {
s <- list
if (s.length() > 3)
} println(s)
println("------------------");
for (
s <- list if (s.length() > 3)
) println(s)
println("------------------");
var newlist = for {
s <- list
s1 = s.toUpperCase()
} yield (s1)
for (s <- newlist) println(s);
println("------------------");
var i = 0
while (i < list.length) {
println(list(i))
i += 1
}
println("------------------");
var j = 0
do {
println(list(j))
j += 1
} while (j < list.length)
println("11111111111111");
list.foreach(println)
}
}
15-05-函数参数的求值策略
call by value定义： :
对函数实参求值，并且只求一次
call by name定义： :=>
函数的实参在函数体内部每次用到的时候，都会被求值
15-06-lazy懒值
15-07-数组
15-08-映射
15-09-元组
16-01-面向对象简介
16-02-定义类
//代表一个学生的信息
class Student1 {
//定义学生的属性
private var stuID:Int = 0
private var stuName:String = "Tom"
private var age:Int = 20
//定义成员方法（函数）:get 和set
//定义名字和年龄的get和set
def getStuName():String = stuName
def setStuName(newName:String) = this.stuName = newName
def getStuAge():Int = age
def setStuAge(newAge:Int) = this.age = newAge
}
//测试Student1类，创建main函数(写到Object中)
//注意：object和class的名字可以不一样，如果一样了，这个object就叫做该class的伴生对象
object Student1{
def main(args: Array[String]): Unit = {
//创建学生对象
var s1 = new Student1
//第一次访问属性并输出
println(s1.getStuName()+" "+s1.getStuAge())
//访问set方法
s1.setStuName("Mary")
s1.setStuAge(22)
println(s1.getStuName()+" "+s1.getStuAge())
//再输出一次：直接访问私有的属性
println("*************直接访问私有的属性************")
println(s1.stuID +" "+ s1.stuName+" "+s1.age)
//注意：可以直接访问类的私有成员 为什么可以？ ----> 属性的get和set方法
}
}
16-03-内部类
16-04-类的构造器
16-05-object对象
//实现一个单例模式：自动生成卡号
object CreditCard {
//定义一个变量保存信用卡的卡号
private[this] var creditCardNumber:Long = 0
//定义函数来产生卡号
def generateCCNumber():Long = {
creditCardNumber += 1
//返回卡号
creditCardNumber
}
//测试程序
def main(args: Array[String]): Unit = {
//产生新的卡号
println(CreditCard.generateCCNumber())
println(CreditCard.generateCCNumber())
println(CreditCard.generateCCNumber())
println(CreditCard.generateCCNumber())
}
}
//使用App对象：应用程序对象
object HelloWorld extends App {
// def main(args: Array[String]): Unit = {
// println("Hello World")
// }
//把main函数中的程序直接写到object中
println("Hello World")
//也可以直接通过args获取命令行的参数
if(args.length > 0){
println("有参数")
}else{
println("没有有参数")
}
}
16-06-apply方法
//定义一个类
class Student3(var stuName:String)
object Student3 {
//定义Student3的apply方法
def apply(name:String) = {
println("*********调用到了apply方法*********")
new Student3(name) //调用到了主构造器
}
//测试程序
def main(args: Array[String]): Unit = {
//通过主构造器创建学生对象
var s1 = new Student3("Tom")
println(s1.stuName)
//通过apply方法创建学生对象
var s2 = Student3("Mary")
println(s2.stuName)
}
}
16-07-继承
//继承1：父类 Person 人， 子类 Employee 员工
//定义父类
class Person(val name:String,val age:Int){
//定义函数
def sayHello():String = "Hello " + name + " and the age is " + age
}
//定义子类
//override：表示希望使用子类中的值去覆盖父类中的值
class Employee(override val name:String,override val age:Int,var salary:Int) extends Person(name,age){
//在子类中，重写父类的函数
override def sayHello():String = "子类中的sayHello方法"
}
object Demo1 {
def main(args: Array[String]): Unit = {
//测试程序
//创建一个Person对象
var p1 = new Person("Tom",20)
println(p1.name+" "+p1.age)
println(p1.sayHello())
//创建一个Employee的对象
//可以使用子类对象
var p2:Person = new Employee("Mike",25,1000)
println(p2.sayHello())
//通过匿名子类实现继承：没有名字的子类
var p3:Person = new Person("Mary",25){
//在匿名子类中重写sayHello方法
override def sayHello():String = "匿名子类中的sayHello方法"
}
println(p3.sayHello())
}
}
16-08-抽象类和抽象字段
16-09-trait
16-10-包和包对象
17-01-函数式编程简介和匿名函数
17-02-什么是高阶函数
17-03-高阶函数示例
高阶函数示例.png
（*）map：相当于一个循环，对某个集合中的每个元素进行操作（就是接受一个函数），返回一个新的集合
val numbers = List(1,2,3,4,5,6,7,8,9,10)
numbers.map((i:Int)=>i*2)
简写 numbers.map(_ * 2)
（*）foreach：相当于一个循环，对某个集合中的每个元素进行操作（就是接受一个函数），不返回结果
numbers.foreach((i:Int)=>i*2)
（*）filter: 过滤，选择满足条件的数据
查询能够被2整除的数字
numbers.filter((i:Int)=> i%2==0) 如果是true，就返回结果
（*）zip: 合并集合
List(1,2,3).zip(List(4,5,6))
（*）partition: 根据断言（就是条件，通过一个匿名函数来实现）的结果，来进行分区
举例：把能够被2整除的分成一个区，不能整除的分成另一个区
numbers.partition((i:Int)=> i%2==0)
（*）find: 查找第一个满足条件（断言）的元素
查询第一个能够被3整除的数字
numbers.find(_%3 == 0)
（*）flatten：把嵌套的结构展开
List(List(2, 4, 6, 8, 10),List(1, 3, 5, 7, 9)).flatten
（*）flatMap 相当于 map + flatten
var myList = List(List(2, 4, 6, 8, 10),List(1, 3, 5, 7, 9))
myList.flatMap(x=> x.map(_*2))
结果 res16: List[Int] = List(4, 8, 12, 16, 20, 2, 6, 10, 14, 18)
过程 （1）将List(2, 4, 6, 8, 10)和List(1, 3, 5, 7, 9)调用x=> x.map(_*2)
（2）再合并成一个List