scala记录（1）scala基础

    /**
     * 可以在变量名后面加上变量类型，不加的话会自己推断类型
     * 另外scala换行的时候可以不加分号，多行代码写在一行要用分号隔开。
     * 如以下声明方式
     * 定义变量和常量
     * 变量 :用 var 定义 ，可修改 
     * 常量 :用 val 定义，不可修改
     * 只有这两种声明方式
     */
    var a = 10
    val b = 10
    var c:Int = 10
    val d:String = "a"

/**
 * 类的声明可以带构造器，直接写在类的名字后面，如Person,构造器需要传入的参数必须带上类型
 * 同样也可以不带，如Son
 * class 是scala中的类,类可以传参，传参就有了默认的构造函数。类中的属性默认就有getter，setter方法。重写构造，第一行要调用默认的构造
 * 当new 一个class时，类中除了方法不执行，其他都执行。同一个包下，class的名称不能相同。
 */
class Son{
  val name = "erzi"
  var age = 19
}
class Person(xname:String,xage:Int){
  val name = xname
  var age = xage
  var gender = ‘m‘
  /**
   * 重写构造,如下，同JAVA，重写构造器方法的第一行需调用原始构造器
   */
  def this(yname:String,yage:Int,ygender:Char){
    this(yname,yage)
    this.gender = ygender 
  }
  def sayName() = {
    println(this.name+"---"+this.age+"---"+this.gender)
  }
}

object LearnClass {
  
  def main(args: Array[String]): Unit = {
/**
 * scala中定义在object中的变量，方法都是静态的,object叫对象，相当于java中的单例对象。object不可以传参,Trait也不可传参。
 * scala中 如果一个class名称和object的名称一致，那么这个class叫做这个object的伴生类，这个object叫做这个class的伴生对象，他们之间可以互相访问私有变量。
 */
    val person = new Person("zhangsan",18)
    person.sayName()
    
    val person1 = new Person("lisi",11,‘f‘)
    person1.sayName()

  }
}

class Person(xname :String,xage :Int){
  var name = Person.name
  val age = xage
  var gender = "m"
  def this(name:String,age:Int,g:String){
    this(name,age)
    gender = g
  }
  
  def sayName() = {
    "my name is "+ name
  }

}

object Person {
  val name = "zhangsanfeng"
  
  def main(args: Array[String]): Unit = {
    val person = new Person("wagnwu",10,"f")
    println(person.age);
    println(person.sayName())
    println(person.gender)
  }
}

  /**
     * if else 
     */
    val age =18 
    if (age < 18 ){
        println("no allow")
    }else if (18<=age&&age<=20){
        println("allow with other")
    }else{
        println("allow self")
    }

 /**
     * to和until
     * 例：
     * 1 to 10 返回1到10的Range数组，包含10
     * 1 until 10 返回1到10 Range数组 ，不包含10
     */
    
    println(1 to 10 )//打印 1,2,3,4,5,6,7,8,9,10
    println(1.to(10))//与上面等价，打印 1,10
    
    println(1 to (10,2))//步长为2，从1开始打印 ，1,9
    println(1.to(10,2)) 
    
    println(1 until 10 ) //不包含最后一个数，打印 1,9
    println(1.until(10))//与上面等价
    
println(1 until (10,3 ))//步长为2，从1开始打印，打印1,7

 /**
     * for 循环
     * 
     */
    for( i <- 1 to 10 ){
      println(i)
    }

    //可以分号隔开，写入多个list赋值的变量，构成多层for循环
    //scala中 不能写count++ count-- 只能写count+
    var count = 0;
    for(i <- 1 to 10; j <- 1 until 10){
      println("i="+ i +",j="+j)
      count += 1
    }
    println(count);
    
    //例子： 打印小九九
    for(i <- 1 until 10 ;j <- 1 until 10){
      if(i>=j){
          print(i +" * " + j + " = "+ i*j+"    ")
      }
      if(i==j ){
        println()
      }
    }

  //可以在for循环中加入条件判断
    for(i<- 1 to 10 ;if (i%2) == 0 ;if (i == 4) ){
      println(i)
}

    //将for中的符合条件的元素通过yield关键字返回成一个集合
    val list = for(i <- 1 to 10  ; if(i > 5 )) yield i 
    for( w <- list ){
      println(w)
}

   /**
     * while 循环
     */
    var index = 0 
    while(index < 100 ){
        println("第"+index+"次while 循环")
      index += 1 
    }
    index = 0 
    do{
        index +=1 
        println("第"+index+"次do while 循环")
}while(index <100 )