Scala基础02

一、重温

1、部署Scala

（1）解压

（2）环境变量

（3）JDK1.8以上

2、scalac/scala

3、常量VS变量

4、数据类型

asInstanceOf

isInstanceOf

二、Scala编程

1、IDEA创建工程

2、IDEA安装scala插件

（1）

（2）

（3）

（4）改为2.11.8

（5）抽取出来单独的version的作用

（6）

（7）

三、函数/方法

1、格式

def 函数名（x:Int,y:String,......) : 返回值类型 =     {

    xxxxxx    //最后一行代码默认是整个函数的返回值

}

2、无返回值

IDEA：def sayHello() {按回车补全}

PS：当调用的h函数没有参数时，还可以省略（）【有一种函数除外】

3、条件函数

val x = 100

if(x > 0){

    true

}else{

    false

}

也可以：

if (x > 0) true else false

4、to

[]:

5、until

[）:

6、Range

[)：

until = Range

看until的源码

1.until(10) = 1 until 10

1.to(10) = 1 to 10

7、Range(1,10,step)

step不等于0

8、for

for ( i <- 0 to 10 until i%2 ==0){

    println(i)

}

也可以嵌套if使用

9、遍历foreach(数组的时候详细讲解）

---

Array("若泽","老J","hadoop","spark").foreach(sb => println(sb))

---

四、默认参数

---

    def loadSparkConf(fileName:String = "spark-default.conf"): Unit ={
          println(fileName)
}
      loadSparkConf()
      loadSparkConf("spark-ruoze.conf")
  }

---

这种函数带有默认参数，如果不传值将会输出默认参数

五、命名参数（了解即可）

根据变量名传参，不用记住，知道即可。

六、可变参数

1、例子

相加的函数，为防止可能不断添加新变量，所以写成这种形式是最为可扩展的。

---

def sum(nums:Int*) = {

        var result = 0

        for (num <- nums){    //增强for循环

            result += num

    }

            result

}

            println(sum(1.to(10):_*))    //    _*将数组、列表转为可变参数

---

:_*可以将列表、数组通通转为可变参数，从而可以进行数学运算。

七、面向对象编程

1、属性、方法

---

package com.ruozedata.day02
/*
类、属性
 */
object simpleClassApp {
  def main(args: Array[String]): Unit = {
    val people = new People()
    people.name = "郑鸿彬"
    println(people.name + "age:" +people.age)
    println(people.eat())
  }
}
//定义类
class People{
  //定义属性
  var name:String = _  //_表示占位符，String类型表示null,Int类型表示0以此类推
  val age = 10
  //定义方法
  def eat(): String={
    name + "吃香蕉"
  }
}

---

2、私有属性

（1）正常定义一个属性

可以直接访问到

（2）加上private

无法访问。

（3）通过定义方法来实现外部访问私有属性

3、pom.xml

（1）添加spark-core的依赖

（2）spark的入口类

SparkContext

（3）研究此类

里面还有很多私有的属性和方法只有在这个包里才可以使用

4、构造函数

（1）创建一个构造函数

（2）定义一个类（构造函数）

（3）创建一个方法不调用

结果仍是

（4）总结

---

package com.ruozedata.day02
/*
   构造函数
 */
object ConstructApp {

  def main(args: Array[String]): Unit = {
    val girl = new Girl("cindy",18,"1366000000","深圳市南山区" )
    println(girl.name + ":" + girl.age + ","+ girl.city + "," + girl.phone + "," + girl.address )
  }
}

//定义一个构造函数
class Girl(val name: String,val age:Int){     //name、age可以当作属性使用，所以将这种类的创建方式叫做构造函数

  println("girl enter")
  def hate: Unit ={
    println(name + "hate 子栋")
  }
  var phone:String =""
  var city:String = "渔村"
  //附属构造函数（java里面的重载）
  //第一行必须调用主构造器或者其他的附属构造器
  def this(name:String,age:Int,phone:String){
    this(name,age)
    this.phone = phone
  }
  var address = ""
  def this(name: String,age:Int,phone:String,address:String){
    this(name,age,phone)
    this.address = address
  }
  println("girl leave")
}

---

1）构造函数与类相似，但是它可以在定义的时候将传参作为属性，可供外部调用

2）可以在构造函数里面定义属性

3）可以在附属函数里面重写扩展该主构造函数

5、面向对象三大特性

（1）继承

1）创建一个继承Girl的类，Cindy

---

lass Cindy(name:String,age:Int,major:String) extends Girl(name:String,age:Int){   //Cindy继承了Girl，拥有name和age两大属性
  println("Cindy enter")


  println("Cindy leave")

---

2）new的时候发现major无法显示，说明major是在Girl里面没有的，需要在Cindy类里定义一下

3）

创建子对象的时候，会先调用父类的构造方法

4）override

如果你想重写父类中已有的属性或者方法，需要在属性或者方法前，添加override修饰符

（2）抽象类

类中有一个或者多个方法/属性没有实现：只有定义，不实现

是不能直接使用的，必须要通过实现了该抽象类的属性和方法来使用

1）创建抽象类

---

package com.ruozedata.day02
/*
     抽象类
 */
object AbstractApp {

}


abstract class Animal{
//属性或者方法只有定义
  var name:String
  var age:Int

  def speak
}

class Dog extends Animal

---

2）子类要不定义为抽象类不实现，要不就得实现父类的方法

3）实现父类的方法

Alt+Enter

4）抽象类的子类重写父类中的方法或者属性不需要使用override