目录
其中Any和AnyRef 、AnyVal 、Nothing 之间的关系如下图：空值之间的区别当给变量定义的时候，不给出类型就是一个Nothing
变量声明
在声明变量时，Scala 允许你决定该变量是不可变（只读）的，还是可变的（读写）。如下所示，不可变的“变量”用 val 关键字声明：
val array: Array[String] = new Array(5)
Scala 的大部分变量事实上是指向堆内存对象的引用，这一点与 Java 一致。所以，以上代码中的 array 也是一个引用，它不能指向其他 Array，但所指向的 Array 中的元素是可变的，如下所示：
一个 val 变量在声明时必须被初始化。
类似地，一个可变变量用关键字 var 来声明。尽管由于该变量是可变变量，声明后可以再次对其赋值，也必须在声明的同时立即初始化：
在 Java 中， 所谓的原生类型， 即 char、byte、short、int、long、float、double 和boolean，与其他引用类型有着本质的不同。这些类型确实既不是对象，也没有引用，是“原始”值。Scala 尽力使其面向对象特性更加一致，因此这些类型在 Scala 中是包含有方法的对象，就像引用类型一样。然而，Scala 编译时将这些类型尽可能地转为原生类型，使你可以得到原生类型的运行效率.
用 val 和 var 声明变量时必须初始化这一规则，但存在少数例外情况。例如，这两个关键字均可以用在构造函数的参数中，这时候变量是该类的一个属性，因此显然不必在声明时进行初始化。此时如果用 val 声明，该属性是不可变的；如果用 var 声明，则该属性是可变的、
var 和 val 关键字只标识引用本身是否可以指向另一个不同的对象，它们并未表明其所引用的对象是否可变。
为了减少可变性引起的bug，应该尽可能地使用不可变变量。
数据类型
其中Any和AnyRef 、AnyVal 、Nothing 之间的关系如下图：
空值之间的区别
当给变量定义的时候，不给出类型就是一个Nothing
Scala的类和oject
- 建议类名首字母大写 ，方法首字母小写，类和方法命名建议符合驼峰命名法。
- scala 中的object是单例对象，相当于java中的工具类，可以看成是定义静态的方法的类。object不可以传参数。另：Trait不可以传参数
- scala中的class类默认可以传参数，默认的传参数就是默认的构造函数。重置必须要调用默认的构造函数。
- class 类属写构造函数的时候，性自带getter ，setter方法。
- 使用object时，不用new,使用class时要new ,并且new的时候，class中除了方法不执行，其他都执行。
- 如果在同一个文件中，object对象和class类的名称相同，则这个对象就是这个类的伴生对象，这个类就是这个对象的伴生类。可以互相访问私有变量。
package com.lzq.bilibili
//在Scala当中驼峰命名法，在Scala当中定义的类可以传递参数,有了参数就有了默认的构造,传参一定要指定类型,传递参数的时候会自动getset
//在类当中重写构造，构造中第一行需要调用默认构造
//在Scala当中，new Person时 出来方法不执行【除了构造方法】其他都执行
//在同一个文件当中class名称和Object名称一样时，这个类叫做这个对象的伴生类，这个对象叫做这个类的伴生对象，互相之间可以互相访问私有变量
class Person(pname: String, page: Int) {
val name = pname
val age = page
var sex = 'M'
println("=========Begin========")
def Say() = {
print("hello " + DataType.name)
}
def this(qname: String, qage: Int, qsex: Char) {
this(qname, qage)
this.sex = qsex
}
println("=========End========")
}
//object相当于java当中的单例，定义的全是静态的。相当于java的工具类 Object当中不能够传递参数
object DataType {
//object会在class之前进行调用
println("###### Object ######")
val name = "yueyue"
def apply(i: Int, s: String) = {
println("i = " + i + ", s =" + s)
}
def main(args: Array[String]): Unit = {
// if else分支语句
// val age = 15
// if (age < 18) {
// println("未成年")
// } else if (age == 18) {
// println("刚成年")
// } else {
// println("已经成年")
// }
// for循环
// val a = 1 to (10,2)
// println(a)
// for(i<- 1 to 10){
// println(i)
// }
// 嵌套for循环 方式一
// for (i <- 1 to 9) {
// for (j <- 1 to 9) {
// if (i >= j) {
// print(i + "*" + j + "=" + i * j + " ")
// }
// }
// println()
// }
//方式二
// for (i <- 1 to 9;j <- 1 to 9) {
// if (i >= j) {
// print(j + "*" + i + "=" + i * j + " ")
// }
// if(i==j ){
// println()
// }
// }
//在for语句当中添加条件
// for ( i <- 1 to 1000 if(i> 500) if(i%3 ==0)){
// print(i+" ")
// }
//while循环
//var i = 1
// while(i<10){
// println(s"第 $i 次")
// i=i+1
// //或者 i += 1 但是不能使用 ++
// }
//改成do while循环
// do {
// println(s"第 $i 次")
// i = i + 1
// }
// while (i < 10)
//直接使用变量获取值
// val res = for ( i <- 1 to 100 if(i> 50) if(i%3 ==0)) yield i
// println(res)
//DataType(1000, "String s")
//对Object进行传参，需要调用apply方法，否则是不可以传参的
//实例化这个类 Person p = new Person()
//val person = new Person(pname = "月月鸟", page = 25)
// println(person.name)
// println(person.age)
// person.Say()
// val person1 = new Person(qname = "yueyue1", qage = 30, qsex = 'M')
// print(person1.sex)
// val a = 100
// println(a)
// var b =200
// b=300
// println(b)
}
}方法定义
1.普通方法
def sum(a: Int, b: Int): Int = {
//return a + b
a + b
}
➢ 注意点
- 方法体的返回值可以省略，会自动推断
- 方法体最后的返回值可以使用return，如果使用了return那么一定要指定返回类型
- 方法体中没有用return。默认将方法体当中最后一行计算的结果当做返回值返回，
- 方法体当中，如果只有一行，大括号可以省略
- 如果定义方法，省略了方法名称和 = 无论结果是什么，结果丢弃，返回控制Unit
2.递归方法
在声明方法的时候需要给定方法的返回类型：以及其中的if else语句当中只有一条子语句的话，大括号可省略
def recursion(num: Int): Int = {
if (num == 1) 1 else num * recursion(num - 1)
}
3.参数有默认值的方法
-
def Default_parameters(a: Int = 10, b: Int = 20) = { a + b }
在调用过程当中如果只想改变一个参数值，重新赋值即可
println(Default_parameters(b=54))
4.参数可变的方法
如下代码所示：传递参数的时候在后面加上一个* 表示可传递多个参数，随后对参数进行打印输出可以使用最简单的for循环，foreach循环使用 => 匿名函数。等等
def Variable_parameters(s: String*) = {
// =>匿名函数
//s.foreach(ele => {println(ele)})
//当foreach当中的参数只用了一次可以使用下划线 "_" 进行代替
//s.foreach(println(_))
//或者再进行省略
s.foreach(println)
// for(ele <- s){
// println(ele)
// }
}
5.匿名函数
def Anonymous_function = (a: Int, b: Int) => {
a + b
}
6.嵌套方法
在一个方法当中再定义一个方法，实现嵌套方法。
def nesting(x: Int): Int = {
def nesting1(y: Int): Int = {
if (y == 1) 1 else y * nesting1(y - 1)
}
}
nesting1(x)
7.偏应用函数
参数过多且参数大部分是不变的，就可以使用偏应用函数对其进行简化。
def application(date: Date, log: String): Any = {
println("Date is " + date + ", log is " + log)
}
调用方法：
val date = new Date()
application(date, "a")
application(date, "b")
application(date, "c")
上方调用还是显得有所冗长，直接使用一个方法直接简化：
val date = new Date()
def app=application(date,_:String)
app("a")
3.1 高阶函数 ：方法的参数是函数
也就是将第一个参数改成一个函数进行传递
//sum函数用于调用高阶函数传递的函数
def sum1(a: Int, b: Int) = {
a + b
}
def parameter_fun(f: (Int, Int) => Int, s: String) = {
val i: Int = f(100, 200);
i + " " + s
}
调用：
var res= parameter_fun(sum1,"string")
println(res)
或者使用一个匿名函数。
var res = parameter_fun((a:Int,b:Int)=>{a*b},"string")
println(res)
3.2 高阶函数 ：方法的返回是函数
返回类型需要给出，而不能使用推断类型，需要根据情况而定
方法调用：在函数当中又包含了一个函数。
def return_fun(a: String): (String, String) => String = {
def return_fun1(s1: String, s2: String): String = {
s1 + " " + s2 + " " + a
}
//return_fun1
return_fun1 _ //使用这种方式就不需要给出返回类型
}
3.3 高阶函数 ：方法的参数和返回都是函数
这就是前两者的结合：
def neutralization(f: (Int, Int) => Int): (String, String) => String = {
val i: Int = f(1, 2)
def neutralization1(s1: String, s2: String): String = {
s1 + " " + s2 + " " + i
}
neutralization1
}
使用到一个匿名函数进行调用：
val res= neutralization((a,b)=>{a+b})("hello","changsha")
println(res)
3.4.柯里化函数
是对高阶函数的一个简化
def Currie(a: Int, b: Int)(c: Int, d: Int): Int = {
a + b + c + d
}
println(Currie(1, 2)(4, 3))
165
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
