专栏首页后端技术学习Scala学习三-面向对象

Scala学习三-面向对象

前面我们已经学习了特质类似接口,其可以被继承,同时如果需要继承多个特质的话,则需要使用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更方便。

本文分享自微信公众号 - 后端技术学习(gh_9f5627e6cc61),作者:路行的亚洲

原文出处及转载信息见文内详细说明,如有侵权,请联系 yunjia_community@tencent.com 删除。

原始发表时间:2020-10-08

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • Scala学习二-面向对象

    适用于var变量,对于val不适用,注意如果使用下划线进行初始化,此时必须提供数据类型,这样就可以进行自动推断赋初始值

    路行的亚洲
  • Kafka流程流转-服务端

    kafka分为客户端和服务端,通常我们知道broker是服务端,而生产者和消费者作为客户端。因此在服务端就必定需要解决并发和网络IO的问题。因此不可避免需要用到...

    路行的亚洲
  • ArrayList源码学习

    ArrayList是一种以数组实现的列表,而数组的优势在于有角标,因此查询的速度较快,是一种可以动态扩容的数组。我们着重了解添加、获取、替换、删除操作。

    路行的亚洲
  • 大数据利器--Scala语言学习(高级)

    ListBuffer:ListBuffer 是可变的 list 集合,可以添加,删除元素,ListBuffer 属于序

    MiChong
  • 【Scala篇】--Scala中集合数组,list,set,map,元祖

    备注:数组方法 1     def apply( x: T, xs: T* ): Array[T] 创建指定对象 T 的数组, T 的值可以是 Unit, Do...

    LhWorld哥陪你聊算法
  • Python进阶|装饰器的那些事(二)

    之前我们的案例都是用函数作为装饰器,类也是可以做为装饰器的,这个主要是需要用到__call__。

    罗罗攀
  • 如何在微信浏览器内打开App Store链接

    比如你页面写 <a href=”http://itunes.apple.com/us/app/id399608199″>download</a> ,在微信浏览器...

    德顺
  • 函数 (三) 装饰器

    一 为何要用装饰器 有的时候写完一段代码,过段时间需要对它进行升级、添加一些新功能,但是如果要直接修改原来的代码会影响其他人的调用,所以就需要一个不修改源代码且...

    人生不如戏
  • 用GeoGraphics可视化嫦娥四号着陆点

    前不久中国成功地向月球的背面发射了着陆器和月球车。月球车降落在直径为2500公里的艾特肯撞击盆地。该盆地是太阳系中最大的撞击结构之一。在Wolfram语言中,可...

    WolframChina
  • 大三小白初次接触封闭式开发总结

    学院大三的期末似乎总是这样,会在6月初的时候不是自己出去找到实习,不然就会要求你去到学校安排的实习中去(自己选择实习的方向),所以在我选择了Java Web方向...

    我没有三颗心脏

扫码关注云+社区

领取腾讯云代金券