下面的代码包含了基本的scala的语法内容。包括：判断，循环代码片段，方法定义，调用。 虚拟类，继承，接口，case，package，单例模式
package org.exinglo.scala
class learnscala {
}
object test{
val variable1 = "this is my first scala variable"
def func1(): string = "hello world" //不带参数的函数被调用时，可以不加括号
def func2(who : string): string = { return "hello world " + who}
def func3 = (x : int, y : int) => x + y //这是个匿名函数的写法，调用的时候，func3(1,2)
//这里给了y一个默认值，如果用户传过来，那就用用户的
def func4(x: int)(y : int = 1): int = x + y //加脂法的写法，调用时， func4(1)(2)
// * 代表多个参数的意思，比如 printeverychar("c","b", "a"),可以传递多个string
def printeverychar(c : string*) = {
c.foreach(x => println(x))
}
def main(args : array[string]) {
println(variable1)
for(i <- 0 to 10 if i%2 == 0){
println("i is a even number: " + i)
}
for(i <- 0 until 10){
println("")
var (n, r) = (10, 0)
while(n > 0){
n = n - 1
val p = new person //这里可以省略括号
println("information about person:" + p.name + " " + p.age) //如果p.name没有赋值的话，这里会显示为null
class person{ //类默认是public类型的
var name : string = _ //会生成setter和getter方法
val age = 10 //只会生成getter方法
private[this] val gender = "male" //无法在下面的main方法访问gender，这个属性只能在对象内部访问
//生成对象时 val p = new person2("java", 10)
//如果参数声明时不带val或者var，那么这个变量相当于内部变量，比如 class person(name: string) 这里的name就无法在外部被访问到了
class person2(val name : string, val age : int){//括号中的内容属于主构造器，其中的参数会作为类的属性存在
println("this is the person2's constructor")//这里属于默认构造器，生成对象时，会执行这句话
var gender : string = _ //这里要求初始化
//附属构造器必须叫做this，必须首先调用已经存在的子构造器或者其他附属构造器
def this(name : string, age : int, gender : string){
this(name, age)//必须调用默认的构造器，=
this.gender = gender
//成成student对象的时候，会先打印父类构造器的打印语句，然后但因student类的语句
class student(val grade : int, name : string, age : int) extends person2(name, age) {
println("this is the subclass of person, grade is:" + grade)
override def tostring() : string = {""} //覆盖父类的方法，一定要加上override关键字，其实不仅仅是父类的方法，覆盖父类的var val都要加上override
package org.exinglo.abstractandtrait
class abstractandtrait {
//抽象类（abstract class）
//• 类的⼀一个或者多个⽅方法没有没完整的定义, 当然也可以没有任何抽象方法。
// 对于子类覆盖父类的非抽象方法，一定要override关键字
//• 声明抽象⽅方法不需要加abstract关键字,只需要不写⽅方法体
//• ⼦子类重写⽗父类的抽象⽅方法时不需要加override
//• ⽗父类可以声明抽象字段(没有初始值的字段)
//• ⼦子类重写⽗父类的抽象字段时不需要加override
abstract class personx{
def speak
val name:string
val age:int
class student extends personx{
//必须要实现抽象方法，像这种不写等于号的情况，表示返回类型是unit类型
def speak{
println("speak")
val name:string = ""
val age:int = 3
trait logger{
def log(msg:string)
//这里的trait consolelogger可以不实现父类的方法，也可以覆盖父类的方法实现，也可以实现父类的虚方法
trait consolelogger extends logger{
def log(msg:string){
println("save money:" + msg)
//因为是覆盖上级的方法，必须使用override关键字
trait messagelogger extends consolelogger{
override def log(msg:string){
println("save money to account:" + msg)
//如果一个类没有继承其他的类，实现的第一个trait只能用extends，其他的用with关键字
class test extends consolelogger{
def test{
log("hellp")
abstract class account{
def save
class myaccount extends account with consolelogger{
def save{
log("100")
object run extends app{
//这里是一个很好玩的地方，单独给一个对象混入了一个特质trait，并且这个特质与类的定义继承的特质有冲突
//打印出来的是messagelogger中的log方法
val acc = new myaccount with messagelogger
acc.save
class applytest(val msg:string) {
def apply() = msg
println(msg)
object applytest{
//下面是apply方法的最常用的方式
def apply() = new applytest("object calls new")
//object的方法相当于java中的静态方法
def static{
println("i am a static method")
object basic extends app{
//类似于下面，嗲用object的方法
applytest.static
val t = new applytest("new")
println(t())
//据说下面这样可以调用object applytest中的apply方法，但是我的编译器总是报错
//后来发现是object的apply方法一开始声明没有加上小括号造成的，如def apply = xxxx
val tt = applytest()
println(tt())
// applytest()是调用object的apply方法
// val t = new applytest(); t() 调用的是class applytest的apply方法
/*
* package com.xyz{
* //-------------
* package spark
* }
* }
*
* { //这里只在程序块中可见
* import com.yyy
*
* import java.util.{hashmap =>javahashmap} //定义一个别名
* package aa.bb.cc.dd
* class xxx{
* private[dd] def variable = {} //根据private[]中指定的不同，可见范围不同
* */
class packageandcase {
object basict extends app{
val value = 3
val result = value match{
case 1 => "one"
case 2 => "two"
case _ => "some other number"
val result2 = value match{
case i if i == 1 => "one"
case i if i == 2 => "two"
case _ => "other number"
def t(obj : any) = obj match{
case x:int => println("int")
case s:string => println("string")
case _ => println("unkonwn type")
t(2)
}