Scala基础05：包与引用

标签：

Scala通过不同的包能使用很多类型的表达式，而包的引入在Scala中相当灵活。包是用来管理名称的。

包的定义

在文件顶部，使用package定义包，与java一样。

package cn.sjq.scala

嵌套形式的包定义：

package com{
  package horstmann{
    package impatient{
      class Employee{
        // ...
      }
    }
  }
}

 Scala的这种写包的方法使用的并不多。Scala写的Play框架使用的较多。

与对象和类的定义不同，同一个包可以定义在多个文件中。

例：

如下代码位于Employee.scala

package com{
  package horstmann{
    package impatient{
      class Employee{
        // ...
      }
    }
  }
}

如下代码位于Manager.scala

package com{
  package horstmann{
    package impatient{
      class Manager{
        // ...
      }
    }
  }
}　

源文件的目录和包没有强制关系。不需要将Employee.class与Manager.scala放在com/horstmann/impatient目录中。

同样的，也可以在同一个文件中定义为多个包：

package com{
  package horstmann{
    package impatient{
      class Employee{
        // ...
      }
    }
  }
}

package com{
  package horstmann{
    package impatient{
      class Manager{
        // ...
      }
    }
  }
}

作用域规则

包声明链com.horstmann.impatient并不使com与com.horstmann可见。

包声明链也不对包含的包进行声明。即声明com.horstmann并不意味着声明com.horstmann.impatient。

包对象

类成员对于包的可见性

在Java中，没有声明为public、private或protected的类成员在包含该类的包中可见。

scala中，对于包的可见性可以任意定义。

例：

package com.horstmann.impatient.people

class Person{

  private [people] def description = “A person with name” +

description对于people包是可见的。

people包下的所有成员，可以使用这个类成员。

也可以将成员的可见度延展到上层包。

package com.horstmann.impatient.people

class Person{

  private [impatient] def description = “A person with name” + name

}

例：一个更复杂的示例。

package com{

package python{

private[com] class List{

protected[python] def get(i:Int){}

class ArrayList{

private[ArrayList] def size{}

      }

private[this] var size = 0

    }

  }

package csharp{

import com.python._

object Obj{

private[csharp] val pythonList = new List;

    }

  }

}

Scala包的引入

Scala使用包，可以在任何地方引入。

例：

class Manager{

  import scala.collection.mutable._

  val subordinates = new ArrayBuffer[Employee]

}

直接使用

直接在使用该名称时引入：

val Y= scala.collection.mutable.Map( (a1, b1) , (a2, b2) , (a3, b3))

利用import语句引入

import scala.collection.mutable.ArrayBuffer

val C= new ArrayBuffer[T]()

利用import语句引入包的全部成员：

import scala.collection._

这里的“_”相当于Java中的“*”。

引入同一个包中的几个成员：

import scala.collection.{Map,Set}

重命名

当需要引入不同的包中同名的成员时，可以对成员进行重命名。

import scala.collection.mutable.HashMap

import java.util.{ HashMap => JavaHashMap}

隐藏引入

隐藏引入的对象

import java.util.{ HashMap => _, _}

该语句表示，java.util.HashMap 将被隐藏，无法被使用。而java.util中其他的全部成员，都被引入。

自动引入

Scala默认引入以下三个包：

import  java.lang._

import  scala._

import  Predef._

在适当的地方引入适当的包

可以在脚本开头引入。

可以在具体使用前引入。

包的引入是有作用范围的，且跟函数与声明的作用范围是一致的。

例：

import scala.math._

这样就可以使用

sqrt(2)

pow(2,4)

min(3,pi)

Scala没有静态方法。但有单例对象。

通常，一个类对应一个伴生对象。方法与Java的静态方法一样。

Scala文件访问

scala中访问文件需要使用scala.io.Source对象。

例：读取本地文件。

def main(args: Array[String]) {

// 访问文件

val file = Source.fromFile("D:\\scala-test.txt")

for(line <- file.getLines){

    println(line)

  } 

}

若使用：

for(line <- file){

println(line)

  }

则不会一行一行的读取数据，而是一个字一个字的读取并输出。

例：读取网络文件。

def main(args: Array[String]) {

// 访问网络URL

val file = Source.fromURL("http://www.baidu.com")

for(line <- file.getLines){

      println(line)

    }

  }

Scala基础05：包与引用

标签：

原文地址：http://www.cnblogs.com/shijiaqi1066/p/4610148.html