scala-简介

 

 

 

scala定义变量

//不可变的变量
val msg = "Hello, world!"

//可变的变量，可以不用写变量类型，scala会自动推导
val msg2: java.lang.String = "Hello again, world!"

 

 

 

scala函数基本构成

定义函数如下

def max(x: Int, y: Int): Int = { 
    if (x > y) x 
    else y 
}

 

 

scan循环

var i = 0 
while (i < args.length) { 
    println(args(i)) 
    i += 1 
}

//用scala函数的语法
args.foreach(arg => println(arg))
//完整参数形式
args.foreach((arg: String) => println(arg))
//如果函数文本只有一个参数一句话组成可以简写
args.foreach(println)

//迭代，可以写到脚本里，比如test.scala
for (arg <- args) println(arg)

scala函数文本的语法

 

 

 

 

带类型的参数化数组

val greetStrings = new Array[String](3) 
greetStrings(0) = "Hello"
greetStrings(1) = ", " 
greetStrings(2) = "world!\n" 
for (i <- 0 to 2) 
    print(greetStrings(i))

//上面那段相当于
val greetStrings:Array[String] = new Array[String](3) 
greetStrings.update(0, "Hello") 
greetStrings.update(1, ", ") 
greetStrings.update(2, "world!\n") 
for (i <- 0.to(2)) 
    print(greetStrings.apply(i))

 

 

val numNames = Array("zero", "one", "two")

//上面这段代码相当于
val numNames2:Array[String] = Array.apply("zero", "one", "two")

 

 

1+2等于

1.+(2)

 

 

 

 

对象的定义

package test.obj

/**
 * 定义Rational类，类后面跟的(n:Int,d:Int)是构造函数传入的参数
 */
class Rational(n:Int,d:Int) {
	//定义这两行是lessThan()函数中比较的时候this.n == that.n的时候不会报错
        val numer:   Int = n 
        val denom:   Int = d
        private val g = gcd(n.abs, d.abs)
	println("create->"+n+"/"+d)
	
	//检查分母不能为0，
	require(d != 0)
	
	/**
	 * 定义一个从构造函数，从构造函数中调用了主构造函数
	 */
	def this(n:Int) {
		this(n,1)
	}
	
	/**
	 * 重载toString函数，默认toSring返回的结果是Rational@4b1d6571
	 */
	override def toString():String = {
		n +"/"+ d
	}
	
	/**
	 * 两个Rational相加，这个操作不会改变原始值，会返回一个新对象
	 */
	def add(that: Rational): Rational = {
		new Rational( number * that.denom + that.number * denom, denom * that.denom)
	}
	
	/**
	 * 比较两个Rational大小，这里用到了this关键字，这里是可以省略的
	 */
	def lessThan(that: Rational): Boolean = {
		this.number * that.denom < that.number * this.denom
	}
	
	/**
	 * 返回两个Rational中最大的那个，注意else中的this就不能省略了，返回就返回空了
	 */
	def max(that: Rational): Rational = {
		if(this.lessThan(that)) {
			that
		}
		else {
			this
		}
	}
	
        //定义私有的函数
        private def gcd(a: Int, b: Int): Int = if (b == 0) a else gcd(b, a % b)
	/**
	 * 重载 + ，这样可以实现两个Ratioinal的 + 操作了
	 */
	def +(that: Rational): Rational = {
		new Rational( number * that.denom + that.number * denom, denom * that.denom )
	}
	
	/**
	 * 函数重载，可以传入整型，这样可以实现Rational和整数之间的运算
	 */
	def +(i: Int): Rational = {
		new Rational(number + i * denom, denom)
	}
	
	/**
	 * 重载 * 操作，让两个Rational之间实现乘法操作
	 */
	def *(that: Rational): Rational = {
		new Rational(number * that.number, denom * that.denom)
	}
	
	/**
	 * 重载 * 操作，让Rational和整数相乘
	 */	
	def *(i: Int): Rational = {
		new Rational(number * i, denom)
	}
	
	/**
	 * 重载- 操作，让两个Rational之间实现减法操作
	 */
	def -(that: Rational): Rational = {
		new Rational( number * that.denom - that.number * denom, denom * that.denom ) 
	}
	
	/**
	 * 重载 * 操作，让Rational和整数之间实现减法操作
	 */	
	def -(i: Int): Rational = {
		new Rational(number - i* denom, denom)
	}
	
	/**
	 * 重载 * 操作，让两个Rational之间实现除法操作
	 */
	def /(that: Rational): Rational = {
		new Rational(number * that.denom, denom * that.number) 
	}
	
	/**
	 * 重载 * 操作，让Rational和整数之间实现除法操作
	 */
	def /(i: Int): Rational = {
		new Rational(number, denom * i)
	}
	
}




/**
 * 测试类
 */
object Test {
	def main(args : Array[String]) {	
		var x1 = new Rational(1,2)
		var x2 = new Rational(2,3)
		var x3 = x1.add(x2)
		println(x3)
		
		println(x1 + x3)
		println(x2 * x3)
			
		println("======")
		println(2 + x1)
	}
	
	implicit def intToRational(x: Int): Rational = {
		new Rational(x)
	}
}