scala_day01_安装_基础_IO_函数_递归_异常_方法_样例类_伴生对象

2022年7月9日 08:13 • Java

scala学习

先看如下：

scala_day01_安装_基础_IO_函数_递归_异常_方法_样例类_伴生对象

scala 安装

直接在idea中下载，然后配置 pom.xml 文件

scala_day01_安装_基础_IO_函数_递归_异常_方法_样例类_伴生对象

配置 pom.xml 文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>scala_study</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.scala-lang</groupId>
            <artifactId>scala-library</artifactId>
            <version>2.11.12</version>
        </dependency>

        <dependency>
            <groupId>org.scala-lang</groupId>
            <artifactId>scala-compiler</artifactId>
            <version>2.11.12</version>
        </dependency>

        <dependency>
            <groupId>org.scala-lang</groupId>
            <artifactId>scala-reflect</artifactId>
            <version>2.11.12</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <!-- Java Compiler -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>

            <!-- Scala Compiler -->
            <plugin>
                <groupId>org.scala-tools</groupId>
                <artifactId>maven-scala-plugin</artifactId>
                <version>2.15.2</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>compile</goal>
                            <goal>testCompile</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>

        </plugins>
    </build>
</project>

学习一门语言，当然提前写hello，world

* object:可以理解为一个单例对象，相当于java给方法增加静态关键字
*
* main 函数需要放在object中才能直接运行
*
* def：scala中定义方法的关键字
* main：方法名
* args：Array[String]：方法的参数
* args:参数名
* Array[String]: 参数类型
* [String]:泛型
* Unit：相当于java中的void

package com.wt
/**
 * @author WangTao
 * @date 2022/7/7 18:42
 */

/**
 * object:可以理解为一个单例对象，相当于java给方法增加静态关键字
 *
 * main 函数需要放在object中才能直接运行
 *
 * def：scala中定义方法的关键字
 * main：方法名
 * args：Array[String]：方法的参数
 * args:参数名
 * Array[String]: 参数类型
 * [String]:泛型
 * Unit：相当于java中的void
 *
 */
object Demo1HelloWorld {
  def main(arg: Array[String]):Unit = {
    println("hello,world")
  }
}

scala基础

package com.wt
import java.util.Scanner

/**
 * @author WangTao
 * @date 2022/7/7 18:59
 */
object Demo2base {
  def main(args: Array[String]): Unit = {
    /**
     * 1.变量
     * 可变：var
     * 不可变：val
     *
     * scala会进行类型推断
     * 变量类型会自动通过等号右边的值推断出来
     */
    //类型自动推断
    //val是值不可变的类型
    val a = 100
    println(a)
    println(a.getClass)

    val b = "scala"
    println(b)
    println(b.getClass)

    //var是可变的变量
    //可变：变量的引用可以再指向其他的变量
    var c = "1234"
    println(c)
    c = "7878"
    println(c)

    println("=" * 100)

    /**
     * 2.字符串
     * scala中的字符串和java中的字符串是同一个，java中字符串所有的方法scala中都有
     *
     * scala和java兼容：java中的类在scala中可以使用，scala中的类在java中也可以使用
     * scala和java的语法不一样
     * 
     */
    val str: String = "java,spark,hadoop"
    //split:通过分隔符切分字符串
    val array: Array[String] = str.split(",")
    //mkString:通过一个分割符将序列拼接成一个字符串和split相反
    println(array.mkString("_"))

    /**
     * 字符串的拼接
     * 1.使用+，性能较差，会占用额外的内存空间
     * 2.StringBuffer,StringBuilder
     * 3.scala中的方法(推荐使用)
     *
     */
    //1.使用+
    val str1: String = "java" +","+ "hadoop" +","+ "spark"
    println(str1)

    //2.StringBuilder
    val builder = new StringBuilder
    builder.append("java")
    builder.append(",")
    builder.append("flink")
    builder.append(",")
    builder.append("linux")
    println(builder.toString())

    //3.scala中的方法
    val s1 = "java"
    val s2 = 1000
    val s3 = 3.14

    //底层也是StringBuilder，只是scala中的一种简写
    val value: String = s"${s1},${s2},${s3}"
    println(value)

    println("=" * 100)

    /**
     * 数组
     */

    val ints: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8)
    //通过下标获取元素
    println(ints(1))

    //打印数组中的元素
    println(ints.mkString("-"))

    //通过下标修改数据
    ints(1) = 999
    println(ints(1))

    println("=" * 100)

    /**
     * 算数运算符
     *
     */
    val i2 = 100
    val i3 = 3
    println(i2 + i3)
    println(i2 - i3)
    println(i2 * i3)
    println(i2 / i3)
    println(i2 % i3)

    println("=" * 100)

    /**
     * 流程控制
     */
    //if...else...
    val scanner = new Scanner(System.in)
    val age: Int = scanner.nextInt()
    if(age > 18){
      println("成年")
    }else{
      println("未成年")
    }

    println("=" * 100)

    /**
     * while 循环
     * for 循环
     */
    //while
    val array1: Array[Int] = Array(3, 4, 5, 6, 7, 8)

    println(array1.length)

    var j = 0
    while(j < array1.length) {
      println(array1(j))
      j += 1
    }

    //增强for循环
    for (elem:Int <- array1) {
      println(elem)
    }

  }
}

scala的IO读写

package com.wt

import java.io.{BufferedReader, FileReader, FileWriter}
import scala.io.{BufferedSource, Source}

/**
 * @author WangTao
 * @date 2022/7/7 20:11
 */
object Demo3Io {
  def main(args: Array[String]): Unit = {
    /**
     * 读取文件
     * 1.可以使用java中的方法
     * 2.在scala中有source
     */
    //使用java中的IO流

    val bufferedReader = new BufferedReader(new FileReader("D://Softwore_java//projects//bigdata17_xiaoge//scala_study//src//main//java//com//data//test.txt"))

    //读取第一行
    var line: String = bufferedReader.readLine

    //判断下一行是否为空
    while(line != null){
      println(line)

      //每次循环读取下一行
      line = bufferedReader.readLine()
    }
    bufferedReader.close()

    println("=" * 100)

    //scala 的方式
    val source: BufferedSource = Source.fromFile("D://Softwore_java//projects//bigdata17_xiaoge//scala_study//src//main//java//com//data//test.txt")

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

    for (elem  <- iterator) {
      println(elem)
    }
      source.close()

    //写文件
    val fileWriter = new  FileWriter("D://Softwore_java//projects//bigdata17_xiaoge//scala_study//src//main//java//com//data//out.txt")

    fileWriter.write("java")
    fileWriter.write(",")
    fileWriter.write("look")
    fileWriter.write(",")
    fileWriter.write("sqoop")
    fileWriter.write(",")
    fileWriter.write("hello")

    fileWriter.close()
  }
}

scala 的函数

package com.wt
import scala.language.postfixOps
/**
 * @author WangTao
 * @date 2022/7/7 20:40
 */
object Demo4Fun {
  def main(args: Array[String]): Unit = {
    /**
     * 函数的定义 -- 函数可以在任何位置定义
     * 1.函数可以定义在object中，object中的函数可以直接调用
     * 2.可以在方法或者函数内部定义函数
     */
    println(add1(100, 200))
    println(add2(99))
    println(add3(20, 200))
    println(add4(66, 22))
    pr

    println(plus(99, 99))

    def plus(i: Int,j: Int): Int = {
      i + j
    }
    /**
     * 函数的调用
     */
    //使用object名称调用
    println(Demo4Fun.add1(2, 2))

    //方法调用的简写
    val str = "java,hadoop,sqoop"
    val strings: Array[String] = str.split(",")

    //简写
    val strings1:Array[String] =  str split ","
  }
  /**
   * def:关键字
   * add：函数名
   * (x: Int,y: Int) 参数列表
   * Int：返回值类型
   * {} 函数体
   */

  def add1(x: Int,y: Int): Int = {
    x+y
  }
  /**
   * 函数的简写
   * 1.如果最后一行作为返回值，return可以省略
   * 2.如果函数的代码逻辑之后一行，{} 可以省略
   * 3.如果参数列表为空，()可以不写，如果定义没有括号，调用时也不能有括号
   */

  def add2(x:Int): Int ={
    x + x
  }

  def add3(x:Int,y:Int): Int = x +y

  def add4(x:Int,y: Int) = x + y

  def pr: Unit = println("scala")
}

scala 的递归

package com.wt

/**
 * @author WangTao
 * @date 2022/7/7 21:16
 */
object Demo5Fun {
  def main(args: Array[String]): Unit = {
    println(jieCheng(20))
  }

  //阶乘，递归
  def jieCheng(i: Long): Long = {
    if(i == 1){
      1
    }else{
      i * jieCheng(i-1)
    }
  }
}

scala 的异常

package com.wt
import java.io.FileReader
/**
 * @author WangTao
 * @date 2022/7/7 21:24
 */
object Demo6Exaction {
  def main(args: Array[String]): Unit = {
    /**
     * scala 的异常和java原理一样
     * scala 默认将异常抛出
     */
    try {

      val reader = new FileReader("data/meiyou.txt")

      val i = 100 / 0

      Class.forName("com.shujia.Test")

      //抛出异常
      throw new RuntimeException("异常")

    }catch {
      case e : ArithmeticException =>
        println("0不能为除数异常")
      case e : ClassNotFoundException =>
        println("类找不到异常")
      case e : Exception =>
        println("其他异常")
    }finally (
      println("代码结束了")
    }
  }
}

scala 的方法

package com.wt
/**
 * @author WangTao
 * @date 2022/7/7 21:41
 */
object Demo7scala {
  def main(args: Array[String]): Unit = {
    val student = new Student("1001","a_tao")
    student.print()

    val student1 = new Student("1002","lisi",20)
    student1.print()

    //多态：父类的引用指向子类的对象
    val obj: Object = new Student("1003", "wangwu", 22)
    println(obj.toString)
  }
}
/*
  在类中可以定义，属性，方法，构造函数
  默认构造函数：{} 是scala默认构造函数的代码块，默认构造函数可以有参数

  scala的类同样是object的子类
 */
class Student(id: String,name: String){
    println("默认的构造函数")

  /**
   * 类的属性
   */
  val _id: String = id
  val _name: String = name

  //下划线代码的占位符，相当于给了一个默认值
  var _age: Int = _

  /**
   * 重载构造函数
   * 在重载构造函数的第一行需要手动调用默认的构造函数
   */
  def this(id: String,name: String,age:Int) {
    //调用默认的构造函数
    this(id,name)

    //给属性赋值
    this._age = age
  }

  /**
   * 在类中定义方法
   *
   */
  def print():Unit = {
    println(s"编号：${_id},姓名：${_name},年龄：${_age}")
  }

  /**
   * 重写父类的方法
   *
   */
  override def toString: String = s"编号：${_id},姓名：${_name},年龄：${_age}"
}

scala 样例类

package com.wt
/**
 * @author WangTao
 * @date 2022/7/7 22:26
 */
object Demo8CaseClass {
  def main(args: Array[String]): Unit = {
    val user = new User("001", "阿彬少年",18)
    //直接通过属性获取值
    println(user.id)
    println(user)

    //样例类可以不使用new创建对象
    val user1: User = User("002", "倒拔垂杨柳")
    println(user1)

    //修改属性，需要在被改变的属性上增加var
    user1.name = "鲁智深"
    println(user1)
  }
}

/**
 * 样例类
 * scala在编译的时候给样例类动态增加新的方法，属性，toString，序列化
 *
 * age：Int  = 0 :默认参数
 */
case class User(id: String ,var name: String,age: Int = 0)

scala 伴生对象

package com.wt
/**
 * @author WangTao
 * @date 2022/7/7 22:51
 */
object Demo9Apply {
  def main(args: Array[String]): Unit = {
    //调用对象的apply方法
    println(Score.apply("哈哈哈", 99))
    //apply方法可以直接使用对象名调用
    //Score()

    val score: Score = Score("001", 200)
    println(score)
  }
}
/**
 * Score object 是Score class 的伴生对象
 */
object Score {
  /**
   * apply:是object中的一个特殊方法，可以直接使用object的名称调度
   */
  def apply(sid: String , sco: Int): Score = {
    new Score(sid, sco)
  }
}
class Score(sid: String, sco: Int){
  override def toString: String = s"Score($sid,$sco)"
}

原创文章，作者：carmelaweatherly，如若转载，请注明出处：https://blog.ytso.com/272643.html

Day01 int java println scala String val 样例

赞 (0)

0

jdk环境变量配置方法

上一篇 2022年7月9日

编译原理-词法分析-基于lex实现 python

下一篇 2022年7月9日

发表回复

登录后才能评论