Scala面向对象的基本操作

单例对象

在scala中,使用object创建的对象就是单例对象
object对象不能带参数

类的基本操作

类的定义和构造器

/**
  * @Author: zhm.Feng
  * @Date: 2019/3/19 13:13
  */

//类的主构造器定义在类的后面,使用小括号
class Animal2(name: String, age: Int) {
  println("执行主构造器")
  //使用var修饰的变量提供了getter和setter方法,而使用val修饰的变量只提供了getter方法
  var gender: String = _
  var hobby: Int = _

  //定义一个辅构造器,语法为  def this(){}
  //辅构造器的第一行必须是调用主构造器或者其他辅构造器
  def this(gender: String) {
    this("柯基",5)
    this.gender = gender
  }

  def this(hobby: Int) {
    this("F")
    this.hobby = hobby
  }
}

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

    val ani = new Animal2("F")
    println(ani)
  }
}

访问权限

/**
  * @Author: zhm.Feng
  * @Date: 2019/3/19 14:29
  */

//当构造器私有化之后,是不能直接访问的,需要访问辅构造器
class Animal4 private(name:String,age:Int) {
  def this(){
    this("柯基",5)
    println("访问辅构造器")
  }

}

//private修饰的类只能在当前包及其子包下才能访问
private[scala] class Animal5 (name:String,age:Int){

  def this(){
    this("柯基",5)
    println("访问本包内的构造器")
  }
}

object app4{
  def main(args: Array[String]): Unit = {
    val ani = new Animal4()
  }
}

伴生对象

/**
  * @Author: zhm.Feng
  * @Date: 2019/3/19 18:33
  */
class AnimalApply (name:String,age: Int){

  private val size:String = "XXL"
  def this(){
    this("柯基",5)
    println("哒哒哒")
  }

  def echo: Unit ={
    println("hahaha")
  }
}

//单例对象与某个类共享一个类名时,就叫伴生对象
//类和他的伴生对象可以互相访问私有资源
object AnimalApply{

  {
    println("嘿嘿嘿")
  }
  def apply(name: String, age: Int): AnimalApply ={
    println("调用了伴生对象的方法")
    new AnimalApply(name, age)
  }

  def main(args: Array[String]): Unit = {
    //当创建实例不加参数时,是创建的伴生对象的实例
    val ani = AnimalApply
    //加了参数之后是调用了伴生对象的方法
    val animal = AnimalApply("柯基",5)
    animal.echo
    println(animal.size)

    println(animal)
  }
}

trait : 类似于java中的接口

/**
  * @Author: zhm.Feng
  * @Date: 2019/3/19 18:56
  */
trait Flyable {

  val name:String = "柯基"

  def fly(): Unit ={
    println("I can fly")
  }
  def eat()
}
//无论是实现还是继承都使用extends
class Bird extends Flyable {
  //如果是实现没有方法体的方法,可以去掉override
  def eat(): Unit = {
    println("我吃虫")
  }
  //如果是覆盖已经实现的方法,则必须要override
  override def fly(): Unit = {
    println("我还没长大")
  }
}

class KeJi(name:String){

}


/**
  * @Author: zhm.Feng
  * @Date: 2019/3/19 19:05
  */
object TraitDemo {

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

    val bird = new Bird
    bird.fly()
    bird.eat()

    //在程序中动态继承特质
    val ani = new KeJi("柯基") with Flyable {
      override def eat(): Unit = {
        println("柯基也能飞")
      }
    }
    ani.fly()
    ani.eat()
  }
}

抽象类 : 跟java的抽象类基本相同

继承

//无论是实现还是继承都使用extends
class Bird extends Flyable {
  //如果是实现没有方法体的方法,可以去掉override
  def eat(): Unit = {
    println("我吃虫")
  }
  //如果是覆盖已经实现的方法,则必须要override
  override def fly(): Unit = {
    println("我还没长大")
  }
}

样例类和样例对象

/**
  *样例类,使用 case关键字修饰的类, 其重要的特征就是支持模式匹配
  *样例类默认是实现了序列化接口的
  *样例 object, 不能封装数据, 其重要特征就是支持模式匹配
  */
//样例类
case class Message(msg:String)
//样例对象
case object CheckHeartBeat

模式匹配

匹配字符串

import scala.util.Random

/**
  * @Author: zhm.Feng
  * @Date: 2019/3/19 20:30
  */
object CaseDemo2 {
  def main(args: Array[String]): Unit = {
    val arr = Array("大马猴","大坤坤","大龙猫","大蛤蟆")
    val res:String = arr(Random.nextInt(arr.length))

    res match {
      case "大马猴" => println("斗鱼叫父")
      case "大坤坤" => println("国服增幅王")
      case "大龙猫" => println("永和站神")
      case "大蛤蟆" => println("东营F4")
    }
  }
}

匹配类型

import scala.util.Random

/**
  * @Author: zhm.Feng
  * @Date: 2019/3/19 20:30
  */
object CaseDemo3 {
  def main(args: Array[String]): Unit = {
    val arr = Array("大马猴",1,3.2,Value)
    val res = arr(Random.nextInt(arr.length))

    res match {
      case x:Int => println(s"$x  类型为整数 ")
      case x:String => println(s"$x  类型为字符串 ")
      case x:Double => println(s"$x  类型为小数")
      case x => println(s"$x  类型为 ")
    }
  }
}

匹配元组,集合

/**
  * @Author: zhm.Feng
  * @Date: 2019/3/19 20:58
  */
object CaseDemo4 {
  def main(args: Array[String]): Unit = {
    val arr = Array("haha",1,3.0)
    arr match {
      case Array("haha",_,_)=>println("haha")
      case Array(_,1,_)=>println(1)
      case Array("haha",_,3.0)=>println(3.0)
    }

    val list = List(1,2,"haha")
    list match {
      case List(_,2,_) => println(2)
      case List(_,_,"haha") => println("haha")
      case List(1,_,_) => println(1)
    }

    val tuple = (2,5,8)
    tuple match {
      case (1,_,_) => println(1)
      case (2,5,_) => println(5)
      case (2,_,8) => println(8)
    }
  }
}

同时还可以匹配样例类