scala基础-class、object的一些体会

1、定义成员private与默认public

1.1成员定义private的时候也会默认定义private的get和set方法，因为是私有的所以不可访问。
这个时候就需要自己定义set、get方法来访问name。
1.2如果将成员定义为public，此时会默认定义public的get和set的方法，但是成员为私有的。
我们访问name其实是访问name的get、set方法。

object ProTest1 {
  def main(args: Array[String]): Unit = {
    val scala = new Hiscala
    // 以下两种调用方式在没有参数的时候是等价的
    scala.sayName()
    scala.sayName

    // println(scala.name) private是私有的，不可直接访问，但是可通过getName方法进行访问
    println(scala.getName)
  }
}

class Hiscala{
  private var name = "scala"
  def sayName(){ println("Hi, " + name) }
  def getName = name
}

输出：

Hi, scala
Hi, scala
scala

2、get方法的覆写

object ProTest1 {
  def main(args: Array[String]): Unit = {
    val scala = new Person
    println(scala.name)
    scala.name = "Spark"
    println(scala.name)
    scala.update("Hadoop")
    println(scala.name)
  }
}

class Person{
  private var myName = "Kylin"
  def name = this.myName
  // name_=实际为name的set方法的覆写，也就是set方法，所以可以直接调用name = newName
  def name_=(newName : String){
    this.myName = newName
    println("Hi, " + myName)
  }
  // 同时可以自定义函数实现set方法
  def update(newName : String){
    myName = newName
    println("Hi, " + myName + ". See you again!")
  }
}

输出：

Kylin
Hi, Spark
Spark
Hi, Hadoop. See you again!
Hadoop

3、private[this]的使用

private[this]不允许其他对象访问，对象私有，只能这个对象访问，这个对象的类中的方法也不可以访问这个成员。其他对象中的方法也不可访问。

object ProTest1 {
  def main(args: Array[String]): Unit = {
    val personA = new Person()
    val personB = new Person
    personA.getName()
    personA.getName(personB)
    // 实现getName的重载
  }
}

class Person{
  var nameA = "AAA"
  private var nameB = "BBB"
  private[this] var nameC = "CCC"

  def getName()={
    println(nameA + "\t" +nameB + "\t" +nameC)
    }
  // 调用公开的nameA与私有的nameB都是可行的
  def getName(p:Person){
    println(nameA + "\t" +nameB)
    }
  // 使用nameC的时候报错value nameC is not a member of com.yanch.cn.Person
  /*
  def getNameC(c:Person){
    println("It's " + c.nameC)
  }*/
}

输出：

AAA BBB CCC
AAA BBB

4、构造器的重载

object ProTest1 {
  def main(args: Array[String]): Unit = {
    // 调用默认构造器
    val scala = new Person
    println("-" * 20)
    // 调用 默认构造器
    val scala2 = new Person()
    println("-" * 20)
    // 调用 this(newName : String)构造器
    val scala3 = new Person("Spark")
    println("-" * 20)
    // 调用 this(newName : String, age : Int)构造器
    val scala4 = new Person("Spark", 30)
  }
}

class Person{
  println("aaaa")
  private var myName = "Kylin"
  private var age = 10

  def this(newName : String){
    this()
    myName = newName
    println("This is a newname!" + myName)
  }

  def this(newName : String, age : Int){
    this(newName)
    this.age = age
    println("This is a new age!" + age)
  }
}

输出：

aaaa
--------------------
aaaa
--------------------
aaaa
This is a newname!Spark
--------------------
aaaa
This is a newname!Spark
This is a new age!30

5、伴生对象object

5.1 object 成员函数为静态的，可以直接调用；
5.2 object 有自带的默认构造器，而且只在调用object成员的时候第一次执行，后面不执行；
5.3 同文件中同名的class类即为其伴生类，object为class的伴生对象；伴生类与伴生对象必须在同一个文件之中；
5.4 伴生对象中有apply方法，当前类的伴生对象的工厂方法；
5.5 抽象类依旧可以通过伴生对象的工厂方法来构造实例化。

object ProTest2 {
  def main(args: Array[String]): Unit = {    
    // 使用new构造Person2类的实例
    val p1 = new Person2
    println(p1.getAge)

    println("-" * 20)
    // 使用伴生对象构造实例
    val p2 = Person2
    println(p2.getAge2)

    println("-" * 20)
    // 使用伴生对象的apply犯法构造类Person2的实例
    val p3 = Person2()
    println(p3.getAge)

    println("-" * 20)
    // object 有自带的默认构造器，而且只在调用object成员的时候第一次执行，后面不执行
    // object 成员函数为静态的，可以直接调用
    println(Person2.getAge2)

  }
}

class Person2{
  println("It's a class !")
  private var age = 10
  def getAge = age
}

object Person2{
  println("It's a object !")
  private var age2 = 1
  def getAge2 = age2
  def apply()={
    println("It's a apply method !")
    new Person2
  }
}

输出：

It's a class !
10
--------------------
It's a object !
1
--------------------
It's a apply method !
It's a class !
10
--------------------
1

6、抽象类

抽象类加final，则无法被继承（方法也是如此）
override 覆写父类的方法（统一，抽闲方法不写不影响功能），覆写父类非抽象方法就必须加override。

object ProTest2 {
  def main(args: Array[String]): Unit = {    
    val c1 = new Cat
    c1.eat
    // 使用apply工厂方法
    val c2 = Cat()
    c2.eat
  }
}

abstract class Animal{
  var color : String
  var action : String
  def eat
}

class Cat extends Animal{
  override var color = "Black"
  override var action = "Creep"
  override def eat{
    println("Fish !")
    }
}

object Cat{
  def apply()={
    println("It's a cat !")
    new Cat
  }
}

输出：

Fish !
It's a cat !
Fish !