180124_scala笔记1

Scala(类java语言，面向对象 且 函数式):
scala-2.11.7.msi(jdk<1.8) jdk1.7.80
scala-2.12.X.msi(jdk>=1.8)


windows上安装scala
我的安装路径：D:\CodeProgram\Scala


环境变量：
SCALA_HOME：D:\CodeProgram\Scala
Path：%SCALA_HOME%\bin;%SCALA_HOME%\jre\bin;(追加)
CLASSPATH：.;%SCALA_HOME%\bin;%SCALA_HOME%\lib\dt.jar;%SCALA_HOME%\lib\tools.jar.;


检验安装：
windows+r --> cmd -->scala
'''
Welcome to Scala version 2.11.7 (Java HotSpot(TM) 64-Bit Server VM, Java 1.7.0_80).
Type in expressions to have them evaluated.
Type :help for more information.
'''




scala> println("Hello World!")[正常打印是println]
Hello World!


scala> print("Hello World!")[print没换行]
Hello World!


scala -version [java -version 和java一样查看版本]


echo %path%[cmd查看path，此时path中的相对变量已赋值]
scala> :quit [scala的退出方式]


scala> res3.to[按tab键，会给出提示]
toCharArray   toLowerCase   toString   toUpperCase


scala> res5.[按tab键，会给出提示]
+                 compareTo             equalsIgnoreCase   isInstanceOf         replace        substring
asInstanceOf      compareToIgnoreCase   getBytes           lastIndexOf          replaceAll     toCharArray
charAt            concat                getChars           length               replaceFirst   toLowerCase
codePointAt       contains              indexOf            matches              split          toString
codePointBefore   contentEquals         intern             offsetByCodePoints   startsWith     toUpperCase
codePointCount    endsWith              isEmpty            regionMatches        subSequence    trim


scala> val c=100[首次出现的名称，需要告知是val(value，即值变量，常量的意思)还是var(variable，即变量)]
c: Int = 100[这里的Int类型和java的Int1类型不同，没声明常量c是Int类型，但是scala会类型推断，像python一样]


scala> c=200[已出现过的名称，可以不告知val还是var，然而原本为val的名称，不能再被赋值]
<console>:11: error: reassignment to val[报'对常量改变值'的错误]
       c=200


scala> var c=200[对名称c重新解读]
c: Int = 200


scala> c=300[已出现过的名称，可以不告知val还是var，变量var能再被赋值]
c: Int = 300


scala> c="oop"[已出现过的名称，可以不告知val还是var，变量var能再被赋值，但要符合先前的类型推断，不能改变]
<console>:11: error: type mismatch;[报'类型不匹配'的错误]
 found   : String("oop")
 required: Int
       c="oop"
         ^


scala> var c="oop"[对名称c重新解读]
c: String = oop


scala> var c=100[对名称c重新解读]
c: Int = 100


scala> c:Byte=100[已出现过的名称，若不进行重新解读，类型不能声明]
<console>:1: error: ';' expected but '=' found.
c:Byte=100
      ^


scala> var c:Byte=100[已出现过的名称，进行重新解读，可声明类型，该类型需匹配或继承scala的类型推断]
c: Byte = 100


scala> var c:byte=100[类型不能忽略大小写]
<console>:10: error: not found: type byte
       var c:byte=100


scala> var d:Byte=127
d: Byte = 127


scala> var d:Byte=128[Byte上限127]
<console>:10: error: type mismatch;
 found   : Int(128)
 required: Byte
       var d:Byte=128


scala> var d:Short=32768
<console>:10: error: type mismatch;
 found   : Int(32768)
 required: Short
       var d:Short=32768
                   ^


scala> var d:Short=32767[Short上限32767]
d: Short = 32767


scala> var a,b,c=100[继承python语法，对多个名称赋值，实际汇编运行c=100,b=c,a=b]
a: Int = 100
b: Int = 100
c: Int = 100


scala> var a,b,c=1,2,3[未继承python元组语法，不能这样赋值]
<console>:1: error: ';' expected but ',' found.
var a,b,c=1,2,3


scala> var a:Any=100[Any是任意类型，像vba里的变体类型variant]
a: Any = 100


'''数据类型
Byte->Short->Int->Long->Float->Double
Char
Boolean
'''


scala> 100.toString()[数据类型都能访问方法，调用方法加不加()都行]
res7: String = 100


scala> 100.toString
res8: String = 100


scala> var a:String="100"
a: String = 100


scala> 1 to 10[操作符对两个对象操作完后还是表达式，其实操作符to底层调用的还是to方法]
res15: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)


scala> 1.to(10)[to原本是操作符，在scala中可以重载成方法名称，调用to方法，像vb的for i=1 to 10]
res9: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)


scala> "Hello".intersect("World")[取两字符串的交集字符，组成按调用者的字符排序，组成字符串]
res11: String = lo


scala> 1.+(1)[+号原本是操作符，在scala中可以重载成方法名称]
res14: Int = 2


scala> var x=10
x: Int = 10


scala> x+=1[scala中只有+=，没有++，操作结束没有返回值，只有调用x才返回操作后的值，相当于惰性迭代]


scala> x
res17: Int = 11


scala> var x:BigInt=1234567890[支持大数类型，因为scala原本就是为大数据使用的]
x: BigInt = 1234567890


scala> x*x*x*x
res18: scala.math.BigInt = 2323057227982592441500937982514410000


scala> import scala.math._[_号相当于通配符*号，该包定义了函数，scala.可省略]
import scala.math._


scala> sqrt(2)
res20: Double = 1.4142135623730951


scala> pow(2,5)
res22: Double = 32.0


scala> Pi
res23: Double = 3.141592653589793


scala> min(3,Pi)
res24: Double = 3.0


scala> "Hello".distinct[java中的distinct方法，对字符串中的字符去重]
res25: String = Helo


scala> "Hello"(0)[根据下标取出字符，像python中用[]操作数组，字符串也视作数组]
res27: Char = H


scala> "Hello".apply(0)[上例中下标引用的底层调用的是apply方法，请求返回字符数组的第0个字符]
res28: Char = H


scala> BigInt(123)[根据下标取出BigInt类中的数字123，是scala下math包中的类]
res29: scala.math.BigInt = 123


scala> BigInt.apply(123)[请求取出BigInt类中的数字123]
res31: scala.math.BigInt = 123




Scala不分基本类型和class，都可以直接访问方法


*.scala -->(通过scalac) *.class --> 
scala解释器执行第一个.scala文件


1.词法：
    1.1.标识符
    1.2.换行字符
    1.3.字面值
    1.4.空白与注释
    1.5.XML模式