[阿强的自学之路]----Scala学习笔记 Day09:面向对象5 抽象类和伴生对象

抽象类：

定义没有方法体的方法，该方法由其子类来具体的实现。该没有方法体的方法我们称之为抽象方法，含有抽象方法的类我们称之为抽象类。

抽象类可以理解为是一个只有方法声明没有方法体的特殊类。

举例：水果，动物。。

 

基本语法：

（1）定义抽象类：abstract class Person{} //通过  abstract 关键字标记抽象类
（2）定义抽象属性：val|var name:String //一个属性没有初始化，就是抽象属性
（3）定义抽象方法：def   hello():String //只声明而没有实现的方法，就是抽象方法

注意：只要出现抽象属性和方法，一个是抽象类，但是一个抽象类中可以有非抽象属性和方法。

 

继承和重写：

（1）如果父类为抽象类，那么子类需要将抽象的属性和方法实现，否则子类也需声明为抽象类。
（2）重写非抽象方法需要用  override修饰，重写抽象方法则可以不加  override。
（3）子类中调用父类的方法使用 super关键字。
（4）子类对抽象属性进行实现，父类抽象属性可以用  var修饰；

子类对非抽象属性重写，父类非抽象属性只支持 val类型，而不支持 var。

object Test_Abs {
  def main(args: Array[String]): Unit = {
    val stu1 : PersonAbs = new StudentAbs
    println(stu1.name)
    println(stu1.age)
    stu1.m2()
    stu1.m1()
  }
}
abstract class PersonAbs(){
  //抽象属性
  val name:String
  //非抽象属性
  val age :Int = 23
  //抽象方法
  def m1():Unit
  //非抽象方法
  def m2():Unit={
    println("我是父类方法")
  }
}
class StudentAbs() extends PersonAbs{
  override val age:Int = 22//重写的非抽象属性只能是val
  val name: String = "jim"

  def m1(): Unit = {
    super.m2()//调用父类的方法
    println("我是子类继承父类的抽象方法")
  }

}

匿名子类：

object Test_Anno {
  def main(args: Array[String]): Unit = {
    val person : PersonAnn = new PersonAnn {
      override val name: String = "john"

      override def m1(): Unit = println("123")
    }
    println(person.name)
    person.m1()
  }
}
abstract class PersonAnn{
  val name :String
  def m1():Unit
}

伴生对象：

Scala语言是完全面向对象的语言，所以并没有静态的操作（即在Scala中没有静态的概 念）。

但是为了能够和Java语言交互（因为Java中有静态概念），就产生了一种特殊的对象 来模拟类对象，该对象为单例对象。

若单例对象名与类名一致，则称该单例对象这个类的伴 生对象，这个类的所有“静态”内容都可以放置在它的伴生对象中声明。

说明：

（1）单例对象采用 object 关键字声明
（2）单例对象对应的类称之为伴生类，伴生对象的名称应该和伴生类名一致。
（3）单例对象中的属性和方法都可以通过伴生对象名（类名）直接调用访问。

package com.scala.learn
//测试伴生类和伴生对象
object Test_Company {
  def main(args: Array[String]): Unit = {
    //val personCom = new PersonCom("bob",23) 无法调用主构造方法
    val personCom = PersonCom.NewPerson("bob",23)
  }
}
//class PersonCom (name:String,age:Int){
class PersonCom private(name:String,age:Int){//将构造方法私有化 这样将无法初始化
  def printInfo(): Unit ={
    println(s"person name = $name age = $age school = ${PersonCom.school}")
  }
}
object PersonCom{
  //相当于新建一个static修饰的方法
  def NewPerson(name:String,age:Int):PersonCom = {
    new PersonCom(name,age)
  }
  val school:String = "CSDN"//相当于在java中用static修饰的变量
}

使用apply命名时可以简化调用的过程：

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

val personCom2 = PersonCom("jim",24)

注意这是调用了伴生对象的apply方法，而不是new一个对象。