Scala入门学习笔记

有java基础感觉scala应该是比较简单的，很快就能上手，scala多了很多花里胡哨的东西，没有java那么朴实无华。
一、Hello World

/**
 * Copyright..@ lbhbinhao@163.com
 * Author:liubinhao
 * Date:2020/12/16
 * +++++ ______                           ______            ______
 * ++++/     /|                         /     /|           /     /|
 * ++/_____/  |                       /_____/  |         /_____/  |
 * |     |   |                      |     |   |        |     |   |
 * |     |   |                      |     |   |________|     |   |
 * |     |   |                      |     |  /         |     |   |
 * |     |   |                      |     |/___________|     |   |
 * |     |   |___________________   |     |___________ |     |   |
 * |     |  /                  / |  |     |   |        |     |   |
 * |     |/ _______________/  /     |     |  /         |     |  /
 * |_________________________|/b    |_____|/           |_____|/
 **/
object HelloProgram1{
  def main(args: Array[String]): Unit = {
    print("Hello World!")
  }
}

二、scala中的数据类型，val 常量， var 变量。
val定义的引用不可以在定义后对其值进行修改。

object DatatypeProgram2{
  def main(args: Array[String]): Unit = {
    // val can't be changed
    val var1 = 1;
    var var2 = 2;
    var2 = 3;
  }
}

三、scala中的控制流。if，else 用法和java几乎一毛一样。

object ConditionalProgram3{
  def gradeRank(x:Int): Unit ={
    if (x<60){
      print("不及格")
    }
    else {
      if(x>=90){
        print("优秀")
      }
      else{
        if (x>=80){
          print("良好")
        }
        else{
          print("及格")
        }
      }
    }
  }
  def main(args: Array[String]): Unit = {
    gradeRank(89)
  }
}

四、scala 中的match用饭，scala中没有swith，提供了更加强大的match用法，其实基本差不多，scala中的match中的功能更多。

object PatternMatchProgram4 {
  def numMatch(x: Int): Unit = {
    x match {
      case 1 => println("one")
      case 2 => println("two")
      case 3 => println("three")
      case _ => println("nothing")
    }
  }

  def main(args: Array[String]): Unit = {
    numMatch(2)
  }

}

五、scala中的类。
scala中的类和java中的类是一模一样的关键字，定义的形式有些区别。可以在类名定义默认构造函数。

//class HeroNode2(hNO:Int,hName:String,hNickname:String){
//
//  val no = hNO
//  var name = hName
//  var nickname = hNickname
//  var next: HeroNode2 =null //指向后一个节点
//  var pre:HeroNode2 = null //指向前一个结点
//
//}

class ListNode(value:Int, next:ListNode){
  var value1: Int = value
  var next1:ListNode = next
}
object LoopProgram5{

  def main(args: Array[String]): Unit = {
    var lt = new ListNode(2,new ListNode(3,new ListNode(4,null)))
    println(lt.next1)
    while (lt!=null){
      println(lt.value1)
      lt = lt.next1
    }

    //break the loop
    for (a<- -1 to 10){
      if(a == 5){
        return
      }
    }
  }
}

六、scala中的函数
使用def关键字定义函数，scala提供返回值推导，所以不需要写返回值。

object FunctionProgram6{
  //普通函数
  def add(a:Int,b:Int): Unit ={
    a+b
  }

  //5!
  def fun(a:Int): Int ={
    if (a == 1)
      1
    else {
      fun(a - 1)*a
    }
  }

  def main(args: Array[String]): Unit = {


    val i = fun(3)
    println(i)
  }
}

七、高阶函数
一个函数的传入参数是另一个函数，则改函数是另一个函数的高阶函数。
代码示例：

object HiOrderFunctionProgram7{

  def add1(a:Int, b:Int) = {
    a+
      b
  }

  def highFun(a:Int,f:Int=>Int): Int ={
    a+f(a)
  }

  def main(args: Array[String]): Unit = {
    val i = add1(1, 3)
    println(i)
  }
}

八、scala继承
使用extend关键字，和java一样

case class Program8(name:String)

//program8 class
//extends
class Employee{
  var salary:Float = 10000
  def fun(): Unit ={

  }
}

class Programmer extends Employee{
  var bonus:Int = 5000

  override def fun(): Unit = super.fun()
  println("Salary = "+salary)
  println("Bonus = "+bonus)
}

object MainObject{
  def main(args:Array[String]){
    new Programmer()
  }
}

九、面向对象。
scala是一门完全面向对象的编程语言，面向对象是一种编程思想，就是用代码来模拟我们现实世界的一种编程方法。

//oop
class Vehicle{
  val speed:Int = 60

}
class Bike extends Vehicle{
  override val speed:Int = 100
  def show(){
    println(speed)
  }
}
object MainObject2{
  def main(args:Array[String]){
    var b = new Bike()
    b.show()
  }
}

trait PrintAble{
  def print()
}

十、scala抽象类
scala中的abstract关键字和java中完全一样。

//如果继承有抽象类需要放在第一个

abstract class AbsClass{

}
class Print extends AbsClass with PrintAble {
  override def print(): Unit = ???
}

object ArrayProgram10{
  def main(args: Array[String]): Unit = {
    val ints = Array(1, 2, 3, 4, 5)
    for (item<- ints){
      println(item)
    }
    val str = new String("hello")
    val str1 = new String("hello")
    println(str == str1)
  }
}

总结：scala写着很简单，看着比java更难理解，最好还是写类型，虽然有类型推导，很多个人感觉更像是一些语法糖的功能，不过是真香。