Scala拾趣--从Java7说开来

　　我们知道，关于当前正在进行中的Java7在Java社区有很多讨论。其焦点集中在要不要在Java7中引入一些新的语言特性，尤其是闭包：不仅有要不要加入闭包的争论，还有采用那种实现方式的问题。在javapolis举行的关于JAVA7语言特性投票的结果一文中列出了Java7中可能会加入的语言特性，那么我们先来看看在Scala中对于这些语言特性有何解决方式呢？
　　首先把闭包撇出来，因为对闭包不甚了解，所以就不多说。不过以我的看法，因为Scala本身就支持函数式编程，而Java还需要向后兼容性的考虑，所以我觉得Java7中无论以那种方式来实现闭包，也不太可能比Scala中的实现更加有效，或更加优雅。
　　下面我们就逐条来分析Java7中的十种语法提议：

1.Property declaration
2.Property access
　　这两条都是为了简化书写代码，这里用一个具体的例子来说明：
　　考虑一个Person类，这个类有两个属性，一个是表示姓名的forename，在JAVA7中可能的实现方式：

public class Person {   
 public property String forename;   
 public property int age;   
} 

 

　　而使用Scala，则可以使用下列方式（参考资料:Defining a BeanProperty）：

class Person(@BeanProperty var forename:String,@BeanProperty var age:Int)

　　一行代码搞定！



3.Improve generics
　　Scala中也支持泛型，而且貌似比JAVA中的更灵活。不过其实现方式与目前的JAVA一样，都是使用擦除化。因此对于JAVA中泛型存在的一些问题，Scala中也存在（唔，至少这条提议中列出的两个问题在Scala中也同样存在。其他的我不太清楚，目前对Scala中的泛型理解尚浅）。


4.Access List and Map using []
　　在Scala中可以像下面一样使用Map：

import scala.collection.mutable.HashMap
object MapAccess extends Application{
    var map =new HashMap[Int,String]
    map(0) ="Zero"
    map += 1 -> "One"
    map += 2 -> "Two"
    var value =map(2)
    println(value)
}

　　可以看到，在Scala中可以通过map(key)来读取value，通过map(key) =value来写入值对...
　　事实上，Scala中并没有对Map提供特别的语法支持。也就是说，对任意的类，你都可以像操作Map一样。只要你在一个类a中定义了apply方法，你就可以把这个类当作一个函数来使：
   　　a(something)
　　这等价于：
   　　a.apply(something)
　　如果你还定义了update方法，你就可以使用
   　　a(key) =value
　　这等价于
   　　a.update(key,value)
　　怎么样，不赖吧？

5,10.Null-handling and chaining
　　之所以有这两个提议，是由于在Java中存在null以及void类型的方法。在Java中，很多方法会返回一个null表示没有得到预期的结果或结果为空。事实上大部分情况这样做是不恰当的，这时抛出一个异常或返回一个表示“空”的对象（比如字符串“”，或空的List）可能更合理。而且这样造成的后果是对于很多方法调用后需要对其结果是否为null进行判断。
　　幸运的是，Scala中没有这些问题。
　　第一：在Scala中没有void，也就是说每个方法都会返回一个实实在在的对象（Java中的void在Scala中有一个对应的类Unit）。
　　第二：对于标准的Scala程序，null不应该出现。相对应的Scala中有个Option类来处理这种返回结果为“空”的情形。
　　这里我也不细说了，有兴趣的可以参看opensdp同学的 用Scala语言中的 Option 对象来处理 null-like 返回值。



6.Extension methods
　　这个有点像Ruby中的“open class”，就是允许在不修改原有代码的情况下给已有的类添加新的方法。
　　由于JAVA是静态类型语言，并且不允许两个名字完全一样的类的存在，所以在这一点的实现肯定会有很多限制，不可能做到像Ruby那样。目前有两种解决方案：


　　第一种实现可以看成是static import的一种扩展；第二种实现同样用到了static import，并且需要修改已有代码。
　　总之，这两种方案看起来都不甚优雅，甚至可以说丑陋。其意义也不大，并且对代码的可读性会造成一定的影响。
　　那么我们来看看Scala中能够如何解决这个问题。Scala中有一个功能很强大的机制：隐式类型转换。这个机制威力巨大，用处远不止Extension methods，这里我只举个例子说明如何解决Extension methods，有兴趣的可以参看fakechris同学写的scala学习笔记(5) -- implicit type

　　在Ruby中，我们可以通过如下方式向String类中添加print_self方法：

class String
  def print_self
    puts self
  end
end

　　然后我们就可以对普通的String调用print_self方法：

"Daniel Spiewak".print_self    # prints my name

　　那么Scala中怎末实现这个呢？很简单：

object StringTest extends Application{
    
    "Eastsun".printSelf         //对String调用printSelf方法
    
    implicit def stringWrapper(s:String) =new {
        def printSelf = println(s)
    }
}

　　并且在类StringTest可见的范围内，这个方法都是有效的。（参考资料：Getting Over Java）



7.String switch
　　在Scala中没有switch关键词，但是有另一个强大得多的机制（不过，也复杂得多）：Pattern match。实现String switch功能，那只不过是小菜一根。

object MatchTest extends Application{
    
    test("hello")
    
    def test(obj:Any):Unit = obj match{
        case 1|2|3|4 => println("A integer between 1 and 4")
        case "hello" => println("Hi")
        case _       => println("something else")
    }
}

8.Typedef
　　唔，对于这个功能...但是Scala中恰好就有这样一个关键词type，typedef就是这个关键词的作用之一：

import scala.collection.mutable.HashMap
object TypeTest extends Application{
    type ISMap =HashMap[Int,String]
    var map =new ISMap
    map(1) ="One"
}

9.Multi-catch
　　这里我们又可以来感受一下Scala中Pattern match的威力了：

import java.io.IOException
object ExceptionCatch extends Application{
    
    exceptionCatch(ioexceptionThrow)
    
    def ioexceptionThrow():Unit = throw new IOException
    
    def exceptionCatch(func:()=>Unit) =
        try{
            func()
        }catch{
            case _:IllegalArgumentException|_:IllegalStateException => println("RuntimeException")
            case _:IOException => println("IOException")
            case _             => println("Something else")
        }
}

　　结论：可以看到，目前在JAVA中想方设法想要加入的语言特性，在Scala中要么是根本不需要的东西，要么是以一种更加优雅的方式实现了。但同时，在学习Scala的过程中，一方面感受到Scala语法所带来的巨大便利与威力，另一方面其语法比起JAVA来复杂了许多。譬如在Java中粗略来说有interface,abstract class与普通的class。而Scala中除了普通的class与abstract class还有case class，sealed class,trait,object这些类型的类。更不用说Scala中那些函数式有关的语法了。
　　因此，可能有人会有疑问：有着这么复杂语法的语言有存在的必要吗？会不会成为下一个C++（恐龙）呢？Daniel Spiewak 在他的博客Is Scala Really the Next C++?中也提出了这个问题，他的答案是否定的。主要的理由是：C++由于兼容的目的背上了C这个沉重的包袱，由于C的影响，很多语言特性不能很好的实现；而Scala不同，Scala与Java在源代码上是不兼容的，因此Scala可以更加自由的发挥。
　　我比较赞同这个观点，同时觉得Java7不应该添加太多的东西进去了。虽然现在Java代码相对其他新式语言来说显得啰嗦，但是Java简单，这就是它最大的优点。如果Java即要考虑向后兼容性，又想把新的特性一股脑加进去，到后来只可能走向C++的老路。这些新的特性应该由JVM上的其他语言来实现，比如Groovy，比如Scala。你觉得呢？
　　PS:根据达尔文的理论，生物的进化包括遗传与变异。而目前的JAVA是只“遗传”不“变异”，这对于语言的进化也是很不好的。

其实一开始决得java简单，是因为java有一些固定的规范。比方 命名等等。现在java7搞得这些东西，把java搞复杂了。其实本义是好的。但是，由于写法灵活了，反而复杂了。现在我觉得c#已经不亚于c++的复杂程度了。不希望java也朝了c#的方向走。

   如果你觉得繁，可以不用要加入的新特性，为什么不加？（前提：如果Java7向后兼容性足够好）何乐而不为呢？

问题是如果需要兼容，就不太可能实现的很优雅
譬如JAVA5中的泛型。。。和鸡肋差不多。
以及将要加入的闭包，其实现方式也够呛。
这种打补丁式的改进总不会太完美。

PS：弄一个JAVA3000出来也不错，抛弃向后兼容性。

一行代码搞定,不是很好.代码太宽了.如同ErLang那样.
Ruby的那种方式比较好.有点AOP的意思.可以集中声明 attribute (property? 记不清了)
attribute : id, name
public : name
private : id

个人觉得property那部分，可以用annotation，比引入新的关键字和谐的多，可以在编译期做些手脚，根据annotation生成get,set方法，例如

class Student{
    @Property //代表可以get 和set
    private String name;
    
    @Setter //代表可以set
    private Integer age;
    //省略get set方法
}

同时也可以对"="和"."符号做特殊处理，例如

student.information.content = "hahaha";//会编译成student.getInformation().setContent("hahaha");
student.age = 19;//会被编译成student.setAge(19);

可能实现得不太优雅，不过似乎还挺好用。

貌似Scala中还有几种不同的实现方式，下面这样也可以(参考The busy Java developer's guide to Scala: Don't get thrown for a loop!)：

class Person(name:String, a:Int){
	@scala.reflect.BeanProperty
	var firstName = name
	
	@scala.reflect.BeanProperty
	var age = a
}

另外，好像Scala并没有针对Property的特殊语法，这些都是通过annotation实现的。

嗯，用处还是有一些的，使用那些集合类的时候就方便了很多。

不过其坏处也不少，尤其是让JAVA的语法复杂了不少。JAVA中的继承以及方法复写重载部分的语法有很多很诡异的变化。

比如：

import java.util.*;
class GT1{
    public void print(List<Integer> list){
    }
    public void print(List<String> list){
    }
}

上面这段代码是编译不过的，而下面的就可以：

import java.util.*;
class GT2{
    public Integer print(List<Integer> list){
        return null;
    }
    public String print(List<String> list){
        return null;
    }
}

这样的情形就很让人迷惑了。当然，搞清楚擦除法原理后还是可以理解的。但这已经失去了JAVA的原味。

我没有用过其他的语言，感觉JAVA这个泛型很好用，很不错！