一天时间搞定scala[仅针对spark开发]_学习scala需要多长时间-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_41819729/article/details/107916346

一天时间搞定scala[仅针对spark开发]

好久没写博客了，天气一热身上开始出现各种小毛病，苦不堪言，也希望广大程序员同胞能珍重身体，坚持锻炼。

想学spark,但是又觉得又要学一门scala很繁琐？本着先学会用，再学会原理的心态，我花了一周时间整理了这篇博客，很干但是很高效（1天时间基本可以学完所有spark开发所需的scala知识，前提是掌握了java），希望对大家能够有些许参考价值。

文章目录

一天时间搞定scala[仅针对spark开发]

scala是基于JVM的语言

在这里插入图片描述

六大特性

1. 与java无缝整合

2. 类型推断

3. 支持分布式和并发Actor

4. Trait特质特性

5. 模式匹配match

6. 高阶函数

类和对象

class

类中声明的属性会自动生成对应的setter/getter方法(val–>getter,var–>getter/setter)

object CatDemo {
     
  def main(args: Array[String]): Unit = {
     
    val cat = new Cat()
    cat.name="tom" //在底层中是cat.name_$eq("tom")，在Java中是cat.setName("tom")
    cat.age = 10
    cat.color = "white"
    println(cat)
  }

  class Cat {
     
    //定义猫类的属性
    // 当声明了var name:String时，在底层对应private name
    // 同时会生成两个public方法--》类似setter/getter，public name_$eq()=>setter
    var name : String = "" //给初始值
    var age:Int = _ //下划线表示默认值
    var color:String = _

    override def toString: String = s"name:$name,age:$name,color:$name"
  }

}

当new类时，类中除了方法不执行其他都执行
class可以传参，传参就覆盖了默认的无参构造

重写构造时，第一行要先调用默认的构造this(…)

class Person(inName: String, inAge: Int) {
     
  val age: Int = inAge
  val name: String = inName
  var height: Int = _

  //辅助构造
  def this(height: Int) {
     
    this("sda", 123)
    this.height = height
  }
}

extends BaseA with BaseB

class Person(inName: String, inAge: Int) extends Human with Animal {
     ...}

object(伴生对象)

package com.chanzany.scala.oop

/**
 * Scala:
 * 1. Scala object 相当于java中的单例(常用于工具类)，在Object中定义的函数方法等全是静态的，Object默认不可以传参，
 * 如果非要传参，可以在该Object中定义apply方法
 * 2. Scala中定义变量用var.定义常量用val,变量可变，常量不可变
 * 3. Scala每行后面都会有分号自动推断机制，不用显式写出";"
 * 4. Scala类中可以传参(构造器)，传参一定要指定类型，类中的属性默认有"getter"和"setter"方法
 * 5. 类中重写构造需要定义this构造方法,而且构造中第一行必须先调用默认构造
 * 6. scala中当new class时，类中除了方法(除了构造)，其他都执行
 * 7. 在同一个scala文件中，class名称和object名称一样时，该类(class)和该对象(object)互为伴生关系，
 * 它们之间可以相互访问所有权限的类属性和方法，类似于C++中的友元
 */


class Person2(inName: String, inAge: Int) {
   
  val name: String = inName
  private val age: Int = inAge
  //  var sex: Char = _ //_表示对应数据类型的默认值
  var sex: Char = 'M'

  def this(inName: String, inAge: Int, inSex: Char) {
   
    this(inName, inAge)
    this.sex = inSex
  }

  //  println("******Person Class in the __init__ function********")

  def sayHello(): Unit = {
   
    println(s"hello my name is $name")
  }

  //  println("===========Person Class in the __init__ function===========")
}

object Lession_ClassAndObj {
   
  //  println("################Person Class in the __init__ function################") //静态先加载
  def main(args: Array[String]): Unit = {
   
    //        val person = new Person("zhangsna", 20)
    //    person.sayHello()
    //    Lession_ClassAndObj.sayHello() // 无需创建Object对象，相当于工具类，全是静态方法

    //    val p = new Person("lisi", 20, 'F')
    //    val p2 = new Person("hha", 10)
    //    println(p.sex)
    //    println(p2.sex)
    //      person.age //当age并定义为Private时，无法从类外方法，但是可以被伴生object访问
    //    Lession_ClassAndObj(2)
    Lession_ClassAndObj(2, "Advised Using in Future")
  }

  //Object不支持构造传参，但是为了使得某些场景可以对object进行传参，所以需要重写object的apply方法来接受参数并做相关逻辑处理
  def apply(versionID: Int): Unit = {
   
    println(s"Version:$versionID")
  }

  def apply(versionID: Int, string: String): Unit = {
   
    println(s"Version:$versionID")
    println(string)
  }

  def sayHello(): Unit = {
   
    println("hello")
  }
}

/**
 * 伴生object与其对应的伴生类同名，二者的关系类似于C++中的友元类
 */
object Person2 {
   
  def main(args: Array[String]): Unit = {
   
    val person = new Person("chanzany", 20)
    println(person.age)
  }
}

object相当于Java中的单例/工具类，定义的属性和方法都是静态的
object不可以传参，除非使用apply()方法接收调用该object时传入的参数
apply方法
- （1）通过伴生对象的apply方法，实现不使用new方法创建对象。
- （2）如果想让主构造器变成私有的，可以在()之前加上private。
- （3）apply方法可以重载。
- （4）Scala中obj(arg)的语句实际是在调用该对象的apply方法，即obj.apply(arg)。用以同一面向对象编程和函数式编程的风格。

Trait

package com.chanzany.scala.LessionTrait

/**
 * Trait类似于JAVA中接口与抽象类的整合
 * 一个类继承多个trait时，第一个关键字使用extends,之后使用with
 */

trait Read {
   
  def read(name: String) = {
   
    println(s"$name is reading")
  }
}

trait Listen {
   
  def listen(name: String): Unit = {
   
    println(s"$name is listening")
  }
}

class Human() extends Read with Listen {
   
}

object TraitDemo {
   

  def main(args: Array[String]): Unit = {
   
    val h = new Human()
    h.read("zhangsan")
    h.listen("zhangsan")
    
  }
}

相当于java中的接口和抽象类的结合。
可以在Trait中定义方法(实现/不实现)，变量，常量
Trait不可以传参
类继承Trait第一个关键字使用extends,之后使用with
- class Person(...)extends Trait1 with Trait2{...}

样例类case class

case class Person1 (name:_String_,age:Int)  
object Lesson_CaseClass {
     
def main(args: Array[_String_]): Unit = {
     
	val p1 = new Person1("zhangsan",10)  
	val p2 = Person1("lisi",20)  
	val p3 = Person1("wangwu",30)  
	val  list = List(p1,p2,p3)  
	list.foreach {
    x => {
     
		x match {
     
		case Person1("zhangsan",10) => println("zhangsan")  
		case Person1**("lisi",20) => println("lisi")  
		case _ => println("no match")  
		}  
   	   } 
    }  
 }  
}

样例类中参数，默认有getter/setter方法，对外可见
样例类默认实现了toString,equals，copy和hashCode等方法。
样例类可以new, 也可以不用new

基本语法

for…

1 to 10
1 until 10
for(i <- 1 to 10)
for(elem<-collection)

while…do…while

i+=1,i=i+1

if…else…

与java相同

变量

var修饰的对象引用可以改变，val修饰的则不可改变

数据类型

整型：Byte,short,Int,Long
浮点型：Float,Double
字符类型Char,字符串String
布尔类型Boolean
特殊类型
- Unit
  表示无值，和其他语言中void等同。用作不返回任何结果的方法的结果类型。Unit只有一个实例值，写成()。
- Null
  null , Null 类型只有一个实例值null
- Nothing
  Nothing类型在Scala的类层级的最低端；它是任何其他类型的子类型。
  当一个函数，我们确定没有正常的返回值&