Scala---面向对象

单例对象:object

object Oop1 {
  println("-------1-----")
  def showInfo():Unit={
    println("-------2-----")
    println("this is oop1 test")
  }
  println("-------3-----")
}

object TestOop1 {
  def main(args: Array[String]): Unit = {
    Oop1.showInfo()
  }
}

【注意：执行顺序】

【在第一次调用方法时，会将object中的所有的和相关方法进行初始化】

object Oop1 {
  println("-------1-----")
  def showInfo():Unit={
    println("-------2-----")
    println("this is oop1 test")
  }
  println("-------3-----")
}

object TestOop1 {
  def main(args: Array[String]): Unit = {
    Oop1.showInfo()
    Oop1.showInfo()		//创建第二个
  }
}

【注意：第二次调用方法的时候，仅仅调用了对应的方法】

伴生类(class)、伴生对象(object)

/*
*  伴生类---伴生对象：class A 和 object A 在同一个文件中，称为 互为伴生
*/

class Oop1(name:String,age:Int){   //伴生类，Scala中默认构造函数(括号里的)--主构造方法
  println("-----class 1-----")
  var uaddress = ""
  println(this.name+"\t"+this.age)

  def this(name:String){   //有一个参数 -- 辅助构造方法
    this(name,0)
  }
  def this(){              //无参 -- 辅助构造方法
    this("Jack",0)
    println("构造器")
  }
  def this(name:String,age:Int,address:String){
    this(name,age)
    uaddress = address
  }
//  def show(): Unit ={
//    println("name    "+name+"    age    "+age+"    address    "+uaddress+"    country    "+Oop1.country)
//  }

  override def toString: String = {
    "name    "+name+"    age    "+age+"    address    "+uaddress+"    country    "+Oop1.country
  }



  println("-----class 2-----")
}

object Oop1 { //伴生对象
  private val country = "中国"

  def apply(name: String, age: Int): Oop1 = new Oop1(name, age)  //调用class的构造方法，创建对象的时候就不用new了

  def apply(): Oop1 = new Oop1()

  def apply(name: String, age: Int,address:String): Oop1 = new Oop1(name, age,address)

  println("-------object 1-----")

  def showInfo():Unit={
    println("-------object 2-----")
    println("this is oop1 test")
  }

  println("-------object 3-----")

  def main(args: Array[String]): Unit = {
//    Oop1.showInfo()
//    Oop1.showInfo()

//    var o1 = new Oop1("Tom",34)   //创建伴生类的对象时,先调用伴生对象（object）中的信息,在调用class中的信息
    var o2 = new Oop1("buck",23,"南京")  //创建class对象
    println(o2)
    val o3 = Oop1("Hudie",23)    //创建object对象 ,在object 中添加apply方法，去调用class构造方法 1
    val o4 = Oop1()              // 2
    val o5 = Oop1("fang",52,"北京") //3
    val o6 = Oop1.apply()        //相当于2
    println(o3)
    println(o4)
    println(o5)
//    o2.show()
//    var o3 = new Oop1("Louis")
  }
}

抽象类

abstract class Car {  //抽象类
  def brand:String    //抽象方法
  def engine:String
  def speaker():Unit={ //非抽象方法
    println("嘀嘀嘀...")
  }
}
class Bmw extends Car{
  override def brand: String = {  //重写抽象方法
    println("BMW x6")
    return "BMW x6"
  }

  override def engine: String = {
    println("3.0TFSI 涡轮增压")
    "3.0TFSI 涡轮增压"
  }
}
object carTest{
  def main(args: Array[String]): Unit = {
    val bwm = new Bmw
    bwm.brand
    bwm.engine
    bwm.speaker()
  }
}

特质 trait

相当于Java中的接口，但是特质中可以定义函数体
实现特质中的抽像方法，必须使用 override
使用类来实现接口的时候，使用 with 关键字

trait Type1{ 
  def wheel:String={
    println("四个轮子")
    "四个轮子"
  }
}

trait Type2{
  def fly(): Unit ={
    println("飞上天空")
  }

  def downToSea():Unit
}

测试类

class Bmw extends Car with Type1 with Type2 {		//继承抽象类的同时实现多个特征
  override def brand: String = {  //重写抽象方法
    println("BMW x6")
    return "BMW x6"
  }

  override def engine: String = {
    println("3.0TFSI 涡轮增压")
    "3.0TFSI 涡轮增压"
  }

  override def downToSea(): Unit = {
    println("不能下海")
  }
}

main方法

object CarTest{
  def main(args: Array[String]): Unit = {
    val bwm = new Bmw		//创建对象，就可以调用对应的方法
	bwm.brand
	bwm.engine
	bwm.speaker()
	bwm.wheel
	bwm.fly()
 	bwm.downToSea()
 	}
}

还有一种写法，在创建对象的时候在 实现 特征，称之为混入特质

这种写法虽然比较麻烦，每一次定义是都要重写对应的方法，但是写法比较灵活，可以随便实现某个特征，而不比满足这个类的规范

val mzd = new Mazida with Type1 with Type2 {   //混入特质
      override def downToSea(): Unit = {
        println("可以但没必要下海")
      }

      override def wheel: String = {
        println("两个轮子")
        "两个轮子"
      }
    }
    mzd.fly()
    mzd.downToSea
    mzd.wheel