scala-第四章-scala面向对象

目录

面向对象概述
类的定义与使用
构造器
继承与重写
抽象类
伴生类和伴生对象
apply
case class
trait

面向对象概述

Java/Scala OO
    封装：属性、方法封装到类中
    	Person:
         		private int id ,String name,Date birthday ... getter/setter
           	eat/sleep...
    继承：父类和子类之间的关系
    	User extends Person
     		exam......
    多态：父类引用指向子类对象，精髓所在，开发框架的基石
    	Person person = new Person();
     	User user = new User();
      	Person person = new User();

类的定义与使用

package com.imooc.scala.course04

object SimpleObjectApp {
  def main(args: Array[String]): Unit = {
    val person = new People()
    person.name = "卢本伟"
    println(person.name + "..." + person.age)
    println("invoke eat method:"+person.eat())
    person.watchFootball("Barcelona")
    person.printInfo()

  }
}

class People {
  // 定义属性
  var name: String = _//_表示占位符
  val age: Int = 10

  private [this] val gender="male"//只能在class内部可以使用
  def printInfo(): Unit ={
    println("gender "+gender)
  }

  def eat(): String = {
    name + "eat..."
  }

  def watchFootball(teamName: String): Unit = {
    println(name + "is watching match of " + teamName)
  }
}

构造器

package com.imooc.scala.course04

object ConstructorApp {
  def main(args: Array[String]): Unit = {
    val person = new Person("张三", 30)
    println(person.name + ":" + person.age + ":" + person.school)

    val person2 = new Person("卢本伟", 20,"M")
    println(person2.name + ":" + person2.age + ":" + person2.school + ":" + person2.gender)
  }
}

//主构造器
class Person(val name: String, val age: Int) {
  println("Person 进来了")

  val school = "ustc"
  var gender: String = _

  //附属构造器
  def this(name: String, age: Int, gender: String) {
    this(name, age) //附属构造器第一行代码必须要调用主构造器或者其他附属构造器
    this.gender = gender
  }

  println("Person 退出了")
}

继承与重写

package com.imooc.scala.course04

object ConstructorApp {
  def main(args: Array[String]): Unit = {
    val student = new Student("卢本伟", 18, "Math")
    println(student.name + ":" + student.major)

    println(student.toString)
  }
}

//主构造器
class Person(val name: String, val age: Int) {
  println("Person 进来了")

  val school = "ustc"
  var gender: String = _

  //附属构造器
  def this(name: String, age: Int, gender: String) {
    this(name, age) //附属构造器第一行代码必须要调用主构造器或者其他附属构造器
    this.gender = gender
  }

  println("Person 退出了")
}

// major: String 前面如果不写var外部是无法访问的
class Student(name: String, age: Int, var major: String) extends Person(name, age) {
  println("学生类 进来了")
  println("学生类 退出了")

  //重写要用override关键字，只要涉及到继承那么就可以使用 override 对父类有的属性和方法进行重写
  override val school="lll"
  override def toString: String = "def toString :"+school

}

抽象类

package com.imooc.scala.course04

object AbstractApp {
  def main(args: Array[String]): Unit = {
    val student=new Student2()
    println(student.name)
    student.speak
  }
}

/**
 * 类的一个或者多个方法没有完整的实现(只有定义没有实现)
 */

abstract class Person2{
  def speak
  val name:String
  val age:Int
}

class Student2 extends Person2{
  override def speak: Unit = {
    println("speak ...")
  }

  override val name: String = "PK"
  override val age: Int =18
}

伴生类和伴生对象

package com.imooc.scala.course04

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

  }
}

// 伴生类和伴生对象
// 如果有一个class 还有一个与class同名的object，那么就称为object是class的伴生对象，class是object的伴生类
class  ApplyTest{

}
object ApplyTest{
  
}

apply

package com.imooc.scala.course04

object ApplyApp {
  def main(args: Array[String]): Unit = {
    for (i <- 1 to 10){
      ApplyTest.incr
    }
    println(ApplyTest.count) // 10 ，说明object本身就是一个单例对象
    println("--------------------------")

    val b=ApplyTest()// 默认调用了object.apply里的方法
    println("---------------------------------------")
    val c=ApplyTest()//
    println(c)
    c()
    // 类名() -> Object.apply
    // 对象() -> Class.apply
    // 最佳实践：在object的apply方法中去new Class


  }
}

// 伴生类和伴生对象
// 如果有一个class 还有一个与class同名的object，那么就称为object是class的伴生对象，class是object的伴生类
class ApplyTest {
  def apply(): Unit ={
    println("class ApplyTest apply...")
  }
}

object ApplyTest {
  println("object AppltTest 进来")
  var count = 0

  def incr = {
    count = count + 1
  }

  def apply()={
    println("object ApplyTest apply...")
    // 在object中的apply中new了一个class
    new ApplyTest
  }

  println("object AppltTest 离开")

}

总结
// 伴生类和伴生对象
// 如果有一个class 还有一个与class同名的object，那么就称为object是class的伴生对象，class是object的伴生类
// 类名() -> Object.apply
// 对象() -> Class.apply
// 最佳实践：在object的apply方法中去new Class

case class

package com.imooc.scala.course04

// 通常用在模式匹配
object CaseClassApp {
  def main(args: Array[String]): Unit = {
    println(Dog("hhh").name)
  }
}

// case class 不需要new
case class Dog(name: String)

// 普通case class和普通的class没什么区别，唯一的不同就是不用new

trait

Trait xxx extends ATrait with BTrait
class SparkConf(loadDefaults:Boolean)
    extends Cloneable
    with Logging
    with Serializable