object HelloWorld[首字母大写，驼峰]
class MyFirstScalaClass[首字母大写，驼峰]
def myMethodName()[首字母小写，驼峰]
def main(args: Array[String])[入口函数，格式固定]
package com.runoob {//包中含有的类
class HelloWorld
}
import java.awt.Color//导入*.java文件，其实是开放了通信路径
import java.awt._ // 引入包内所有成员
def handler(evt: event.ActionEvent) { // java.awt.event.ActionEvent
… // 因为引入了java.awt，可以省去前面的部分
}
import语句可以出现在任何地方，而不是只能在文件顶部。
import java.awt.{Color, Font}//可以导入多个*.java文件
import java.util.{HashMap => JavaHashMap}// 导入并重命名成员
import java.util.{HashMap => _, _} // 引入了util包的所有成员，但是HashMap被隐藏了，名称 _, _是被隐藏的意思(学python的)
//默认情况下，Scala 总会引入 java.lang._ 、 scala._ 和 Predef._
”’
Byte–>Short–>Int–>Long–>Float–>Double
Char
String
Boolean
Unit //用作不返回任何结果的方法的结果类型。Unit只有一个实例值，写成()。
Null //不懂，暂时很少见使用
Nothing //它是任何其他类型的子类型。
Any //是所有其他类的超类
AnyRef //是Scala里所有引用类(reference class)的基类
”’
Int：0xFFFFFFFF,0777L
Float：1e30f，3.14159f(以正则模式^.*?f$为特征)
scala> val pa=(40,”Foo”)//学python的元组
pa: (Int, String) = (40,Foo)
//Scala 访问修饰符基本和Java的一样，分别有：private，protected，public。默认访问级别是 public
//private在嵌套类情况下，外层类甚至不能访问被嵌套类的私有成员，Java中允许外部类访问内部类的私有成员。
//Scala中protected成员只允许保护成员在定义了该成员的的类的子类中被访问。Java中用protected关键字修饰的成员，除了定义了该成员的类的子类可以访问，同一个包里的其他类也可访问。
package p{
class Super{
protected def f() {println(“f”)}
}
class Sub extends Super{
f()
}
class Other{
(new Super).f() //错误，Other类未继承Super类，看不见Super中被protected的f()方法
}
}
//作用域保护，Scala中访问修饰符可以通过使用限定词强调。格式为:private[x]或protected[x]，这里的x指代某个所属的包、类或单例对象。如果写成private[x],读作”这个成员除了对[…]中的类或[…]中的包中的类及它们的伴生对像可见外，对其它所有类都是private。
package bobsrocckets{
package navigation{//navigation包中定义了一堆东西
private[bobsrockets] class Navigator{//被私有的类Navigator仅对bobsrockets包中的类可见
protected[navigation] def useStarChart(){}//被保护的方法useStarChart()仅对navigation包中的类及Navigator类和其子类可见
class LegOfJourney{
private[Navigator] val distance = 100//被私有的常量distance仅对Navigator类可见
}
private[this] var speed = 200//被私有的常量distance仅对LegOfJourney类的对象来调用时可见
}
}
package launch{//launch包中定义了一堆东西
import navigation._//导入包内所有成员
object Vehicle{
private[launch] val guide = new Navigator//被私有的常量guide仅对包launch中的类可见
}
}
}
object Test {
def main(args: Array[String]) {
var a = 10;
var b = 20;
var c = 25;
var d = 25;
println(“a + b = ” + (a + b) );
println(“a – b = ” + (a – b) );
println(“a * b = ” + (a * b) );
println(“b / a = ” + (b / a) );
println(“b % a = ” + (b % a) );
println(“c % a = ” + (c % a) );
println(“a == b = ” + (a == b) );
println(“a != b = ” + (a != b) );
println(“a > b = ” + (a > b) );
println(“a < b = ” + (a < b) );
println(“b >= a = ” + (b >= a) );
println(“b <= a = ” + (b <= a) );
var a = true;
var b = false;
println(“a && b = ” + (a&&b) );
println(“a || b = ” + (a||b) );
println(“!(a && b) = ” + !(a && b) );
}
}
//位运算符用来对二进制位进行操作，~,&,|,^分别为取反，按位与与，按位与或，按位与异或运算
object Test {
def main(args: Array[String]) {
var a = 60; /* 60 = 0011 1100 */
var b = 13; /* 13 = 0000 1101 */
var c = 0;
c = a & b; /* 12 = 0000 1100 */
println(“a & b = ” + c );
c = a | b; /* 61 = 0011 1101 */
println(“a | b = ” + c );
c = a ^ b; /* 49 = 0011 0001 */
println(“a ^ b = ” + c );
c = ~a; /* -61 = 1100 0011 */
println(“~a = ” + c );
c = a << 2; /* 240 = 1111 0000 */
println(“a << 2 = ” + c );
c = a >> 2; /* 15 = 1111 */
println(“a >> 2 = ” + c );
c = a >>> 2; /* 15 = 0000 1111 */
println(“a >>> 2 = ” + c );
}
}
1
() []
左到右
2
! ~
右到左
3
* / %
左到右
4
+ –
左到右
5
>> >>> <<
左到右
6
> >= < <=
左到右
7
== !=
左到右
8
&
左到右
9
^
左到右
10
|
左到右
11
&&
左到右
12
||
左到右
13
= += -= *= /= %= >>= <<= &= ^= |=
右到左
14
,
左到右
object Test {
def main(args: Array[String]) {
var x = 30;
if( x == 10 ){
println(“X 的值为 10”);
}else if( x == 20 ){
println(“X 的值为 20”);
}else if( x == 30 ){
println(“X 的值为 30”);
}else{
println(“无法判断 X 的值”);
}
}
}
object Test {
def main(args: Array[String]) {
var x = 30;
var y = 10;
if( x == 30 ){
if( y == 10 ){
println(“X = 30 , Y = 10”);
}
}
}
}
Scala函数名可以有以下特殊字符：+, ++, ~, &,-, — , \, /, :
def functionName ([参数列表]) : [return type]//无body，为隐式函数
def functionName ([参数列表]) : [return type] = {
function body
return [expr]
}
object add{
def addInt( a:Int, b:Int ) : Int = {
var sum:Int = 0
sum = a + b
return sum
}
}
object Hello{
def printMe( ) : Unit = {//无return，返回值是Unit类型，值为()
println(“Hello, Scala!”)
}
}
functionName( 参数列表 )//普通函数
[instance.]functionName( 参数列表 )//对象调用方法
object Test {//类中方法调用方法
def main(args: Array[String]) {
println( “Returned Value : ” + addInt(5,7) );
}
def addInt( a:Int, b:Int ) : Int = {
var sum:Int = 0
sum = a + b
return sum
}
}
scala> var x=10
x: Int = 10
scala> val s=if(x>9) 1 else -1
s: Int = 1
scala> val s=if(x>9) “xx” else “yy”
s: String = xx
scala> val s=if(x>9) “xx” else -1//两类值类型不一致，scala解释器只好推断为父类型Any
s: Any = xx
scala> val y=if(x>1) “jj”//没设置false时的返回值，即值类型不一致，退化成Any类型
y: Any = ()
scala> val y=if(x>11) {print(“hh”)}//没设置false时的返回值，true时是Unit，即值类型一致，故false时返回Unit类型的()
y: Unit = ()
scala> var h=if(x>5){//花括号未成对，body没结束，这里像R语言
| print(“Hello,World”)
| } else -1
Hello,Worldh: AnyVal = ()//值返回类型Unit和Int不一致，故返回的Int退化为AnyVal类型
scala> val y=if(x>11){ “jj”}//String和Unit不一致，故返回的Unit退化为Any类型
y: Any = ()
scala> object add{//函数名中表明返回值类型是好习惯
| def addInt( a:Int, b:Int ) : Int = {
| var sum:Int = 0
| sum = a + b
| return sum
| }
| }
defined object add
scala> add.addInt(10,20)
res2: Int = 30
scala> var y={}//不太理解，可能是{}属于执行语句的一种
y: Unit = ()
scala> var y={//a1,a2,a3首次出现需要声明，否则报”value找不到”错误
| a1=1
| a2=2
| a3=3
| }
<console>:11: error: not found: value a1
a1=1
^
<console>:12: error: not found: value a2
a2=2
^
<console>:13: error: not found: value a3
a3=3
^
scala> var y={//{}属于执行语句的一种，没在最后一句返回值，就属于执行语句了，返回Unit
| var a1=1
| var a2=2
| var a3=3
| }
y: Unit = ()
scala> var y={//如果是函数，return a3，如果是变量，直接a3
| var a1=1
| var a2=2
| var a3=3
| a3
| }
y: Int = 3
scala> println(“Hello %s, %d years old”, “Fred”, 42)//继承c，python的特点
(Hello %s, %d years old,Fred,42)
scala> val name=readLine(“your name”)//控制台输出，提示语句是”your name”，但是输的时候看不到
warning: there was one deprecation warning; re-run with -deprecation for details//不理解
your namename: String = ysjtyyyyyyyy
scala> name
res4: String = ysjtyyyyyyyy
scala> var n=10
n: Int = 10
scala> while(n<16){//n是循环外变量，被循环改变了
| println(n)
| n=n+1
| }
10
11
12
13
14
15
scala> while(n<22){
| println(n)
| n+=1
| }
16
17
18
19
20
21
scala> for(i<- 1 to 10)println(i)//<-相当于vb中=号，to是闭区间取整数
1
2
3
4
5
6
7
8
9
10
scala> for(i<- 0 until 10)println(i)//until是左闭右开取整数
0
1
2
3
4
5
6
7
8
9
scala> var sun=0
sun: Int = 0
scala> for(ch<-“abc”)sun +=ch//迭代的是字符串”abc”中的每个char，而在+号操作符作用下类型转换成Int数
scala> sun
res17: Int = 294
scala> for(i<- 1 to 3;j<- 1 to 3)print((10*i+i)+””)//双层循环
111111222222333333
scala> for(i<- 1 to 3;j<- 1 to 3 if i==j)println((10*i+i)+””)//for()括号最后一句可以加循环启动的条件判断
11
22
33
scala> for(i<- 1 to 3;temp=4-i;j<- temp to 3)println(i*j)//for()括号的双层循环中间可以加入多个临时变量
3
4
6
3
6
9
scala> def sayHello(name:String)={//不返回值的函数
| println(“Hi,”+name)
| }
sayHello: (name: String)Unit
scala> sayHello(“Tom”)
Hi,Tom
scala> def add(a:Int,b:Int):Int=a+b//返回值的需要在()后加:返回值类型
add: (a: Int, b: Int)Int
scala> add(1,2)
res26: Int = 3
scala> def fac(n:Int)={
| var r=1
| for(i<- 1 to 10)r=r*1
| r//最后的表达式是函数的返回值
| }
fac: (n: Int)Int
scala> fac(5)
res27: Int = 1
scala> def fac(n:Int):Int={if(n<=0)1 else n*fac(n-1)}//递归需要有出口
fac: (n: Int)Int
scala> fac(5)
res28: Int = 120
scala> def sayHi(name:String=”Everyone”){//参数的默认值，空参时发挥作用，学python
| println(“Hi,”+name)
| }
sayHi: (name: String)Unit
scala> sayHi(“Tom”)
Hi,Tom
scala> sayHi()
Hi,Everyone
scala> sayHi//定义函数时是有参的，调用时必须加()，建议无论定义时是空参还是有参，都加()号
<console>:13: error: missing arguments for method sayHi;
follow this method with `_’ if you want to treat it as a partially applied function
sayHi
^
scala> def sayHi(name:String*){//可变长参数，在类型后加*号，实际传入的是数组，所以可用for()迭代，学python
| for(e<- name)println(“Hi,”+e)
| }
sayHi: (name: String*)Unit
scala> sayHi(“Jenny”)
Hi,Jenny
scala> sayHi()
scala> sayHi(“Jenny”,”Tonny”,”Tom”)
Hi,Jenny
Hi,Tonny
Hi,Tom
scala> def sum(args:Int*)={//好例子
| var r=0
| for(arg<-args)r+=arg
| r
| }
sum: (args: Int*)Int
scala> val s=sum(1,2,3,4,5,6)
s: Int = 21
scala> val s1=sum(1 to 6:_*)//to不直接产生数组，需要解锁，在后面加:_*可以变成数组
s1: Int = 21