Scala 的访问权限

1.1 Scala的访问权限概述

  Scala中的属性成员、方法和构造器这三种变量可以通过访问控制符控制访问权限。不同的访问控制符可以决定是否可以被外部类访问。由于局部方法的作用域本身有局限，所以不需要使用访问控制符修饰局部方法。属性成员、方法和构造器的访问控制权限可以通过访问控制符发生变化，而局部变量的访问作用域是不可变的。

  Java中的访问控制符有public、default (默认无修饰符)、protected和private。访问控制权限的级别由小到大的顺序为private、 default、protected、public。private为类访问权限，如果一个成员被private修饰，那么该成员只能在本类中被访问，不可以在外部类或继承类中被访问。default即默认的访问权限为包访问权限，同一个包中的类可以被访问。protected为包访问控制权限加上继承，如果不同的包中存在继承关系，则可以访问不同包中的成员。public表示任何地方都可被访问，访问权限最宽松。

1.2Scala的属性和构造函数访问权限

  通过上面介绍的Java中的访问控制权限，下面学习Scala中的属性和构造函数的访问权限。 Scala中也有四种访问控制权限，分别为:默认访问权限、protected访问权限、private 访问权限和private[ thisl访问权限。Scala中的默认访问权限相当于Java中的public，Scala中如果一个变量没有任何修饰符，就代表默认访问权限。protected访问权限与Java中的不同，只能用于继承关系中，即只能被子类访问。private访问权限与Java中相同，只能在类内部使用。private[this]访问权限是Java中没有的， 只能被类中的某一个对象访问，从这一点也可以看出 Scala 比Java更面向对象。在Java中，访问权限的级别范围由小到大为类、包、继承、all,在Scala中，访问权限的级别范围由小到大为对象、类、继承、 包、all。

通过定义类，分别实现成员属性和构造器的不同访问权限。

(1)默认访问权限。 

(2) protected访问权限。

(3) private访问权限。

(4)private[this]访问权限。

下面举例说明如何实现成员属性的不同访问权限，相关代码如下：”

//访问控制权限


//                   类的内部方法  伴生对象中的方法  类的外部(对象.访问)  子类对象.访问  子类方法是否可以访问  另一个对象的属性
//默认权限(public)        可            可             可                可              可               可
//private               可             可            不可              不可             不可             不可
//protected             可             可            不可              不可              可              不可
//private[this]         可             不可          不可               不可             不可             不可
class Student{
  //1.默认权限。类似于java中的public
  val name = "小花"
  //2.私有属性。类的内部 不能继承！
  private val score = 59

  //3.受保护的。
  protected val car = "宝马"

  def say(): Unit = {
    println(name,score,car)
  }
}

object Student{
  def run(obj:Student): Unit = {
    println(obj.name,obj.score,obj.car)
  }
}
//子类
class SubStudent extends Student{
  def test(): Unit = {
    println(this.name,this.car)
  }
}
object Test22_1 {
  def main(args: Array[String]): Unit = {
    val s = new Student()
    //    s.
    val s1 = new SubStudent()
    //    s1.
  }
}

private访问权限输出相关代码如下：

//银行账户存钱取钱例子

class BankAccount(private var balance:Int){
  def showMoney(): Unit = {
    println(s"现在的余额是:${balance}")
  }
  def deposit(money:Int): Unit = {
    balance += money
  }
  def withdraw(money:Int): Unit = {
    if (money <= balance)
      balance -= money
  }
  //转账
  def transfer(to: BankAccount,money:Int): Unit = {
    //A --200--> B
    //A 减少 B 增加
    if(money <= balance){
      //自己减少
      balance -= money
      //对方增加
      to.balance += money
    }
  }
}
object Test22_2 {
  def main(args: Array[String]): Unit = {
    var xiaoming = new BankAccount(0)
    
    var xiaohua = new BankAccount(100)
    //存入200
    xiaohua.deposit(200)
    //取出150
    xiaohua.withdraw(150)

    //转账给小明
    xiaohua.transfer(xiaoming,100)

    xiaohua.showMoney()
    xiaoming.showMoney()

//    println(xiaohua.balance)
  }
}

private[this]访问权限输出相关代码如下：

//银行账户存钱取钱例子

//private[this]:修饰符，这个属性，只能在当前对象中访问
class BankAccount(private[this] var balance:Int){
  def showMoney(): Unit = {
    println(s"现在的余额是:${balance}")
  }
  def deposit(money:Int): Unit = {
    balance += money
  }
  def withdraw(money:Int): Unit = {
    if (money <= balance)
      balance -= money
  }
  //转账:把当前账户的余额转出 money 给 to这个账户
  def transfer(to: BankAccount,money:Int): Unit = {
    //A --200--> B
    //A 减少 B 增加
    if(money <= balance){
      //自己减少
      balance -= money
      //对方增加
//      to.balance += money
      to.deposit(money)
    }
  }
//  def test(to: BankAccount): Unit = {
//    to.balance = 0
//  }
}
object Test22_2 {
  def main(args: Array[String]): Unit = {
    var xiaoming = new BankAccount(0)

    var xiaohua = new BankAccount(100)
//    //存入200
//    xiaohua.deposit(200)
//    //取出150
//    xiaohua.withdraw(150)
//
//    //转账给小明
//    xiaohua.transfer(xiaoming,100)
//
//    xiaohua.showMoney()
    xiaoming.showMoney()

//    println(xiaohua.balance)
  }
}

1.3 Scala的控制方法作用域

  Scala的控制方法作用域有:默认访问权限、protected访问权限、private访问权限、private[package] 访问权限、private[this]访问权限。实际上 Scala的另外两种变量也有private[package]访问权限，这里主要介绍private[package]访问权限，其中package表示包的名称。如果一个变量使用private[package] 进行修饰，则该变量只能在package包中被访问。private[package]和 private[this]是Scala中特有的访问权限，这两种权限Java中没有。 

通过定义类，实现方法作用域的控制。

(1) 默认问权限。 

(2) protected 访问权限。

(3) private访问权限。 

(4)private[package]访问权限。

相关代码如下：

class Car(){
  //                   类的内部方法  伴生对象中的方法  类的外部(对象.访问)  子类对象.访问  子类方法是否可以访问  另一个对象的属性
  //默认权限(public)        可            可             可                可              可               可
  def run(): Unit = {

  }
  def test(): Unit = {
    run()
  }
}
class MotoCar() extends Car{
  def t(): Unit = {
    this.run()
  }
}
object Car{
  def fly(c:Car): Unit = {
    c.run()

  }
}
object Test22_3 {
  def main(args: Array[String]): Unit = {
    val c1 = new Car()
    c1.run()
    val c2 = new MotoCar()
    c2.run()
  }
}

private[package]访问权限输出相关代码如下：

//private[p1]:表示。这方法在p1这个包中，是可以访问的。
package p2{
  class C() {
    private[p2] def test(): Unit = {
      println("test")
    }
  }
  object Test22_4 {
    def main(args: Array[String]): Unit = {
      var c1 = new C()
      c1.test()
    }
  }
}