• scala学习 包和引入


    scala学习 包和引入

    1.打包方法

    1.在文件顶部放置一个Package子句

    package bobsrockets.navigation
    class Navigator
    

    2.在Package子句后加上一段花括号包起来的代码块 -- 打包

    package bobsrockets.navigation{
    	class Navigator
    }
    

    2.嵌套包

    Scala提供了一种名为_root_的包,这个包不会与任何用户编写的包冲突。每个你能编写的顶层包都被是做_root_的成员。

    3.引入

    Scala引入灵活性:

    1.出现在任何位置

    2.引用对象(不论单例或者常规),而不只是包

    3.让你重命名并隐藏某些被引入的成员

    引入选择器:

    一个简单的名称x,将x包含在引入的名称集里。

    一个重命名子句x => y,让名为x的成员以y的名称可见

    一个隐藏子句x=>__,从引入的名称集里排除掉x

    一个捕获所有的__。引入除了之前子句中提到的成员外的所有成员。如果需要捕获所有子句,它必须出现在引入选择器列表的末尾。

    隐式引入:

    //后引入的会遮挡前面的!
    import java.lang._	//java.lang包的全部内容 -- 标准Java类
    import scala._		//scala包的全标准类库 -- Scala标准类库
    import Predef._		//Predef对象的全部内容 -- 包含许多类型、方法和隐式转换的定义
    

    4.Scala修饰符

    私有成员 private

    标为private的成员只在包含该定义的类或对象内部可见

    class Outer{
     class Inner{
         private def f() = { println("f")}
         class InnerMost{
             f() // OK
         }
     }
     (new Inner).f() //Wrong
    }
    

    受保护成员protected

    protected成员只能从定义该成员的子类访问

    package p {
    	class Super{
     	protected def f() = { println("f")}
    	} 
     
     class Sub extends Super{
         f()
     }
     
     class Other{
         (new Super).f()	//Wrong
     }
    }
    

    公共成员

    任何没有被标为private或protected成员都是公共的,公共成员可以从任何位置访问到。

    5.保护范围

    形如private[X]protected[X]的修饰符含义是对此成员的访问限制“上至”X都是私有的或者受保护的,其中X表示某个包含该定义的包、类或者单例对象 。

    package bobsrockets
    package navigation{
        private[bobsrockets] class Navigator{
            protected[navigation] def useStartChart() = {}
            class LegOfJourney{
                private[Navigator] val distance = 100
            }
            private[this] var speed = 200
        }
    }
    package launch{
        import navigation._
        object Vehicle{
            private[launch] val guide =   new Navigator
        }
    }
    
    无访问修饰符 公共访问
    private[bobsrockets] 外围包内可见
    private[navigation] 与Java中包可见性相同
    private[Navigator] 与Java中的private相同
    private[LegOfJourney] 与Scala中的private相同
    private[this] 仅在当前对象内访问(对象私有)

    6.可见性与伴生对象

    Scala的访问规则在private和protected的处理上给伴生对象和类保留了特权。一个类会将它的所有访问权限跟他的伴生对象共享。简而言之,一个对象可以访问它的伴生类的所有私有成员,一个类可以访问它的伴生对象中的所有私有成员。(与Java修饰符相似,除protected static)

    7.包对象

    Scala提供包对象作为整个包中方便共享使用的容器。每个包都允许有一个包对象,在包对象中的任何定义都被认为是包自身的成员。

    包对象会被编译成名为package.class的类文件,该文件位于它增强的包的对应目录下。按照惯例,其代码通过放在package.scala文件中。

    //位于bobsdelights/package.scala
    package object bobsdelights{
        def showFruit(fruit:Fruit) = {
            import fruit._
            println(name + "s are " + color)
        }
    }
    
    //位于PrintMenu.scala
    package printmenu
    import bobsdelights.Fruits
    import bobsdelights.showFruits
    object PrintMenu{
        def main(args:Array[String]) = {
            for(fruit <- Fruits.menu){
                showFruit(fruit)
            }
        }
    }
    
  • 相关阅读:
    StandardWrapper ...$$EnhancerByCGLIB$$b9
    Exception in thread "main" java.lang.ClassCastException: $Proxy13
    Mybatis 源码阅读 (一)
    Thread 中yield(), join()
    java 中类型后面三个点的用法
    JAVA 中汉字在不同编码下的字节不同
    Spring FIlterType
    MyBaties学习记录
    MyBaties学习记录Settings参数详解
    JavaScript学习笔记
  • 原文地址:https://www.cnblogs.com/ganshuoos/p/12805238.html
Copyright © 2020-2023  润新知