Scala第一章学习笔记

　　面向对象编程是一种自顶向下的程序设计方法。用面向对象方法构造软件时，我们将代码以名词（对象）做切割，每个对象有某种形式的表示服(self/this)、行为（方法）、和状态（成员变量)。识别出名词并且定义出他们的行为之后，再定义出名词之间的交互。

　　函数式编程方法通过组合和应用函数来构造软件。纯粹是对输入进行操作，产生结果。所有变量都被认为是不可变的。

　　Spring的JDBCTemplate类上的查询方法

public interface JdbcTemplate{

    List query(PreparedStatementCreator psc,RowMapper rowMapper)

    .......

}

　　用Scala直译

trait JdbcTemplate{

    def query(psc : PreparedStatementCreator,rowMapper : RowMapper) : List[_]

}

看一下PreparedStatementCreator接口和RowMapper接口

public interface PreparedStatementCreator {

    PreparedStatement createPreparedStatement(Connection con) throws SQLException;

}

public interface RowMapper{

    Object mapRow(ResultSet rs, int rowNum)

throws SQLException;

}

Scala提供了一等函数，把JdbcTemplate查询方法改成接受函数而不是接口作为参数。这样query方法就编程函数式了，返回值为ResultItem,这就是传说中的租借模式了。这样就创建了一个直接使用函数参数的接口了。

trait JdbcTemplate{

    def query[ResultItem](psc:Connection => PreparedStatement; rowMapper : (ResultSet,Int) => ResultItem) : List[ResultItem]

}

Scala组合断言， or 方法接受两个断言，f1,f2，产生一个匿名函数。这个函数接受函数t,然后把f1(t)和f2(t)的结果 or 一下。

object Predicates{

    def or[T](f1 : T => Boolean, f2 : T =>Boolean) = (t : T) => f1(t) || f2(t)

    def and[T](f1 : T =>Boolean,f2 : T=> Boolean) = (t : T)=> f1(t) && f2(t)

    val notNull[T] : T => Boolean = _ != null

                                   (_为语法占位符)

Scala把变量类型等基本操作

//可变整型变量

var x : Int

//不可变整型变量

val x : Int

//延迟执行的不可变整形变量

lazy val x : Int

//用户指定类型

val x : Int = 5

//编译器推断类型

val y = 5

def myMethod(functionLiteral : A => B) : Unit

//显示的类型声明

myMethod({ arg : A : => new B})

//类型推断

myMethod({ arg => new B})

较简洁版的Scala快速排序

def qsort[T <% Ordered[T]](list:List[T]):List[T] = list match{

    case Nil => Nil

    case x :: xs =>

        val (before,after) = xs partition ( _ < x)

        qsort(before) ++ (x :: qsort(after));

)

Scala调用Java 使Java类库成为用Scala做开发时很自然的事

//Java对象

class SimpleJavaClass {

    private String name;

    public SimpleJavaClass(String name){

    this.name = name;

    }

    public String getName(){

     return name;

    }

    public static SimpleJavaClass create(String name){

        return new SimpleJavaClass(name);

    }

}

//Scala里使用简单java对象

    val x = SimpleJavaClass.create("Test")

    x.getName()

    val y = new SimpleJavaClass("Test")

Scala对象映射到java Scala对象实际上是一个单例类，在编译时此单例类命名为对象名后价格$符号。这个单例类里有个Module$静态成员，指向其唯一实例。

//Scala 对象

object ScalaUtils{

    def log(msg : String) : Unit = Console.println(msg)

    val MAX_LOG+SIZE = 1056

}

//在Java里使用Scala对象

ScalaUtils.log("Hello!");

ScalaUtils$.MODULE$.log("Hello");

System.out.println(ScalaUtils$.MODULE$.MAX_LOG_SIZE());

System.out.println(ScalaUtils.MAX_LOG_SIZE());

巴特西

Scala第一章学习笔记

最新文章

热门文章