Scala介绍-CSDN博客

强大的编程语言

Scala 是一门非常强大的语言，它允许用户使用命令和函数范式进行编写代码，因此，编程时你可以使用常用的命令式语句，就像我们使用 C、Java、PHP 以及很多其他语言一样，而且，你也可以使用类似 Lisp 语言中函数式语句，还有，你可以混合使用这两种风格的语句，就像 Ruby 或 Groovy。 Scala 几乎支持函数语言中所有已知的功能，比如，模式匹配（Pattern matching）、延迟初始化（Lazy initialization）、偏函数（Partial Function）、不变性（Immutability），等等...即是说，认识到这样一个事实是非常重要的：Scala 的强大源自它对函数范式的支持，而后者令 Scala 成为一种高等级（high-level）的编程语言。对于高等级的编程语言，你只需关注 what（做什么）而不是如何做（how）。

面向对象特性[编辑]

Scala是一种纯面向对象的语言，每一个值都是对象。对象的数据类型以及行为由类和特质描述。类抽象机制的扩展有两种途径。一种途径是子类继承，另一种途径是灵活的混入机制。这两种途径能避免多重继承的种种问题。

函数式编程[编辑]

Scala也是一种函数式语言，其函数也能当成值来使用。Scala提供了轻量级的语法用以定义匿名函数，支持高阶函数，允许嵌套多层函数，并支持柯里化。Scala的case class及其内置的模式匹配相当于函数式编程语言中常用的代数类型。

高效

Scala 是一种高效的编程语言，实际上，根据最新的 benchmark 性能测试，它几乎和 Java 一样快捷。在 JVM 上实现的 Scala 代码，可以编译为字节码，在这一过程中，代码通过优化阶段进行编译。

下面，让我们看一个 Java 示例：

 
      
           int 
           [] x = { 
           1 
           ,  
           2 
           ,  
           3 
           ,  
           4 
           ,  
           5 
           ,  
           6 
           }; 
          
 
             
          
 
           ArrayList res =  
           new  
           ArrayList(); 
          
 
           for  
           ( 
           int  
           v : x) { 
          
 
                
           if  
           (v %  
           2  
           ==  
           1 
           ) res.add( 
           new  
           Integer(v)); 
          
 
           } 
          
 
    

Scala代码：

我们可以看到，相对于上文中的 Java 代码段，这段代码更加简洁，而且具有更好的可读性。

可扩展

Scala 语言本身的名字 Scala 来自 Scalable（可扩展的）一词，这意味着这种语言可以按照用户的需求进行扩展。因此，从根本上来讲，用户可以添加新的类型和控制结构。比如，我想要添加一个简单的“loop”控制结构：

// 一个简单的构建

 
      
           def  
           loop(range 
           :  
           Range)(op 
           :  
           Int 
           = 
           > Unit) 
          
 
           { 
          
 
                
           range foreach (op) 
          
 
           } 
          

              
          
 
           loop( 
           1  
           to  
           5 
           ) { println }  
           // 1 2 3 4 5 
          
 
           loop( 
           1  
           to  
           5 
           ) { x  
           = 
           >  
           if  
           (x  
           %  
           2  
           ==  
           0 
           ) println(x) }  
           // 2 4 
          
 
    

不过，Scala 之所以是可扩展的，在于互相关联的两点：它是真正的面向对象的语言和真正的函数式语言。

面向对象

Scala 中每个事物都是对象（对象的方法除外），因此，没有必要对基本（primitive）类型或引用类型进行区分，这就是所谓的：统一对象模型（Uniform Object Model）。但是，正如我之前在优化流程中所提到的，值类型对象被转换为 Java 基本类型，因此不必担心性能的问题。其内部还包含为类方法分组的单件对象（Singleton object）。

◆所有操作都是方法调用，+ - * ! / 都是方法，因此，没有必要进行操作符重载。

函数式语言

函数式语言具有很多特点，不过在扩展性这一语境中，我们所关心的是两个事实：

◆函数是第一等级（first-class）的值
这表示用户可以将函数作为值传递，也可以作为值返回。这样可以获得简洁而具有可读性的代码，正如上文中作为示例的过滤代码段。

◆纯函数（pure function）
Scala 支持没有副作用的纯函数，这意味着：如果你的输入相同，那么输出结果也总是相同。这样能够让代码更为安全，对代码测试也更为方便。

更佳的并行模型

当涉及到线程这一问题时，Scala 支持传统的 shared data 模型。但是，使用这种模型较长一段时间之后，许多人发现使用这种模型编写代码，非常难以实现以及进行测试。你总是需要考虑死锁问题和竞争条件。因此，Scala 提供了另一个称为 Actor 的并行模型，其中，actor 通过它的收件箱来发送和接收非同步信息，而不是共享数据。这种方式被称为：shared nothing 模型。一旦你不再顾虑共享数据的问题，也就不必再为代码同步和死锁问题而头痛。

被发送信息的不变性本质以及 actor 中串行处理，这两者使得对于并行的支持更为简便。

静态类型

◆使用静态类型语言编写的代码更加健壮（robust）
对于动态类型语言，你需要编写更多的测试代码来检查类型，而在静态类型语言中，你可以将这些问题交给编译器处理。

◆使用静态类型语言编写的代码过于严格和冗长

Scala 具有一个灵活的类型系统，并且可能是这一类型中最好的。很多情况下，如果你没有指定类型，这一系统将能够对类型进行推断。

例如，你可以这样编写代码：

 
      
           val  
           list 
           :  
           List[String]  
           =  
           List( 
           "one" 
           ,  
           "two" 
           ,  
           "three" 
           ) 
          
 
           val  
           s 
           :  
           String  
           =  
           "Hello World!" 
          
 
    

但你也可以这样编写代码：

 
      
           val  
           list  
           =  
           List( 
           "one" 
           ,  
           "two" 
           ,  
           "three" 
           ) 
          
 
           val  
           s  
           =  
           "Hello World!" 
          
 
    

模式匹配

模式匹配究竟是用来做什么的？它让你可以将一个值对多种情况（case）进行匹配，有点类似 Java 中的分支（switch）语句。但它不是仅仅匹配数字（这是分支语句的作用），而是用户能够对本质上为对象创建形式（creation form）的事物进行匹配。

 
           x  
           match  
           { 
          
           case  
           Address(Name(first, last), street, city, state, zip)  
           = 
           > println(last +  
           ", "  
           + zip) 
          
           case  
           _  
           = 
           > println( 
           "not an address" 
           )  
           // 缺省情况 
          
           }