初识scala(上)

scala中HelloWorld样例

/**
  * object： 是scala中的单例对象，object的方法可以直接调用
  *
  */
object Demo1Helloworld {

  /**
    * main方法需要放在object中才能运行
    *
    * def: 定义方法的关键字
    * main： 方法名
    * args： 方法参数名
    * Array[String]： 参数类型 （String类型的数组），[] 在scala代表泛型
    * Unit： 没有返回值，相当于java中的void
    * {}  中是代码体
    */
  def main(args: Array[String]): Unit = {
    //java的方式
    System.out.println("java")
    //scala的方式，  底层和java是完全一样的，只是将代码简化了
    println("scala")
  }
}

scala与Java的区别

变量

val ：不可变的变量— 常量
var : 可变的变量 — 变量
如果后面不会对变量进行修改使用val
scala 变量的类型可以自动推断，根据等号右边的值，自动推断变量的类型
也可以显示指定变量的类型

方法（函数）

java 中只能在类中定义方法
scala 可以在任何位置定义方法

函数的简写

1、return可以省略，最后一行会作为返回值
2、如果函数只有一行代码，{}可以省略
3、返回值类型可以自动推断， 根据返回值自动推断返回值类型
4、如果参数列表为空，()可以省略

函数参数的默认值

def add(i: Int = 100, j: Int): Int = {
      i * j
    }
    
    //使用参数的名传值
    val i1: Int = add(j = 100)

    println(i1)//10000

可变参数

def test(i: Int*): Unit = {
      for (a <- i) {
        println(a)
      }
    }

    test(1, 2, 3, 4, 6, 7)

运行结果

1
2
3
4
6
7

Process finished with exit code 0

循环判断

//增强for循环
    for (i <- array) {
      println(i)
    }

    println("=" * 100)


    //通过下表遍历
    var i = 0
    while (i < array.length) {
      //通过下标获取元素
      val j = array(i)
      println(j)

      //递增下标
      i += 1
    }

    println("=" * 100)
    //scala中独有的方式，foreach函数
    array.foreach(println)

if

比较简单，和Java的语法一样

    val age = 19

    if (age >= 18) {
      println("已经成年")
    } else if (age < 18 & age > 0) {
      println("未成年")
    } else {
      println("其它")
    }

IO流

//底层还是java的io流
    val bufferedSource: BufferedSource = Source.fromFile("data/students.txt")

    //读取所有行,得到一个迭代器
    val lines: Iterator[String] = bufferedSource.getLines()

    for (line <- lines) {
      println(line)
    }

Exception（异常）

object Demo7Exactpion {
  def main(args: Array[String]): Unit = {
    try {
      //val i: Int = 100 / 0
      //抛出异常
      throw new RuntimeException("运行时异常")
    } catch {
      //匹配异常类型
      case e: ArithmeticException =>
        println("除0异常")
        //打印异常的堆栈信息
        e.printStackTrace()
      case e: RuntimeException =>
        println("运行时异常")
        e.printStackTrace()
    } finally {
      println("都会执行")
    }
    println("代码结束")
  }
}

JDBC

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


    //1、加载驱动
    Class.forName("com.mysql.jdbc.Driver")

    //2、建立链接
    val con: Connection = DriverManager.getConnection("jdbc:mysql://192.168.200.201:3306/student", "root", "123456")

    //3、写sql查数据
    val stat: PreparedStatement = con.prepareStatement("select * from students")

    //4、执行查询
    val resultSet: ResultSet = stat.executeQuery()

    //5、解析数据
    while (resultSet.next()) {
      //通过列名取数据
      val id: Long = resultSet.getLong("id")
      val name: String = resultSet.getString("name")
      val age: Long = resultSet.getLong("age")
      val gender: String = resultSet.getString("gender")
      val clazz: String = resultSet.getString("clazz")

      println(id + "\t" + name + "\t" + age + "\t" + gender + "\t" + clazz)
    }
    //关闭链接
    stat.close()
    con.close()
  }
}

读取Json

object Demo9Json {
  def main(args: Array[String]): Unit = {
    val str = "{\"id\":\"001\",\"name\":\"张三\",\"item\":[1,2,3,4]}"

    //解析json数据
    val nObject: JSONObject = JSON.parseObject(str)

    //使用key获取value
    //需要明确类型
    val id: String = nObject.getString("id")

    val name: String = nObject.getString("name")

    val item: JSONArray = nObject.getJSONArray("item")
    println(id)
    println(name)
    println(item)


  }
}

class(类)

可以在类中定义方法，属性，构造函数，可以创建类的对象
在scala的类中有一默认的构造函数

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

    //创建类的对象，调用类的构造函数
    val student = new Student("001", "张三")
    //调用对象的方法
    student.print()

    val student1 = new Student("002", "李四", 24)

    println(student1)


  }
}

class Student(id: String, name: String) {
  println("默认构造函数")
  //定义属性, 定义及赋值
  var _id: String = id
  var _name: String = name
  //定义一个未赋值的变量，  下划线的作用是占位符
  var _age: Int = _
  /**
    * 重载构造函数
    * 在重载构造函数的第一行需要先调用默认的构造函数
    *
    */
  def this(id: String, name: String, age: Int) {
    //调用默认构造函数
    this(id, name)

    //给成员变量赋值
    this._age = age
  }


  //在类中定义普通的方法
  def print(): Unit = {
    println("student")
  }


  //重写父类的方法
  override def toString: String = {
    s"Student(" + _id + "\t" + _name + "\t" + _age + ")"
  }
}

case class (样例类)

样例类：帮助我们简化写代码的类

scala在编译的过程中会自动的给样例类增加额外的属性，方法和构造函数

样例类属性默认不支持修改，需要增加var才能修改

样例类可以不通过new创建对象

case class User(id: String, var name: String, age: Int = 20)

调用

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

    //创建类的对象
    val user = new User("001", "张三")
    println(user.id)
    println(user)
    //修改属性的值
    user.name = "李四"
    println(user)
    /**
      * 样例类可以不通过new创建对象
      *
      */
    val user2 = User("003", "王五")
    println(user2)
  }
}

Apply方法

apply:是scala中一个特征的方法，可以直接使用object名调用

object Demo12Apply {
  def main(args: Array[String]): Unit = {
    Test.print()
    Test.apply()
    //调用对象的apply方法
    Test()
    //不通过new创建对象
    val test: Test = Test()
  }
}

/**
  * object： 是一个特殊的类（类和对象绑定了，只一个一个对象）
  * object中的方法可以直接调用，不需要创建对象
  *
  */
object Test {
  def print(): Unit = {
    println("test")
  }
  /**
    * apply:是scala中一个特征的方法，可以直接使用object名调用
    *
    */
  /*  def apply(): Unit = {
      println("apply")
    }*/

  def apply(): Test = new Test()
}

class Test {

}

字符串拼接

    val s = "java"
    val i = 1000
    val d = 3.14
    //底层还是StringBuilder
    val str = s"$s\t${i}java\t$d"
    println(str)

运行结果

java	1000,scala,	3.14