演示一个程序错误及其修复方法

演示一个程序错误及其修复方法 修复方式：使用 lazy val 延迟初始化 fileWriter，使其在 filename 被初始化后再创建。

package level02

import java.io.FileWriter
import java.io.IOException

object class18 {

  // 在文件中写入日志
  trait FileLogger {
    // 抽象属性: 文件名，由子类提供
    val filename: String

    // 使用 lazy val 延迟 fileWriter 的初始化
    // 这样可以确保在 filename 被赋值之后，fileWriter 才会被创建
    lazy val fileWriter: FileWriter = new FileWriter(filename, true)

    def writeMsg(msg: String): Unit = {
      try {
        fileWriter.write(msg + "\n") // 增加换行符，使日志更清晰
        fileWriter.flush() // 建议在每次写入后刷新，确保数据及时写入文件
      } catch {
        case e: IOException => e.printStackTrace()
      }
    }

    // 提供一个关闭资源的方法
    def close(): Unit = {
      try {
        if (fileWriter != null) {
          fileWriter.close()
        }
      } catch {
        case e: IOException => e.printStackTrace()
      }
    }
  }

  class MyFileLogger extends FileLogger {
    // 为抽象字段 filename 提供具体的值
    override val filename: String = "11-26.log"
  }

  def main(args: Array[String]): Unit = {
    val fileLogger = new MyFileLogger()
    fileLogger.writeMsg("今天上午上scala课程")
    fileLogger.writeMsg("下午继续学习 trait 和类的初始化。")

    // 程序结束时关闭文件写入器，这是一个好习惯
    fileLogger.close()

    println("日志已写入文件 '11-26.log'。")
  }
}

package level02

import java.io.FileWriter

/*
演示一个程序错误
*/
object class19 {
  // 在文件中写入日志
  trait FileLogger {
    println(2)
    // 抽象属性: 文件名
    val filename: String
    lazy val fileWriter = new FileWriter(filename, true)
    def writeLog(msg: String): Unit = {
      fileWriter.write(msg)
      fileWriter.close()
    }
  }

  class MyFileLogger extends FileLogger {
    println(1)
    val filename = "11-28.log"
  }

  def main(args: Array[String]): Unit = {
    val fileLogger = new MyFileLogger()
    fileLogger.writeLog("今天上午上scala课程")
  }
}

访问权限控制1

1.公开的，不写修饰符

2.protected,保护的

在类的外部不能访问：

在子类中访问。

3.private [this]

只能被当前对象中使用

在类的内部使用

package level02
object Person {
  def test(p:Person): Unit = {
    // private 在伴生对象中可以访问!
    println(p.password)
    // private[this] 在伴生对象中不能访问的
    // println(p.money)
  }
}

class Person() {
  var name:String = "xx"; // 公开的
  protected var birthday:String = "2000-10-10"
  private var password:String="123456"
  private[this] var money:Int=100

  def t():Unit = {
    println(money)
  }
}

class Son extends Person(){
  // 2. protected在子类中可访问
  println(birthday)
  // 3. private在子类中不能访问的
  // println(password)
}

def main(args: Array[String]): Unit = {
  val p1 = new Person()
  println(p1.name)
  // 2. protected在类的外部无法访问
  // println(p1.birthday)
  new Son()
  // 3. 在伴生对象中访问 类的私有成员
  Person.test(p1)
}