Scala入门学习之【类,对象,继承】

1.类的定义

1.1类的定义

class Person {
    //用val修饰的变量是只读属性，有getter但没有setter
    //（相当与Java中用final修饰的变量）
    val id = "9527"

    //用var修饰的变量既有getter又有setter
    var age: Int = 18

    //类私有字段,只能在类的内部使用
    private var name: String = "唐伯虎"

    //对象私有字段,访问权限更加严格的，Person类的方法只能访问到当前对象的字段
    private[this] val pet = "小强"
  private  var  gender:String="男" //当加上private时候  只能在类和半生对象里边使用
  private[this] var pop:String = _  // private[this] 表示只能在类里边能用
  private [ad] val  age=1     //private [ad]只有在这个保内可以访问

}

1.2构造器

主构造器会执行类定义中的所有语句

/**
  *每个类都有主构造器，主构造器的参数直接放置类名后面，与类交织在一起
  */
class Student(val name: String, val age: Int){
  //主构造器会执行类定义中的所有语句  因为是静态类
  println("执行主构造器")

  try {
    println("读取文件")
    throw new IOException("io exception")
  } catch {
    case e: NullPointerException => println("打印异常Exception : " + e)
    case e: IOException => println("打印异常Exception : " + e)
  } finally {
    println("执行finally部分")
  }

  private var gender = "male"

  //用this关键字定义辅助构造器
  def this(name: String, age: Int, gender: String){
    //每个辅助构造器必须以主构造器或其他的辅助构造器的调用开始
    this(name, age)
    println("执行辅助构造器")
    this.gender = gender
  }
}



/**
  *构造器参数可以不带val或var，如果不带val或var的参数至少被一个方法所使用，
  *那么它将会被提升为字段
  */
//在类名后面加private就变成了私有的
class Queen private(val name: String, prop: Array[String], private var age: Int = 18){
  
  println(prop.size)

  //prop被下面的方法使用后，prop就变成了不可变得对象私有字段，等同于private[this] val prop
  //如果没有被方法使用该参数将不被保存为字段，仅仅是一个可以被主构造器中的代码访问的普通参数
  def description = name + " is " + age + " years old with " + prop.toBuffer
}

object Queen{
  def main(args: Array[String]) {
    //私有的构造器，只有在其伴生对象中使用
    val q = new Queen("hatano", Array("蜡烛", "皮鞭"), 20)
    println(q.description())
  }
}

2.对象

2.1单例对象

在Scala中没有静态方法和静态字段，但是可以使用object这个语法结构来达到同样的目的

1.存放工具方法和常量

2.高效共享单个不可变的实例

3.单例模式

2.2伴生对象

在Scala的类中，与类名相同的对象叫做伴生对象，类和伴生对象之间可以相互访问私有的方法和属性

class Dog {
  val id = 1
  private var name = "itcast"

  def printName(): Unit ={
    //在Dog类中可以访问伴生对象Dog的私有属性
    println(Dog.CONSTANT + name )
  }
}

/**
  * 伴生对象
  */
object Dog {

  //伴生对象中的私有属性
  private val CONSTANT = "汪汪汪 : "

  def main(args: Array[String]) {
    val p = new Dog
    //访问私有的字段name
    p.name = "123"
    p.printName()
  }
}

2.3apply（）方法

object AAA{
  def apply(): AAA={
    new AAA
  }
  def apply(name:String): AAA={
    new AAA(name)
  }
  def apply(name:String,sex:String): AAA={
    new AAA(name,sex)
  }
}
object SingletonDemo {
  def main(args: Array[String]): Unit = {
    
    //就是不用new  直接去调用apply()方法  并且把对象付给a
    val a=AAA()

    //就是不用new  直接去调用apply(name:String)方法  并且把对象付给a1
    val a1=AAA("dayu")
    
    
    //val arr=Array(1,2,3) //就是这个道理 ，不用new 了
  }
}

2.4应用程序对象

object AppObjectDemo extends App{
  //不用写main方法
  println("I love you Scala")
}