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)
}
}