Scala-抽象类、匿名子类、伴生对象、单例模式

open_test01

已于 2023-02-25 16:51:26 修改

阅读量481

点赞数

分类专栏： Scala 文章标签： java 开发语言 scala

于 2023-02-25 16:49:08 首次发布

本文链接：https://blog.csdn.net/dafsq/article/details/129216256

版权

Scala 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

抽象类

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

object gou {
  def main(args: Array[String]): Unit = {
    //测试
    val student = new stu0
    println(student.name)
    println(student.age)
    student.run()
    student.sleep()
  }
}

//定义为抽象类父类
abstract class Student0{
  //定义非抽象属性
  val name : String = "yiyi"
  //定义抽象属性
  var age : Int

  //定义非抽象方法
  def run(): Unit ={
    println("跑起来")
  }
  //定义抽象方法
  def sleep(): Unit //抽象方法没有具体的方法体
}

//定义具体的实现子类
class stu0 extends Student0{
  //实现父类抽象属性和方法
  var age: Int = 18
  def sleep(): Unit = {
    println("睡觉吧")
  }

  //重写非抽象父类属性
  override val name: String = "stu"
  override def run(): Unit = {
    super.run()
    println("跑不动了")
  }
}

继承和重写的补充

如果父类为抽象类，那么子类需要将抽象的属性和方法实现，否则子类也需声明为抽象类
重写非抽象方法需要用 override 修饰，重写抽象方法则可以不加 override。
子类中调用父类的方法使用 super 关键
子类对抽象属性进行实现，父类抽象属性可以用 var 修饰；
子类对非抽象属性重写，父类非抽象属性只支持 val 类型，而不支持 var。
因为 var 修饰的为可变变量，子类继承之后就可以直接使用，没有必要重写

匿名子类

和 Java 一样，可以通过包含带有定义或重写的代码块的方式创建一个匿名的子类。

object gou {
  def main(args: Array[String]): Unit = {
    //测试
    val stu : Student0 = new Student0 {//匿名子类
      override var num: Int = 1
      override def sleep(): Unit = {
        println("eat")
      }
    }
    //打印匿名子类属性
    println(stu.num)
    //调用匿名子类方法
    stu.sleep()
  }
}

//定义为抽象类父类
abstract class Student0{
  //定义抽象属性
  var num : Int
  //定义抽象方法
  def sleep(): Unit //抽象方法没有具体的方法体
}

伴生对象（单例对象）

Scala语言是完全面向对象的语言，所以并没有静态的操作（即在Scala中没有静态的概念）。但是为了能够和Java语言交互（因为Java中有静态概念），就产生了一种特殊的对象来模拟类对象，该对象为单例对象。若单例对象名与类名一致，则称该单例对象这个类的伴生对象，这个类的所有“静态”内容都可以放置在它的伴生对象中声明。

object Person{
val country:String="China"
}

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

object gou {
  def main(args: Array[String]): Unit = {
    //测试
    val stu : Student_ = new Student_("xixi",18)
    println(s"${stu.name}")
    stu.printt()
    
    //测试工厂方法
    val student = Student_.newStu("aa",20)
  }
}

//定义类
class Student_(val name: String ,val age : Int){
  def printt(): Unit ={
    println(name)
    println(age)
    //可以直接访问伴生对象属性
    println(Student_.school)
  }
}

//定义Student_类的伴生对象
object Student_{
  val school : String = "烧烤学院"
  def printt(): Unit ={
    println(school)
  }
  //定义一个类对象实例的创建方法（工厂方法）
  def newStu(name : String,age:Int): Student_ = new Student_(name,age)
}

单例设计模式

饿汉模式

object Singlenton {
  def main(args: Array[String]): Unit = {
    //测试
    val stu = Student_.getIn()
    stu.printt()
    val stu2 = Student_.getIn()
    stu2.printt()
    //打印两个对象地址 地址相同 全局只有一份
    println(stu)
    println(stu2)
  }
}
//定义类对象
class Student_(val name: String ,val age : Int){
  def printt(): Unit ={
    println(name)
    println(age)
  }
}

//定义Student_类的伴生对象
object Student_{
  //单例设计
  private val student : Student_ = new Student_("a",18)
  def getIn(): Student_ = student
}

懒汉模式

object Singlenton {
  def main(args: Array[String]): Unit = {
    //测试
    val stu = Student_.getIn()
    stu.printt()
    val stu2 = Student_.getIn()
    stu2.printt()
    //打印两个对象地址 地址相同 全局只有一份
    println(stu)
    println(stu2)
  }
}
//定义类对象
class Student_(val name: String ,val age : Int){
  def printt(): Unit ={
    println(name)
    println(age)
  }
}

//定义Student_类的伴生对象
object Student_{//懒汉模式
  private var student : Student_ = _
  def getIn(): Student_ = {
    if(student == null){
      //如果没有对象实例那么则创建一个
      student = new Student_("aa",20)
    }
    return student
  }
}