scala（1）

1定义名称：

scala中只有两种方式定义名称：val，var
 （1） val name:String="武松"
    val修饰的是值，不可改变，String 类型可省略

 （2） var money:Int=10000
    var修饰的是变量，可重新赋值，Int类型可省略
    
      money=100  //给money重新赋值

2.数据类型转换：

val a=10.asInstanceOf[Double]  	将Int类型转换成Double类型
	
	println(a)
   Double=10.0

val b=10.isInstanceOf[Double]  	判断 b是否是Double类型

println(b)
   Boolean=false

3.函数,方法

Scala函数定义：
	def max（x:int,y:int）:int（这里的int表示返回值类型，可省略）={
        if(x>y){
        x （函数体最后一行表示返回值）
	}else{
        y （函数体最后一行表示返回值）
	}
	}

def:定义函数关键字

max：函数的名称

(x:int,y:int)：函数的入参（可能有，可能没有）

def sum(x:Int,y:Int): Unit ={
      printly（"你好"）
    }
Unit表示没有返回值。

4.函数的调用

package com.ruozedata.scala

object expertion {
  def main(args: Array[String]): Unit = {
    sayHello()                   //调用方法 
    另一种调用方法：sayHello       //不加括号，适合于没有入参的方法
     }

(方法)
  def sayHello(): Unit ={
    print("今天你好")
  }

}

5.循环表达式：

1 to 10==1.to(10)  	 	调用的是Range.Inclusive【1，2......10】

Range(1,10) 			从1取到9，【左闭又开）
Range（1，10，2）		  2表示步长，一次长几个数

1 until 10 和 Range是一样的

列如：

for(i<- 1.to(10) if i%2==0){
      print(i)
  }
  
结果：2 4 6 8 10

6.面向对象

object ClassDemo {
  def main(args: Array[String]): Unit = {
     val people=new people			//引用people类，创建对象
    people.name="二傻"			   //给people中的name属性赋值
     println(people.sleep())		//调用people中sleep方法，并打印返回值
     people.py("小强")			  //调用 people中与py方法，并传入值。
  }

}


类：
class people{
  var name=""      //属性
  val city=""

   def sleep()={       //方法 带有返回值
      name+"ZZZZZ..."
  }

  def py(pyname:String): Unit ={              //方法  没有返回值
    println(name+"正在和"+pyname+"打游戏")
  }

}

7.占位符

var name：String=_  (表示占位符)  注意：必须要加数据类型，否则不知道自己是什么数据类型

8.编写SparkConf

package com.ruozedata.scala


import java.util.concurrent.{ConcurrentHashMap, ConcurrentMap}

import com.sun.javafx.tk.quantum.MasterTimer

object SparkConfApp {
  def main(args: Array[String]): Unit = {
  
    var sparkConf=new SparkConf
    sparkConf.setappname("SparkConfApp").setMaster("yarn")

    //也可以这么设置
   // sparkConf.set("spark.master","yarn")  //如果 方法加了 paivate 就调用不了了，只能内部类自己调用，
    // sparkConf.set("spark.app.name","SparkConfApp")
    sparkConf.print()
  }


}

class SparkConf{

   var master:String=_
   var appname:String=_
  
  //底层是Map
  var setting=new ConcurrentHashMap[String,String]()

  def setMaster(master:String):SparkConf ={
  
    // this.master=master
    set("spark.master",master)
    this
  }

  def setappname(name:String):SparkConf={
  
    //this.appname=name
    set("spark.app.name",name)
    this
  }


  private[this]def set(key:String,value:String):SparkConf={  //private 表示私有的
    setting.put(key,value)  //将 key，value 传到 ConcurrentHashMap中
    						//每调用一次set方法，就会上传一次
    this
  }

  def print():Unit={
  
    val appName=setting.get("spark.app.name")
    val master=setting.get("spark.master")
    println(appName+"======="+master)

  }
}

9.构造方法

object gouzao {
  def main(args: Array[String]): Unit = {
      
      var person=new Person("小强","北京")
    println(person.name+"======"+person.city)
  }

 // 跟在class后面的是 主构造器（构造方法） 
  class Person(val name:String,val city:String){
   
    println("Person 进来了")

     println("Person 出去了")
  }

}

结果：
Person 进来了
Person 出去了
小强======北京

10.附属构造器

package com.ruozedata.scala

object gouzao {
  def main(args: Array[String]): Unit = {
      var person=new Person("小强","北京",18)
    println(person.name+"======"+person.city+"======"+person.age)
  }

//跟在class后面的是 主构造器（构造方法）
  class Person(val name:String,val city:String){

    println("Person 进来了")
    var age:Int=_
  //附属构造器，
    def this(name:String,city:String,age:Int){
      //第一行必须要调用著构造器或者其它附属构造器
      this(name,city)
      this.age=age
    }
   println("Person 出去了")
  }

}


结果：
Person 进来了
Person 出去了
小强======北京======18