Scala语法1

目录

• main方法和def 函数
• 变量，类型转换，字符串分割拼接
• 文件读写和JDBC
• 面向对象编程
• 继承
• case类，最常用的

main方法和def 函数

package scala_01

/**
  * main方法只能放在object中运行
  * object 修饰的类  就相当于静态类 也相当于代码加载到虚拟机中的 “类对象”
  * 类中的方法及属性 相当于自动加上了 static
  * 可以直接通过 “类对象”（类名）直接进行调用
  * 单例模式
  */

object ScalaDemo1 {

  /**
    * Scala中的main方法
    * 在scala中方法不可以用static修饰
    * def 定义一个函数的关键字
    * main 方法名
    * args: Array[String] 参数名:参数类型
    * Unit 返回值类型 相当于java中的void
    * {} 方法体
    */

  def main(args: Array[String]): Unit = {
    println("Hello World!~")

    //  在scala中使用java中的类
    val stu: StudentJava = new StudentJava(1,"zs",18)
    println(stu.id)
    println(stu.name)
    println(stu.getAge)
    println(stu getAge)
    println(stu)

    //  通过类名直接调用方法
    ScalaDemo1.print()
    println(ScalaDemo1.print())

    ScalaDemo1.print2("hahah")
  }

  def print():String={
    println("scala")
    return "0"
  }

  def print2(s:String): Unit ={
    println("scala2")
    println(s)
  }

}

/**
  * 输出结果
  * Hello World!~
  * 1
  * zs
  * 18
  * 18
  * StudentJava{id=1, name='zs', age=18}
  * scala
  * scala
  * 0
  * scala2
  * hahah
  */

变量，类型转换，字符串分割拼接

package scala_01

object ScalaDemo2 {

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

    /**
      * 变量
      * 可以用val 和 var修饰，定义的时候不需要指定类型
      * 用val修饰的变量 不能进行修改 相当于常量
      * 用var修饰的变量 可以进行修改
      * 能使用val就用val
      */

    val i = 100
    var j = 200

    println(i)
    println(j)

    j = 300
    println(j)

    /**
      * 类型推断
      */

    // 自动推断
    val k = 100
    // 手动加上类型 √
    val kk: Int = 200

    println(k + kk)

    // Java中的类型转换
    // Scala中的String就是Java中的String
    val str1: String = "123"
    println(Integer.valueOf(str1))

    // Scala 中的类型转换
    //只要数据符合要求就可以直接to+类型
    // 隐式转换 动态增加方法
    val str2: String = "321"
    println(str2.toInt)

    // 字符串分隔
    val str3: String = "Hello,World"
    println(str3.split(","))

    // 字符串拼接
    val builder: StringBuilder = new StringBuilder()
    builder.append("a")
    builder.append("pple")
    println(builder)

    // scala中更好的字符串拼接
    val str4: String = "bana"
    val str5: String = "na"
    // s"$变量名" ，底层也是StringBuilder
    println(s"$str4,$str5")

    // java中不行
    println("-" * 50)
  }
}

/**
  * 100
  * 200
  * 300
  * 300
  * 123
  * 321
  * [Ljava.lang.String;@45c8e616
  * apple
  * bana,na
  * --------------------------------------------------
  */

文件读写和JDBC

package scala_01

import java.sql.DriverManager

import scala.io.{BufferedSource, Source}

object ScalaDemo3 {

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

    // 文件读写
    val source: BufferedSource = Source.fromFile("scala/data/students.txt")
    val it: Iterator[String] = source.getLines()
    for (elem <- it) {
      println(elem)
    }

    println("-"*50)

    // 第一种简化方式
    // Source.fromFile.getLines.for
    for (elem <- Source.fromFile("scala/data/students.txt")
      .getLines()) {
      println(elem)
    }
    println("-"*50)

    // 第二种简化
    Source.fromFile("scala/data/students.txt")
      .getLines()
      .foreach(println)

    // JDBC
    Class.forName("com.mysql.jdbc.Driver")
    val conn =
      DriverManager.getConnection("jdbc:mysql://master:3306/student?useSSL=false", "root", "123456")

    val statement = conn
      .prepareStatement("select * from student where age=?")

    statement.setString(1,"22")
    val rs = statement.executeQuery()
    while (rs.next()){
      val name = rs.getString("name")
      val age = rs.getString("age")
      println(s"$name,$age")
    }
    conn.close()
  }
}

面向对象编程

/**
  * 面向对象编程
  * 类中可以定义属性、方法、构造函数
  */

/**
  * {}就是scala中类默认的构造函数
  * id: String, name: String, age: Int 构造函数的参数
  */

class Student(id: String, name: String, age: Int) {
  println("默认的构造函数")
  val _id = id
  val _name = name
  val _age = age
  var _clazz: String = _

  // 重载构造方法 需要重新实现this方法
  // 第一行代码必须调用默认的构造方法
  def this(id: String, name: String, age: Int, clazz: String) {
    // 调用默认的构造方法
    this(id, name, age)
    _clazz=clazz
    println("重载构造方法")

  }

  // 重写了父类的toString方法
  override def toString(): String = {
  // 如果变量名以下划线开头 需要用花括号括起来
  // 如果想调用变量的某个方法 也需要用花括号括起来
  // return 可以省略 最后一行代码默认是返回的值
    s"Student(_id=${_id}, _name=${_name}, _age=${_age},_clazz=${_clazz})"
  }

}

object ScalaDemo4 {
  def main(args: Array[String]): Unit = {
    val stu: Student = new Student("1001", "zs", 18)
    println(stu._id)
    println(stu._name)
    println(stu._age)
    println(stu)

    println("-" * 50)

    val stu2: Student = new Student("001", "张三", 21, "文科一班")
    println(stu2._id)
    println(stu2._name)
    println(stu2._clazz)
    println(stu2)
  }

}

/**
  * 默认的构造函数
  * 1001
  * zs
  * 18
  * Student(_id=1001, _name=zs, _age=18,_clazz=null)
  * --------------------------------------------------
  * 默认的构造函数
  * 重载构造方法
  * 001
  * 张三
  * 文科一班
  * Student(_id=001, _name=张三, _age=21,_clazz=文科一班)
  */

继承

object ScalaDemo5 {
  def main(args: Array[String]): Unit = {
    //这里A也可以使用B，A更加体现出多态
    val b:A = new B("002","ls",22)
    println(b)
  }

}

class A(id:String,name:String){
  println("A的构造方法")

  val _id=id
  val _name =name

  override def toString = s"A(_id=${_id}, _name=${_name})"
}

/**
  * 继承还是使用extends关键字
  * 但是在继承就需要调用父类的构造方法
  */
class B(id:String,name:String,age:Int) extends A(id,name){
  println("B中的构造方法")

  val _age=age
  override def toString = s"B(${_id}, ${_name}, ${_age})"
}

/**
A的构造方法
B中的构造方法
B(002, ls, 22)
  */

case类，最常用的

object ScalaCaseDemo6 {
  def main(args: Array[String]): Unit = {
    // 创建样例类的对象时 new关键字可以省略
    val ss:Stu = Stu("0003","ww",21,"男","理科八班")
    println(ss.id)
    println(ss.name)
    println(ss.age)
    println(ss.gender)
    println(ss.clazz)

    // 样例类中的参数 就是该类的属性
    // 默认以val修饰 如果想要重新赋值 则需要手动指定为var
    ss.age=88
    println(ss.age)

  }
}

case class Stu(id:String,name:String,var age:Int,gender:String,clazz:String)