1. 在Scala里使用Scala类
如果在单独的文件里创建Scala类，就可以轻松地使用它们，就像（无需显式编译）在Scala脚本里使用一样。不过，如果想在编译过的Scala或Java代码里使用Scala类，那就必须编译了。
举例如下：
package com.cn.peng
class Person(val firstName:String, val lastName:String) {
override def toString():String = firstName + " " + lastName
}
package com.cn.peng
class Dog(name:String) {
override def toString():String = name
}
下面是使用上面两个类的脚本：
package com.cn.peng
object use {
def main(args:Array[String]){
val george = new Person("George", "Washington")
val geogesDogs = List(new Dog("Captain"), new Dog("Clode"),
new Dog("Forester"), new Dog("Searcher"))
printf("%s had several dogs %s...", george,geogesDogs mkString ", ")
}
}
脚本会产生如下输出：
George Washington had several dogs Captain, Clode, Forester, Searcher...
2. 在Scala里使用Java类
在Scala里可以直接使用Java类。如果要用的Java类是标准JDK的一部分，直接用就是了。如果它不在java.lang里，就要导入类的包。下面用到了java.util和java.lang.reflect包：
package com.cn.peng
import java.util.Date
import java.lang.reflect._
object UseJDKClasses extends App {
println("Today is " + new Date())
val methods = getClass.getMethods()
methods.foreach{method:Method => println(method.getName())}
}
程序运行结果如下：
Today is Sat Apr 04 16:53:55 CST 2015 main delayedEndpoint$com$cn$peng$UseJDKClasses$1 args delayedInit scala$App$_setter_$executionStart_$eq executionStart scala$App$$_args scala$App$$initCode methods scala$App$$_args_$eq scala$App$_setter_$scala$App$$initCode_$eq wait wait wait equals toString hashCode getClass notify notifyAll
如果想用的Java类是你自己创建的，或是来自第三方，请确保scalac的classpath指向字节码的位置。假定我们有如下的Java文件：
package investments;
public enum InvestmentType {
SHORT_TERM,
BOND,
STOCK,
REAL_ESTATE,
COMMODITIES,
COLLECTIBLES,
MUTUAL_FUNDS
}
package investments;
public class Investment {
private String investmentName;
private InvestmentType investmentType;
public Investment(String name, InvestmentType type){
investmentName = name;
investmentType = type;
}
public int yield() { return 0; }
}
在Scala代码里使用这些类，同使用Scala类一样。下面是一个在Scala里创建Investment实例的例子：
package com.cn.peng
import investments._
object UseInvestment {
def main(args: Array[String]){
val investment = new Investment("XYZ Corporation", InvestmentType.STOCK)
println(investment.getClass())
}
}
运行结果如下：
class investments.Investment
Investment类的yield()方法需要小心使用。如果Java代码有方法或字段的名字（比如trait或yield等）于Scala的关键字冲突，调用它们会导致Scala编译器死掉。比如，下面的代码是不行的：
val theYield1 = investment.yield //ERROR
val theYield2 = investment.yield() //ERROR
幸运的是，Scala提供了一个解决方案。把冲突的变量/方法放到反引号里，就可以绕开这个问题。改一下代码就可以让上面的两个调用工作了：
val theYield1 = investment.`yield`
val theYield2 = investment.`yield`()
3. 在Java里使用Scala类
Scala提供了与Java之间完整的双向互操作性。因为Scala能编译成字节码，所以在Java里使用Scala类相当容易。默认情况下，Scala并不遵循JavaBean的约定，要用@scala.reflect.BeanProperty这个注解生成符合JavaBean预定的getter和setter。还可以从Scala类继承Java类，不过，要运行使用了Scala类的Java代码，classpath里需要有scala-library.jar。在本节里，我们会看到Scala的构造在Java端会表现出怎样的不同。
3.1 有普通函数和高阶函数的Scala类
遵循标准Java构造的Scala类相当直白，在Java端使用它们很容易。我们写一个Scala类：
package automobiles
class Car(val year:Int) {
private[this] var miles : Int = 0
def drive(distance:Int) {miles += distance}
override def toString():String = "year: " + year + " miles: " + miles
}
下面是个使用这个Scala类的Java类：
package com.cn.peng;
import automobiles.Car;
public class UseCar {
public static void main(String[] args){
Car car = new Car(2014);
System.out.println(car);
car.drive(10);
System.out.println(car);
}
}
程序运行结果如下：
year: 2014 miles: 0 year: 2014 miles: 10
在Java里使用Scala类相当简单。不过，不是所有的Scala类都那么友善。比如，如果Scala类有方法接收闭包，这些方法在Java里就不可用，因为Java目前尚不支持闭包。下面Equipment类的simulate()方法对Java就是不可用的；不过，我们可以用run()方法：
package com.cn.peng
class Equipment {
//Not usable from Java
def simulate(input:Int)(calculator:Int => Int):Int = {
//...
calculator(input)
}
def run(duration:Int){
println("running")
//...
}
}
因此，设计API的时候，如果类主要是给Java用，请在提供高阶函数的同时也提供普通函数，让这个类对Java完全可用。
3.2 同trait一起工作
没有方法实现的trait在字节码层面上就是简单的接口。Scala不支持interface关键字。因此，如果想在Scala里创建接口，就创建一个没有实现的trait。下面是个Scala trait的例子，他也是个接口：
package com.cn.peng
trait Writable {
def wirte(message: String):Unit
}
上面的trait里面有个抽象的方法，混入这个trait的类都应该实现这个方法。在Java端，Writable可以看做与其它接口一样；它对Scala根本没有依赖。所以，可以这样实现（implement）它：
package com.cn.peng;
public class AWritableJavaClass implements Writable{
@Override
public void wirte(String message) {
// TODO Auto-generated method stub
}
}
不过，如果trait有方法实现，那么Java类就不能实现这个trait/interface，虽然它们可以使用它。因此，在Java里不能实现下面的Printable，但可以持有一个Printable的引用：
package com.cn.peng
trait Printable {
def print(){} //default print nothing
}
如果想让Java类实现trait，就让它纯粹些；换句话说，不要有实现。在这种情况下，任何公共的实现都应该放到抽象基类里，而不是trait里。不过，如果只是想让Java类使用trait，就没有任何限制。
3.3 单例对象和伴生对象
Scala将对象（单例对象或伴生对象）编译成一个“单例类”——这个类的名字末尾有一个特殊$符。这样，下面所示的Object Single，会产生一个类名Single$。不过，Scala处理单例对象和伴生对象有些不同，稍后可以看到。
Scala把单例对象编译到一个单例类（它用的是Java的静态方法）中，此外，还会创建一个普通的类，它把调用传递给单例类。所以，下面这段代码创建了一个单例对象Single，而Scala则创建了两个类：Single$和用来传递调用的类Single。
package com.cn.peng
object Single {
def greet(){println("Hello from Single")}
}
在Java里使用上面的单例对象，就像使用由static方法的Java类一样，如下所示：
package com.cn.peng;
public class SingleUser {
public static void main(String[] args){
Single.greet();
}
}
上面代码的输出如下：
Hello from Single
如果对象是同名类的伴生对象，Scala会创建两个类，一个类表示Scala类（下面例子里的Buddy），另一个类表示伴生对象（下面例子里的Buddy$）：
package com.cn.peng
class Buddy {
def greet(){println("Hello from Buddy class")}
}
object Buddy {
def greet(){println("Hello from Buddy object")}
}
访问伴生类可以直接使用类的名字。访问伴生对象需要使用特殊的符号MODULE$，如下例所示：
package com.cn.peng;
public class BuddyUser {
public static void main(String[] args){
new Buddy().greet();
Buddy$.MODULE$.greet();
}
}
输出如下：
Hello from Buddy class Hello from Buddy object
4. 继承类
Scala类可以继承Java类，反之亦然。大多数情况下，这应该够用了。之前也讨论过，如果方法接收闭包作为参数，重写起来就有些麻烦。异常也是这个问题。
Scala没有throws字句。在Scala里，任意方法都可以抛出异常，无需显式声明成方法签名的一部分。不过，如果在Java里重写这样的方法，试图抛出异常，就会陷入麻烦。看个例子，假设Scala定义了Bird：
package com.cn.peng
abstract class Bird {
def fly();
//...
}
还有另一个类Ostrich：
package com.cn.peng
class Ostrich extends Bird {
def fly(){
throw new NoFlyException
}
//...
}
其中NoFlyException定义如下：
package com.cn.peng
class NoFlyException extends Exception{
}
在上面的代码里，Ostrich的fly()抛出异常没有任何问题。不过，如果要在Java里实现一个不能飞的鸟，就会有麻烦，如下所示：
package com.cn.peng;
public class Penguin extends Bird{
public void fly() throws NoFlyException {
throw new NoFlyException();
}
//...
}
首先，如果只是抛出异常，Java会报错“unreported exception NoFlyException;must be caught or declared to be thrown." 一旦加上了throws子句,java又会报错”Exception NoFlyException is not compatible with throws clause in Bird.fly()“。
即便Scala很灵活，并不强求一定要指定抛出哪些异常，但是要想在Java里继承这些方法，就要告诉Scala编译器，把这些细节记录在方法签名里。Scala为此提供了一个后门：定义@throws注解。
虽然Scala支持注解，但它却不提供注解的语法。如果想创建自己的注解，就不得不用Java来做。@throws是已经提供好的注解，用以表示方法抛出的受控异常。这样，对我们来说，要在Java里实现Penguin，必须在把Bird改成这样：
package com.cn.peng
abstract class Bird {
@throws(classOf[NoFlyException]) def fly();
//...
}
现在，编制上面的代码，Scala编译器会在字节码里为fly()方法放上必要的签名。经过了这个修改，Java类Penguin就可以正常编译了。