Scala package与import实战详解

为什么要有package的概念？

因为要对多个同名的类进行命名空间的管理，避免同名类发生冲突
比如说，scala.collection.mutable.Map和scala.collection.immutable.Map

---

• package定义的第一种方式: 多层级package定义（比较差的做法，一般不这么干）

package com {
    package sunny{
        package scala {
            class Test {}
        }
    }
}

• package定义的第二种方式: 串联式package定义（也不怎么样，一般也不这么干）

package com.sunny.scala {
    package service {
        class Test {}
    }
}

• package定义的第三种方式: 文件顶部package定义

package com.sunny.scala.service

class Test {

}

• package定义的第四种方式: IDE自动生成包

---

• package特性一: 同一个包定义，可以在不同的scala源文件中的; 一个scala源文件内，可以包含两个包

Test1.scala

package com {
    package sunny{
        package scala {
            class Test1
        }
    }
}

Test2.scala

package com {
    package sunny {
        package scala {
            class Test2
        }
    }
}

Test3.scala

package com {
    package sunny {
        package scala1 {
            class Test
        }
    }
}

package com {
    package sunny {
        package scala2 {
            class Test
        }
    }
}

• package特性二: 子包中的类，可以访问父包中的类

Test.scala

package com {
    package sunny {
        package scala {
            object Utils {
                def isNotEmpty(str: String): Boolean = str != null && str != ""
            }
            
            class Test
        
            package service {
                class MyService {
                    def sayHello(name: String) {
                        if(Utils.isNotEmpty(name)) {
                            println("Hello, " + name)
                        } else {
                            println("Who are you?")  
                        }
                    }
                }
            }
        }
    }
}

object MainClass {
  def main(args: Array[String]): Unit = {
    val service = new com.sunny.scala.service.MyService
    service.sayHello("leo")  
    service.sayHello("")  
  }
}

• package特性三: 相对包名与绝对包名

package com {
    package sunny {
        package scala {
            object Utils {
                def isNotEmpty(str: String): Boolean = str != null && str != ""
            }
            
            class Test
            
            package collection {}
            
            package service {
                class MyService {
                    // 这会报错，默认使用相对报名，从com.sunny.scala.collection包中，寻找mutable包下的ArrayBuffer类
                    // 但是找不到，所以会报错
                    // val names = new scala.collection.mutable.ArrayBuffer[String]
                    
                    // 正确的做法是使用_root_，引用绝对包名
                    val names = new _root_.scala.collection.mutable.ArrayBuffer[String]
                    
                    def sayHello(name: String) {
                        if(Utils.isNotEmpty(name)) {
                            println("Hello, " + name)
                        } else {
                            println("Who are you?")  
                        }
                    }
                }
            }
        }
    }
}

• package特性四: 定义package对象（比较少）

package内的成员，可以直接访问package对象内的成员

package com.sunny.scala

package object service {
    val defaultName = "Somebody"
}

package service {
    class MyService {
        def sayHello(name: String) {
            if(name != null && name != "") {
                println("Hello, " + name)
            } else {
                println("Hello, " + defaultName) 
            }
        }
    }
}

• package特性五: package可见性

package com.sunny.scala

class Person {
    private[scala] val name = "leo"
    private[sunny] val age = 25
}

---

import

如果没有import，那么。。。你每次创建某个包下的类的对象，都得用new com.sunny.scala.service.MyService这种冗长的格式。。。
所以如果用了import，那么。。。你只要先import com.sunny.scala.service.MyService，然后再new MyService，即可。。。

import com.sunny.scala.service.MyService;

object MainClass {
  def main(args: Array[String]): Unit = {
    val service = new MyService
    service.sayHello("leo")  
    service.sayHello("")  
  }
}

• import特性一: 用import com.sunny.scala.service._这种格式，可以导入包下所有的成员

• import特性二: scala与java不同之处在于，任何地方都可以使用import，比如类内、方法内，这种方式的好处在于，可以在一定作用域范围内使用导入

object MainClass {
  def main(args: Array[String]): Unit = {
    import com.sunny.scala.service._
    
    val service = new MyService
    service.sayHello("leo")  
    service.sayHello("")  
  }
}

• import特性三: 选择器、重命名、隐藏

import com.sunny.scala.service.{ MyService }，仅仅导入java.awt包下的Color和Font类
import com.sunny.scala.service.{ MyService => MyServiceImpl }，将导入的类进行重命名
import com.sunny.scala.service.{ MyService => _, _ }，导入java.util包下所有的类，但是隐藏掉HashMap类

• import特性四: 隐式导入

每个scala程序默认都会隐式导入以下几个包下所有的成员

import java.lang._
import scala._
import Predef._