Scala总结（一）

Leefs 2021-03-10 PM 1747℃ 0条

# 13.Scala总结（一）

### 一、基础

**1.1  数据类型**

Scala 与 Java有着相同的数据类型，下表列出了 Scala 支持的数据类型：

**1.2 变量和常量的声明**

`var:`声明变量

`val:`声明常量

变量： 其值可能发生改变的量叫做变量。

常量： 其值不会发生变化的量叫做常量。

示例

```
var age = 18
var name = "李林超博客"
val sex = "male"
```

常量不可再赋值

**1.3 类型转换**

**隐式转换**

> Byte -->  Short (Char) -- > Int --> Long -->  Float --> Double

如上对象类型，两两之间是没有任何关系的，但是Scala通过隐式转换规则将Byte转换为Int类型。

也是可以跨级隐式转换的，比如 Byte *--> Int*

**示例**

```scala
object Scala_DataType {

def main (args : Array[String]) : Unit = {

val b : Byte = 10
    val s : Short = b  //  Byte  隐式转换为 Short 类型
    val i : Int = s    //  Short 隐式转换为 Int 类型
    val i1 : Int = b   //  Byte  隐式转化为 Int 类型

println(i)
    
  }

}
```

**强制类型转换**

将精度大的类型转换为精度小的类型，称为强制类型转换

如何实现强制类型转换？

> + 在java中，采取截取的方式，在结果前面加上强转符 
> + 在Scala中，采取方法转换的方式。如：对象.toByte 
> + Scala的值对象类型之间都提供了相应转换的方法。

**示例**

```scala
// 例题1
val i: Int = 12
val b = i.toByte
println(b)
// 例题2
val i: Int = 66
val b = i.toChar
println(b)
// 例题3
val i: Int = 129
val b = i.toByte
println(b)
```

输出结果

```
12
B
-127
```

**1.4 类和对象**

> 类：class
>
> 对象：Object

**示例**

创建类

```scala
class Person {
  val name = "zhangsan"
  val age = 18
  def sayName() = {
    "my name is "+ name
  }
}
```

创建对象

```scala
object Lesson_Class {
   def main(args: Array[String]): Unit = {
      val person = new Person()
      println(person.age);
      println(person.sayName())
   }
}
```

伴生类和伴生对象

```scala
class Person(xname:String , xage:Int) {
  var name = Person.name // 对象的name
  val age = xage
  var gender = "m"
  def this(name:String, age:Int, g:String) {
    this(name, age)
    gender = g
  }
  
  def sayName() = {
    "my name is "+ name
  }
}

object Person {
  val name = "zhangsanfeng"
  
  def main(args: Array[String]): Unit = {
    val person = new Person("wagnwu",10,"f")
    println(person.age);
    println(person.sayName())
    println(person.gender)
  }
}
```

+ scala 中的`object`是单例对象，相当于java中的工具类，可以看成是定义静态的方法的类。
+ object不可以传参数。另：Trait不可以传参数
+ scala中的`class`类可以传参数，传参就有了`默认的构造函数`
+ 重写构造函数，第一行必须调用`默认构造函数`：`this(参数1, 参数2, …)`
+ class 类属性默认就有`getter`，`setter`方法
+ 使用`object`时不用new；使用`class`时要new ,并且new的时候，class中除了`普通方法`不执行，其他都执行
+ 在`class`类的方法外面，可以直接print；`new 类` 时就打印
+ 如果在同一个文件中，`object对象`和`class类`的`名称相同`，则这个`对象`就是这个类的`伴生对象`，这个类就是这个对象的`伴生类`。可以互相访问`私有变量`(访问级别：`private`)
+ 同一个包下，`两个class` 类名不能相同！重载也不行！

**Apply方法**

使用此方法时，可以在main函数中不通过new来创建一个对象，即可以不用专门的一次一次地进行实例化，加载创建对象的这个类的时候，会自动调用apply方法，类似Java中的static静态块。

示例

```scala
object ScalaDemo01 {
  def main(args: Array[String]): Unit = {
    val p = new Person("zhangsan",19)
     val person = Person("wagnwu",20)   //不用使用new来创建一个实例
  }
}

class Person(xname :String , xage :Int){
  val name = "zhangsan"
  val age = xage
  var gender = "m"
  def this(name:String,age:Int,g:String){
    this(name,age)
    gender = g
  }
}

object Person{
  def apply(name:String,age:Int)={
    new Person(name,age)  
  }
}
```

**1.5 if语句**

```scala
val age =18 
if (age < 18 ){
    println("no allow")
}else if (18<=age&&age<=20){
    println("allow with other")
}else{
    println("allow self")
}
```

**1.6 for,while**

**1.6.1 to和until**(不带步长，带步长区别)

> + 1 to 10 返回1到10的Range数组，包含10
>
> + 1 until 10 返回1到10 Range数组 ，不包含10

```scala
println(1 to 10 )//打印 1, 2, 3, 4, 5, 6, 7, 8, 9, 10

println(1 to (10 ,2))//步长为2，从1开始打印 ，1,3,5,7,9

println(1 until 10 ) //不包含最后一个数，打印 1,2,3,4,5,6,7,8,9

println(1 until (10 ,3 ))//步长为2，从1开始打印，打印1,4,7
```

**1.6.2 for循环**

可以在for循环中加入条件判断

**示例**

```scala
var count = 0;
for(i <- 1 to 10; j <- 1 until 10;if (i%2) == 0){
    println("i="+ i +",j="+j)
    count += 1
}
println(count);
    
//例子： 打印九九乘法表
for(i <- 1 until 10 ;j <- 1 until 10){
    if(i>=j){
        print(i +" * " + j + " = "+ i*j+"	")  
    }
    if(i==j ){
        println()
    }
}
```

**yield关键字**

yield关键字能够将符合要求的元素自动封装到一个集合中

示例

1-100集合中的偶数存储到另一个集合

```scala
val rest = for(i <- 1 to 100; if i%2 == 0) yield i     //此时rest就为选择出的i构成的一个集合
for(elem <- rest) println(elem)
```

**1.6.3 while循环**

+ while（）{}

+ do {}while()

示例

```scala
//while（）{}
var index = 0 
while(index < 100 ){
    println("第"+index+"次while 循环")
    index += 1 
}
//do {}while()
index = 0 
do{
    index +=1 
    println("第"+index+"次do while 循环")
}while(index <100 )
```

*附：参考文章链接*

*https://blog.csdn.net/hjy1821/article/details/83751384*

*https://blog.csdn.net/qq_39437513/article/details/108674551*

*https://www.jianshu.com/p/8a216c71e125*

标签: Hadoop, Spark, Scala

非特殊说明，本博所有文章均为博主原创。

如若转载，请注明出处：https://lilinchao.com/archives/1221.html

上一篇 Spark核心概念

下一篇 Scala总结（二）--函数

Scala总结（一）

评论已关闭

栏目分类

标签云

友情链接申请

Scala总结（一）

评论已关闭

 栏目分类

标签云

友情链接申请

栏目分类

标签云

友情链接申请