Scala学习三-面向对象

Posted 2021-04-24 后端技术学习

前面我们已经学习了特质类似接口，其可以被继承，同时如果需要继承多个特质的话，则需要使用extends…with…进行继承。其类似java中的接口和抽象方法的结合体，但又比java中的其要强大，因为其可以定义抽象字段和普通字段、抽象方法和普通方法。而在java中接口中可以定义常量，不能定义变量。同时特质还可以继承class类，而在java中接口通常是用来实现的。

Object继承trait

//object单例对象继承特质
object OopDemo{
    //定义一个特质，添加方法,monkey会play
    trait Monkey{
        def play(msg:String)
    }

    //定义特质
    trait Eat{
        def eat(msg:String)
    }

    //定义单例对象ProgramMonkey继承上面的两个特质，并重写两个方法
    object ProgramMonkey extends Monkey with Eat{
        override def play(msg:String): Unit = println("monkey会玩很多游戏：" + msg)
        override def eat(msg:String): Unit = println("monkey同样会吃:" + msg )
     }
    def main(args: Array[String]): Unit = {
    //调用programMonkey单例对象中重写的两个方法
     ProgramMonkey.play("玩球球")
     ProgramMonkey.eat("吃香蕉")
   }
}

trait中带成员变量

object OopDemo{
    //定义一个特质Monkey
    trait Monkey{
        //具体字段
        var name = ""
        //抽象字段
        var age:Int
        //具体方法
        def eat() = println("吃香蕉")
        //抽象方法
        def play():Unit
    }

    //定义一个类，继承Monkey特质，重写方法和字段
    class ProgramMonkey extends Monkey{
        //重写抽象字段
        override var age:Int = 28
        //重写父特质中的抽象方法
        override def play(): Unit = println(s"${name}的年龄是${age}，喜欢玩球")
    }

    //main方法
    def main(args: Array[String]): Unit = {
        //创建程序猿对象
        val pm = new ProgramMonkey
        //进行赋值
        pm.name = "程序猿"
        pm.age = 28
        //进行输出
        println(pm.name + "-------" + pm.age)
        //调用方法
        pm.eat()
        pm.play()
    }
}

trait继承class

在scala中，trait可以继承class类，特质会将class中的成员都继承下来

//class 类A{
   //成员变量
   //成员方法  
//}

//trait B extends A{
    //特质B继承A类
//}

object OopDemo{
    //定义类message
    class Message{
        def printMsg()=println("我是一个类")
    }
    //创建特质继承message类
    trait traitMessage extends Message
    //定义类继承特质
    class MyMessage extends traitMessage

    def main(args: Array[String]): Unit = {
        //创建MyMessage类的对象，调用printMsg方法
        val myMessage = new MyMessage
        myMessage.printMsg()
    }
}

样例类

在Scala中，样例类是一种特殊类，一般用于保存数据(类似java中的pojo类)

case class 样例类名([val/var] 成员变量名1:类型1,成员变量名2:类型2,成员变量名3:类型3)

如果不写,则变量的默认修饰符是val，如果要实现某个成员变量值可以被修改，则需手动添加var来修饰此变量.

object OopDemo{
  //创建一个Monkey类
    case class Monkey(name:String="程序猿",var age:Int = 28) {}
  //创建main方法
    def main(args: Array[String]): Unit = {
        //创建对象
        val m = new Monkey
        println(m)
        m.age = 27
        println(m)
    }
}

当我们定义一个样例类后，编译器会自动帮助我们生成一些方法, 常用的如下:

- apply()方法
- toString()方法
- equals()方法
- hashCode()方法
- copy()方法
- unapply()方法

样例对象

在Scala中, **用case修饰的单例对象就叫: 样例对象, 而且它没有主构造器 **, 它主要用在两个地方：

当枚举值使用
作为没有任何参数的消息传递

case object 样例对象名

object OopDemo{
 //定义特质sex   
 trait Sex
 //定义枚举值male、female
 case object Male extends Sex
 case object Female extends Sex

 //定义Monkey(name:String,sex:Sex)
 case object Monkey(name:String,sex:Sex) {}

 //定义main函数
 def main(args: Array[String]): Unit = {
     //创建Monkey类
     val m = Monkey("程序猿",Male)
     println(m)
 }
}

数组

数组就是用来存储多个同类型元素的容器, 每个元素都有编号(也叫: 下标, 脚标, 索引), 且编号都是从0开始数的.
Scala中, 有两种数组，一种是定长数组，另一种是变长数组.

//val/var 变量名 = new Array[元素类型](数组长度)
//val/var 变量名 = Array(元素1,元素2,元素3,...)

object OopDemo{
   def main(args: Array[String]): Unit = {
       var arr1 = new Array[Int](10)
       arr1(0) = 10
       println(arr1(0))

       var arr2 = Array("java","scala","spark")
       println(arr2.length)
   } 
}

变长数组

//导入ArrayBuffer类
import scala.collection.mutable.ArrayBuffer
//创建变长数组
//val/var 变量名 = ArrayBuffer[元素类型]()
//val/var 变量名 = ArrayBuffer(元素1,元素2,元素3,...)

object OopDemo{
   def main(args: Array[String]): Unit = {
       val arr1 = new ArrayBuffer[Int]()
       println("arr1:" + arr1)

       //创建变长数组
       var arr2 = ArrayBuffer("java","kafka","flink")
       println("arr2: " + arr2)
   }
}

进行数组的增删改

使用 += 添加单个元素
使用 - = 删除单个元素
使用 ++= 追加一个数组到变长数组中
使用 -- = 移除变长数组中的指定多个元素
比如：
 arr ++= Array("hive", "spark")

遍历数组

object OopDemo{
  def main(args: Array[String]): Unit = {
    val arr = Array(1,2,3,4,5)
    //进行遍历
    for(i<- to arr.lengt - 1)println(arr(i))
    //遍历方式二
    for(i<- until arr.length)println(arr(i)) 
    //遍历方式三
    for(i<-arr)print(i)  
  }
}

数组常用算法

sum() 方法: 求和
max() 方法: 求最大值
min() 方法: 求最小值
sorted() 方法: 排序, 返回一个新的数组.
reverse() 方法: 反转, 返回一个新的数组.
如：val arr2 = arr.sorted

元组

元组一般用来存储多个不同类型的值。例如同时存储姓名，年龄，性别，出生年月这些数据, 就要用到元组来存储
了。并且元组的长度和元素都是不可变的。

val /var 元组 = (元素1, 元素2, 元素3....)
val /var 元组 = 元素1->元素2

object OopDemo{
  def main(args: Array[String]): Unit = {
    val tuple1 = ("程序员",28)
    val tuple2 = "程序猿"->27
    //进行输出
      println(tuple1)
      println(tuple2)
  }
}

遍历元组

在Scala中, 可以通过 元组名 ._编号 的形式来访问元组中的元素，_1表示访问第一个元素，依次类推.
也可以通过 元组名 .productIterator 的方式, 来获取该元组的迭代器, 从而实现遍历元组.

object OopDemo{
  def main(args: Array[String]): Unit = {
    val tuple1 = ("程序员",28)
    val tuple2 = "程序猿"->27
    //进行迭代
      println(s"名称: ${tuple1._1},年龄: ${tuple1._2}")
      val it = tuple2.productIterator
      for(i <- it)println(i)
  }
}

列表

列表(List)是Scala中最重要的, 也是最常用的一种数据结构。它存储的数据, 特点是: 有序, 可重复.
在Scala中，列表分为两种, 即: 不可变列表和可变列表.

//val/var 变量名 = List(元素1,元素2,元素3,...)
//val /var 变量名 = Nil
//val /var 变量名 = 元素1 :: 元素2 :: Nil

object OopDemo{
 def main(args: Array[String]): Unit = {
  val list1 = List(1,2,3,4)
  val list2 = Nil
  val list3 = -2:: -1 :: Nil
  //进行输出
  println(s"list1: ${list1}")
  println(s"list2: ${list2}") 
  println(s"list3: ${list3}")
 }
}

列表的常用操作

在scala的列表中，还可以实现扁平化

object OopDemo{
  def main(args: Array[String]): Unit = {
  //1. 定义一个列表, 该列表有三个元素, 分别为：List(1,2)、List(3)、List(4,5)
  val list1 = List(List(1,2), List(3), List(4, 5))
  //2. 使用flatten将这个列表转换为List(1,2,3,4,5)
  val list2 = list1.flatten
  //3. 打印结果
  println(list2)
 }
}

同时由于set和map和java中的类似，这里就不展示出来了，同时有一点差别在于函数式编程api上，不需要写stream进行操作，而是直接调用函数式方式，同时操作比java更方便。