[Scala]学习笔记三——面向对象

一、面向对象的概 （Object Oriented——OO）

1.封装： 将属性、方法封装到类中
2.继承： 父类和子类之间的关系
3.多态： 父类引用指向子类对象
多态是面向对象编程的精髓所在，是开发框架的基础

二、类的定义和使用

//main方法
 def main(args: Array[String]): Unit = {
    val person=new Person()
    person.name="Messi"
    println(person.eat)
    person.info
    person.watch("mexico")
}

//定义一个Person类
class Person{
  var name:String=_     				//_为通配符
  val age=10       						   //age定义为val类型了，则不可以改变了
  private [this] val gender="male"      //声明为private[this],则只能在这个类中调用这个属性，在main方法中调用不了

  def watch(team:String): Unit ={
    println(name+" watching race of "+team)
  }
  def eat: String ={
    name+" eat..."
  }
  def info: Unit ={
    println(name+"  "+age+" "+gender)
  }
}

结果：
Messi eat...
Messi  10 male
Messi watching race of mexico

三、主构造器和附属构造器

附属构造器的第一行必须要调用主构造器

//main方法
def main(args: Array[String]): Unit = {
    val person=new Person("Nina",23)
    println(person.age+"   "+person.name+"   "+person.school+"   "+person.gender)
    val person2=new Person("Nina",23,"female")
    println(person2.name+"  "+person2.age+"   "+person2.school+"   "+person2.gender)
}
//主构造器
class Person(val name:String,val age:Int){
    println("Person Constructor start…")
    val school="neu"
    var gender:String=_      		 //用占位符的变量必须先声明其类型
    println("Person Constructor stop…")

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

结果：
Person Constructor start…
Person Constructor stop…
23   Nina   neu   null
Person Constructor start…
Person Constructor stop…
Nina  23   neu   female

四、继承extends和重写override

//main方法
def main(args: Array[String]): Unit = {
    val student=new Student("Nina",23,"computor")
    //println(student.name+"  "+student.age+"   "+student.major)
    println(student)
}
//定义一个Student类，继承Person类
//继承父类的参数可以不用var/val定义，但该类新有的参数需要使用var/val来定义，如下面的major属性
class Student(name:String,age:Int,var major:String) extends Person(name,age){
    println("Student constructor start…")

    override def toString: String ={			//子类继承来的方法和属性都可以重写，需要使用override来声明
      name+"  "+age+"  "+major
    }
    println("Student constructor stop…")
}

结果：
Person Constructor start…
Person Constructor stop…
Student constructor start…
Student constructor stop…
Nina  23  computor

五、抽象类abstract

抽象类是指：类中一个或多个方法没有完整的实现（只有定义，没有实现）

//main方法
def main(args: Array[String]): Unit = {
    val student=new Student()
    student.name="Nina"
    student.age=23
    println(student.name+"  "+student.age)
    student.speak
}

//定义一个抽象类
abstract class People{
  def speak
  var name:String
  var age:Int
}

//定义一个类，继承该抽象类，并实现所有属性和方法
class Student extends People{
  override def speak: Unit = {
    println("speak……")
}
override var name: String = _
override var age: Int = _
}

结果：
Nina  23
speak……

六、伴生类和伴生对象

如果有一个class，还有一个与class同名的object
那么就成这个object是class的伴生对象，class是object的伴生类

七、Apply

1.直接类名. 便可以访问object中的方法和属性

object ApplyApp {
  def main(args: Array[String]): Unit = {
      for(i<-1 to 10)
      TestApply.incu              //直接类名. 便可以访问object中的方法和属性
      println(TestApply.count)
  }
}

//伴生类
class TestApply{
}

//伴生对象
object TestApply{
  println("object TestApply enter...")
  var count=0
  def incu: Unit ={
    count=count+1
  }
  println("object TestApply leave...")
}

结果：
object TestApply enter...
object TestApply leave...
10

2.类名() ==>调用object中的apply()方法

object ApplyApp {
  def main(args: Array[String]): Unit = {
    val a=TestApply()               //类名() ==>调用object中的apply()方法
  }
}

class TestApply{
  println("class TestApply enter...")
  def apply()={
    println("class apply enter...")
  }
  println("class TestApply leave...")
}

object TestApply{
  println("object TestApply enter...")
  def apply()={
    println("object apply enter...")
  }
  println("object TestApply leave...")
}

结果：
object TestApply enter...
object TestApply leave...
object apply enter..

3.对象()==>调用class中的apply()方法

object ApplyApp {
  def main(args: Array[String]): Unit = {
  	//val a=TestApply()               //类名() ==>调用object中的apply()方法
    val b=new TestApply()
    b()                             //对象()==>调用class中的apply()方法
  }
}

class TestApply{
  println("class TestApply enter...")
  def apply()={
    println("class apply enter...")
  }
  println("class TestApply leave...")
}

object TestApply{
  println("object TestApply enter...")
  def apply()={
    println("object apply enter...")
    //new TestApply()                 //最佳实践：在object的apply()方法中new一个class的新对象
  }
  println("object TestApply leave...")
}

结果：
class TestApply enter...
class TestApply leave...
class apply enter...

八、case class

case class 不用new，直接可以使用，通常用在模式匹配中

object CaseClassApp {
  def main(args: Array[String]): Unit = {
    println(Dog("WangCai").name)			//没有new一个Dog对象，而直接使用了
  }
}

case class Dog(name:String){

}

结果：
WangCai

九、trait

XXX extends … with … with… 实现的第一个接口用extends，之后的用with…