scala学习day01

1.scala中的main函数

package com.shujia.scala

object Demo2Helloworld {

  /**
    * def ： 定义函数的关键字
    * main： 函数名
    * args：参数名
    * Array[String]： 参数类型
    * Unit; 相当于void
    *
    * main需要放在object
    *
    * object中所有的方法可以直接调用
    */

  def main(args: Array[String]): Unit = {
    System.out.println("java")
    println("helloWorld")

    //在scala中使用java类
    //scala自动通过等号右边推测出等号左边类型
    val student = new StudentJava("张三", 23)
    
    //写上类型
    val student1: StudentJava = new StudentJava("张三", 23)

    println(student)

  }
}

2.scala的变量

package com.shujia.scala

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

    /**
      * 变量
      * 类型推断，scala会自动推断变量类型
      *
      *
      * val ；常量，不可变 （不能再指向其他的对象） 相当于java中 final
      * var ：变量
      *
      */

    val i: Int = 10

    var j = 100

    //修改变量的值
    j = 20
    println(j)


    //多态，父类引用指向子类对象
    val a: Any = 100


    val l: Long = 1000L


    //scala中的字符串用的就是java中的字符串
    val s: String = "10"


    //java的方式进行类型转换
    println(Integer.parseInt(s))


    //scala进行类型转换
    // String类中本来没有toInt方法，scala可以动态增加方法（隐式转换）
    println(s.toInt)
    println(s.toDouble)
    println(s.toLong)


    val b = 100
    println(b.toDouble)

    /**
      * scala基础类型之间都可以通过to 的方式进行类型转换
      *
      */


    /**
      * scala中字符串的拼接
      *
      */

    val s1 = "java"
    val s2 = "scala"


    //内部使用的是java的Stringbuilder
    val s3 = s"$s1\t$s2"
    println(s3)


    //java中字符串拼接
    val builder = new StringBuilder

    builder.append(s1)
    builder.append("\t")
    builder.append(s2)

    println(builder.toString())


  }
}

3.java和scala读取文件的对比

package com.shujia.scala

import java.io.{BufferedReader, FileReader}

import scala.io.{BufferedSource, Source}

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


    /**
      * 读写文件
      *
      */

    //java中读取文件的方式
    val fileReader: FileReader = new FileReader("scala/data/students.txt")

    val bufferedReader: BufferedReader = new BufferedReader(fileReader)

    //读第一行
    var line: String = bufferedReader.readLine()
    while (line != null) {
      println(line)

      //读下一行
      line = bufferedReader.readLine()
    }


    //scala 中读取文件的方式
    val source: BufferedSource = Source.fromFile("scala/data/students.txt", enc = "utf-8")

    //获取所有行
    //Iterator :迭代器，只能迭代一次
    val lines: Iterator[String] = source.getLines()

    //增强for循环 ，  line 的类型自动推断
    for (line: String <- lines) {
      println(line)
    }

    println("=" * 100)

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

  }
}

4.scala中的类class

package com.shujia.scala

object DemoClass {
  def main(args: Array[String]): Unit = {
    val student:Student = new Student("001","张三",23,"文科六班")
    println(student)
  }
}

//(id:String,name:String)默认构造函数的参数
class Student(id:String,name:String,age:Int){
  println("默认构造函数")

  //私有化
  private val _id:String = id
  var _name:String = name
  val _age:Int = age

  //_ 占位符
  var _clazz:String = _


  //重置构造函数，第一行必须显示调用默认构造函数
  def this(id:String,name:String,age:Int,clazz:String){
    this(id,name,age)
    println("重置构造函数")

    _clazz=clazz

  }
  //重写父类的方法
  override def toString=s"Student(${_id},${_name},${_age},${_clazz})"
}

5.scala中的继承

package com.shujia.scala

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

    val student = new Student1("张三", 23, "文科一班")

    println(student)


    //多态
    val lisi: Person = new Student1("李四", 23, "文科一班")

    println(lisi)

  }
}

class Person(name: String, age: Int) {

  println("Person类默认构造函数")
  var _name: String = name
  var _age: Int = age

  override def toString = s"Person(${_name}, ${_age})"
}


/**
  * 继承
  * 再继承的时候默认需要调用父类的构造函数
  *
  */

class Student1(name: String, age: Int, clazz: String) extends Person(name, age) {
  println("Student默认构造函数")
  var _clazz: String = clazz

  //重写父类的方法
  override def toString = s"Student1(${_name}\t${_age}\t${_clazz})"
}