Scala 面向对象（中）

3.2、抽象类的继承与重写

1. 如果父类为抽象类，那么子类需要将抽象的属性和方法实现，否则子类也需声明为抽象类
2. 重写非抽象方法需要用 override 修饰，重写抽象方法则可以不加 override。
3. 子类中调用父类的方法使用 super 关键字
4. 子类对抽象属性进行实现，父类抽象属性可以用 var/val 修饰；
5. 子类可以直接对一个被 var 修饰的变量进行赋值来实现重写，不需要使用 override 关键字，所以对于非抽象属性，不建议用 var 修饰。

abstract class Person9{//抽象属性val name: String//非抽象属性val age: Int = 18 //被val 修饰 子类需要重写var school = "山西农业大学" //被var修饰 子类不需要重写//抽象方法def hello():Unit//非抽象方法def eat(): Unit = {println("person eat")}}class Student9 extends Person9{//实现抽象属性val name: String = "李元芳"//实现抽象方法def hello(): Unit = {println("hello")}//重写非抽象属性override val age = 10school = "北京中医药大学"  //父类中被 var 修饰的非抽象变量可以直接重新赋值 不需要重写 所以不建议非抽象属性用 var 修饰//重写非抽象方法override def eat(): Unit = {super.eat()println("student eat")}}

4、匿名子类

匿名子类，也就是说不需要继承抽象父类，直接在定义对象的时候重写抽象属性和方法。

object Test {def main(args: Array[String]): Unit = {val person:Person10 = new Person10 {override var name: String = "GG Bond"override def hello(): Unit = {println("hello gays")}println(person.name)person.hello()}}}//定义抽象类
abstract class Person10{//定义抽象属性和方法var name: Stringdef hello(): Unit}

5、单例对象（伴生对象）

说明

• 单例对象采用 object 关键字声明
• 单例对象对应的类称之为伴生类，伴生对象的名称应该和伴生类名一致。
• 单例对象中的属性和方法都可以通过伴生对象名（类名）直接调用访问。
• 伴生类和伴生对象必须名字相同且在一个文件中。

object Test {def main(args: Array[String]): Unit = {val bob = new Student11("bob", 18)bob.printInfo()}}//定义伴生类
class Student11(val name: String,val age: Int){def printInfo(): Unit = {println(s"${name} ${age} ${Student11.school}")}}
//定义伴生对象
object Student11{val school: String = "北京中医药大学"}

5.1、主构造器私有化

        有些时候我们不希望直接通过主构造器来创建对象实例，而是通过工厂方法来创建对象，在Scala中，我们可以借助伴生对象和伴生类可互相调用的特点来实现：

我们需要在伴生类的主构造器参数前使用 private 关键字进行修饰：

object Test {def main(args: Array[String]): Unit = {
//    val bob = new Student11("bob", 18)
//    bob.printInfo()val bob = Student11.newStudent("bob", 18)bob.printInfo()}}//定义伴生类
class Student11 private (val name: String,val age: Int){def printInfo(): Unit = {println(s"${name} ${age} ${Student11.school}")}}
//定义伴生对象
object Student11{val school: String = "北京中医药大学"//定义一个类的对象实例的创建方法(工厂方法)def newStudent(name: String,age: Int): Student11 = {new Student11(name,age)}}

5.2、apply方法

使用 apply方法来实现工厂模式，可直接使用类名来创建对象，不需要显式地使用apply方法。

object Test {def main(args: Array[String]): Unit = {val alice = Student11.apply("alice",10)val tom = Student11("alice",10) //scala 调用apply方法可以省去方法名 简化代码alice.printInfo()tom.printInfo()}}//定义伴生类
class Student11 private (val name: String,val age: Int){def printInfo(): Unit = {println(s"${name} ${age} ${Student11.school}")}}
//定义伴生对象
object Student11{val school: String = "北京中医药大学"def apply(name: String,age: Int): Student11 = {new Student11(name,age)}}

5.3、单例设计模式

        单例设计模式，始终只有一个对象，即使我们在创建对象的时候，赋予不同的属性，但是返回的结果都只会是第一个对象的实例。

object Test12_Singleton {def main(args: Array[String]): Unit = {val student2 = Student12.getInstance("bob",20)student2.printInfo()    //bob 20 北京中医药大学val student1 = Student12.getInstance("alice",18)student1.printInfo()    //bob 20 北京中医药大学//输出相同的对象引用println(student1)    println(student2)}}
//定义伴生类
class Student12 private (val name: String,val age: Int){def printInfo(): Unit = {println(s"${name} ${age} ${Student12.school}")}}//饿汉式
//object Student12{
//  val school = "北京中医药大学"
//
//  private val student: Student12 = new Student12("alice",18)
//
//  def getInstance(): Student12 = student
//}//懒汉式
object Student12{val school = "北京中医药大学"private var student:  Student12 = _def getInstance(name: String,age: Int): Student12 = {if (student == null){//没有对象实例的话就创建一个student = new Student12(name,age)}student}
}

使用伴生对象可以很轻松地实现各种设计模式。