scala访问权限

类的成员（属性，方法……）是否能耐被访问？！就是访问权限

属性的访问修饰符：

（1）无修饰符-不做任何限制

（2）private

（3）protected

（4）private[this]

访问权限

	类的内部方法	伴生对象中的方法	类的外部（对象.的访问）	子类对象.访问	子类方法是否可以访问	另一个对象.属性
无修饰符	可以	可以	可以	可以	可以
private	可以	可以	不可以	不可以	不可以	可以
protected	可以	可以	可以	可以	可以	可以
private[this]	可以	不可以	不可以	不可以	不可以	不可以

class Stu22(var name:String){
  private var age:Int = 18
          var addres:String = "师范路"
  def say():Unit={
    println(name)
  }
}
object Stu22{
  def test(stu22: Stu22):Unit ={
    println(stu22.name,stu22.age)
  }
}

class Stu23(name:String)extends Stu22(name){
  def test():Unit ={
    //在子类中super用来访问对象
    println(this.name)
    println(this.name)
  }
}

object Test_访问权限 {
  def main(args: Array[String]): Unit = {
    var stu1 = new Stu22("小鹿")
    stu1.name

    val stu2 = new stu23("小猪佩奇")
  }
}

【例】银行账户存钱取钱

scala的控制方法作用域有5种：

（1）默认访问权限

（2）protected访问权限

（3）private访问权限

（4）private[package]访问权限

（5）private[this]访问权限

class Stu24{
  def say():Unit ={
    println("public 公开")
  }
  //protected可以被子类继承
  protected  def sing():Unit ={

  }
  //只能通过当前对象来访问。不能通过其他对象. 的方式来访问！
  private [this] def rap():Unit ={
  }

  def test(s:Stu24):Unit ={
    //s.rap() //报错
  }

}

class Stu24_1 extends Stu24{
  def test() :Unit ={
    this.sing()//protected可以被子类继承
//    this.dance()//dance是private修饰
  }
}



class Test_控制方法作用域 {
  def main(args: Array[String]): Unit = {
    def main(args: Array[String]): Unit = {
      val s1 = new Stu24
      s1.say()
      //子类对象
      val s2 = new Stu24_1
      s2.say()
    }
  }
}

private[package]修饰方法

//private[abc]:比private更加宽容的修饰符。只要在包 abc 中，都可以访问
import java.util.{ArrayList,HashSet}

package abc{

  class Stu1{
    private[abc] def rap():Unit ={
      println("rap")
    }
    private   def sing():Unit={ }
  }

  object Test_private {
    def main(args: Array[String]): Unit = {
      val s = new Stu1()
      s.rap()
      //s.sing()//private修饰的，不能通过在类的外部通过 对象. 来访问
    }
  }
}

【课后小答】

1、private修饰的属性，可以在子类中访问吗？

不行

2、protected修饰的属性，可以在子类中访问吗？

可以

3、private[this]修饰的属性，能在哪里访问？

包名

4、private[package]修饰的属性,能在哪里被访问？

被其修饰的包和子类包

package

package包，一个容器。可以把类，对象，包，装入

作用、好处：

（1）区分同名的类：

（2）更好地管理类

（3）控制访问访问

格式

定义格式1：package 包名 。表示之后的代码都属于这个类

定义格式2：package 包名{}

定义格式3：package 包名{package 包名}

包的命名规则

包名称应全部小写，只能包含数字，字母，下划线，小圆点。不能使用数字开头，也不能用关键字

定义包

两种包的管理风格：

（1）一个源文件，一个包

（2）嵌套package表示层级关系。这样的好处是一个文件可以定义多个包，内层包也可以访问外层的包的类和对象

scala的包的导入

通配符导入：import  包名._  导入这个包下所有的类

import 包名.类名  导入这个包下的具体的类

导入相同包的多个类：import java.util。{HashSet，ArrayList}

局部导入：什么时候用，什么时候import。在其作用范围内部都可以使用。

导入重命名

导入之后修改名字。

格式：import 包名.{原名字 => 新名字}

就导入A,B,C,不要导入D

格式：import 包名.{不要的类 =>_,_}

（1）import 包名 导入这个包下的顶层对象

【课后小答】

1、包的关键字是package

2、包的命名有哪些规则？

3、如何导入某个包下所有的类？

使用  . _

4、如何导入某个包下的某个类？

加包名