Scala入门整理，九九乘法表，运算符

一，建立scala class

定义类
变量 var
常亮 val

package com.dyb.lianxiobject TestRiKao {def main(args: Array[String]): Unit = {var t="hello scala"println(t)var s="hello word"println(s)}
}

常量和变量

1)定义
常量:是在运行的过程中,其值不会发生变化的量例如:数值3 字母A 修饰的关键字val
变量:是在运行的过程中,其值可以发生变化的量例如:时间,年龄修饰的关键字var
2)语法
val name:Type=变量值
var name:Type=变量值
注意1：
类型可以不写，scala 可以自动类型推断
注意2:变量名称必须符合命名规范,不能使用关键字(命名规范和java一样)
1.字母,下划线,数字组成,并且不能以数字开头
val 4_tablename=“t_user”;
2.变量名要做到见名知意,(如果英文不好我们通过通过有道翻译)
3.用驼峰命名法命名多个单词组成的变量名
val tablename=“t_user”;
4.变量名不能使用关键字
val def =12

scala中的数据类型

cala中的数据数据类型
any是所有类型的超类,也成为顶级类型
anyVal (值类型) :
int short byte long double string char boolean Uint (9个)
长度4 2 1 8 8 4 2 1
anyRef(引用类型) :
List map option yourclass …
注意:java类型中没有和scala中Nothing对应的类型

for循环

package com.dyb.testobject Test {def main(args: Array[String]): Unit = {//三种遍历方式var list=Array(1,2,3,4)for(i <- 0 until  list.length){println(list(i))}/*for (i<-list){println(i)}*//*  for (j <- 0 until(list.length)){println(list(j))}*//* list.foreach(line=>{println(line)})*///计算数组所有元素的和/* var sum=0;for (i <- 0 until(list.length)){sum+=list(i)}println(sum)*/}
}

循环加运算
实例

//3.统计三个班的成绩情况,每个班有五名同学,每位同学的成绩自己输入,求出每个班的平均分和所有班级的平均分?var sum=0for(j <- 1 until(4)){println("请输入第"+j+"个班级的成绩")var sum1=0for(a <- 1 until(6)){println("请输入第"+a+"名同学的分数:")var score=readInt()sum1+=score}println(j+"班的五名同学总分数是："+sum1)sum+=sum1}println("所有三个班级的平均分是："+sum/3)

for循环嵌套九九乘法表

println("----------------九九乘法表-------------------------")for (j <- 1 until(10)){for(i <- 1 until(j+1)){print(i+"*"+j+"="+j*i+" ")}print("\n");}

插值器


9.差值器scala中有三种插值器1.在任何字符串前面加上s,就可直接在字符串中使用变量了val name:String="cat"println(s"she is name is ${name}")2.f插值器: val height=1.23568println(f"身高是${height}%.2f")3.raw插值器:是输入字符串原样,不进行转义 例如://没有使用rawprintln("a\nb\n\tc")//使用的效果println(raw"a\nb\n\tc")

 var name="didi"println(s"dsscjeiff : ${name}")var s=1.845623println(f"身高：${s}%.2f")println("aaaa\na\t1\nn")println(raw"aaaa\na\t1\nn")//原样输出println(raw"\mn\ndfe\n")*/

访问修饰符

访问修饰符
private :一个类的内部可用
protected:自己类子类也可以被访问(这个比java更加严格,java同一个包的其他类也可以访问)
public ::如果没有指定修饰符 ,这样的成员在任何地方都可以被访问
注意:
如果不指定的情况下,就是public
实例1:(只能自己访问)
class Test01 {
private val name = “毕老师”
def main(args: Array[String]): Unit = {
println(name)
}
}
实例2:
class Test01 {
protected val name = “毕老师”
}
class Test02 extends Test01 {
def main(args: Array[String]): Unit = {
println(name)
}
}
实例3:
object Test {
def main(args: Array[String]): Unit = {
val test0 = new Test01
println(test0.name)
}
}
class Test01 {
val name = “毕老师”
}

运算符

 算术运算符:加 减 乘 除 取余object Test {def main(args: Array[String]) {val a = 100val b = 200val c = 250val d = 250println("a 加 b = " + (a + b))println("a 减 b = " + (a - b))println("a 乘 b = " + (a * b))println("b 除 a = " + (b / a))println("b 取余 a = " + (b % a))}}关系运算符: ==  !=  > < >=  <=object Test {def main(args: Array[String]) {val a = 100val b = 200println("a 等于 b     是: " + (a == b))println("a 不等于 b   是: " + (a != b))println("a 大于 b     是: " + (a > b))println("a 小于 b      是: " + (a < b))println("b 大于等于 a 是: " + (b >= a))println("b 小于等于 a 是: " + (b <= a))}}逻辑运算符:&&  ||  !object Test {def main(args: Array[String]) {var a = true;var b = false;println(a&&b)println(a||b)println(!a)}} 赋值运算符:  =  +=  -=  *=  /=  %=  var a = 10;val b = 20;var c = 0;c = a + b;println(c);var a = 10;    var c = 0;c += a ;println( c );var a = 10;    var c = 0;c -= a ;println( c );var a = 10;    var c = 0;c *= a ;println("c *= a = " + c );val a = 10;var c = 15;c /= a ;println("c /= a  = " + c );val a = 10;var c = 15;c %= a ;println("c %= a  = " + c );

类型转换

类型转换1)String 类型转换为Intval age:String ="123"println(age.toInt.getClass.getName)2)Int 类型转换为Stringval b:Int =123println(b.toString.getClass.getName)3)String类型转换为Float类型val c:String ="123.123"println(c.toFloat.getClass.getName)

生成随机数

val int = Random.nextInt(10)println(int)var a:Int=scala.util.Random.nextInt(100)

获取字符串的首尾字符

//获取首字符??
"Hello"(0)
"Hello".take(1)
//获取尾字符??
"Hello".reverse(0)
"Hello".takeRight(1)

懒加载

1)scala 中使用lazy 关键字修饰变量，就是惰性变量，实现延迟加载
注意:惰性变量只能是常量,并且只有在调用惰性变量时，才会去实例化这个变量
2)案例演示
//正常的
var str = {
println(“helloworld”)
}
//懒加载的形式
lazy val str1 = {
println(“helloworld”)
}
//调用这个变量
str1
3)好处
使用在比较耗时的业务中,如网络IO 磁盘IO