Scala HelloWorld、Scala和java的关系、Scala是什么、Scala的特点、Scala和java的兼容(Scala的基础语法简介)
Scala HelloWorld
在 Scala 模块的 src.main.java 目录下创建一个包用来管理我们的 Scala 代码
然后 在包中新建一个 Scala 的类，右击包 --> New --> Scala Class
并 指定 Scala 类的类型为 Object(对象)
注意 ：
在 Scala 中一行命令不需要以分号结尾，但是如果一行里面写了多条命令，多条命令之间以分号分隔
Scala 的 main 方法 需要放在 object 里面 才能运行
package com.shujia.scala
/**
*
* class 是一个类
* object： 是一个对象，object中定义的所有的方法可以直接调用 所以 object 可以理解为 static
*
*/
object Demo1Helloworld {
/**
* main 需要放在object才能运行
*
* def : 定义方法的关键字
* main : 方法名
* (args: Array[String]) 方法的参数
* args : 参数名，Array[String] ;参数类型（字符串数组）
* Unit : 返回值，相当于void 可以省略不写
*
* [] : scala中的泛型
*
*/
def main(args: Array[String]): Unit = {
println("scala")
//println 底层和java是一样的
System.out.println("java")
}
}
scala 与 java 的关系
Scala 是什么？
Scala 是 Scalable Language 的简写，是一门多范式的编程语言
联邦理工学院洛桑（EPFL）的Martin Odersky于2001年基于Funnel的工作开始设计Scala。
Scala是把函数式编程思想和面向对象编程思想结合的一种编程语言。
大数据计算引擎Spark由Scala编写
Scala 很多地方就是对 java 的延续，一种更高层的封装和简化
Scala 和 java 是语法不兼容，但是类兼容的
所以说 Scala 的底层还是 java
Scala 特点
Scala 与 java 的兼容(Scala的基础语法简介)
变量、常量的定义
字符串
在 Scala 中使用 java 的集合与IO流
package com.shujia.scala
import java.io.{BufferedReader, FileReader}
import java.util
object Demo2SscalaOnJava {
def main(args: Array[String]): Unit = {
/**
* 变量和常量
*
* var : 变量
* val : 常量
*
* 尽量使用val 因为性能更好一点
*
* scala中变量的类型可以自动推断
* 通过等号右边的对象推断类型
* 当然也可以手动添加类型
*
*/
// scala中变量的类型可以自动推断
// var str = "scala"
// 也可以手动添加类型
var str: String = "scala"
str = "java"
/**
* scala中的字符串和java中的字符串是一样的
*
* 之前java中学过的所有的方法在scala中同样适用
*/
// val split: Array[String] = str.split("")
/**
* scala对java中的类做了很多的扩展，增加了很多好用的方法（隐式转换）
*/
// 获取头
val head: Char = str.head
println(head)
// 获取不包含头的所有元素
println(str.tail)
// 获取最后一个元素
println(str.last)
// 这里的 * 是一个方法，表示将等号重复100次，完整形式如下
// println("=".*(100))
// 简化版
println("=" * 100)
/**
* java中集合在scala中的使用
*/
val list = new util.ArrayList[Int]()
list.add(1)
list.add(2)
list.add(3)
println(list.get(1))
println(list)
// scala中遍历java的集合
var i = 0
while (i < list.size()) {
println(list.get(i))
i += 1
}
/**
* 在scala中使用java的io流
*/
val fileReader = new FileReader("data/students.txt")
val bufferedReader = new BufferedReader(fileReader)
// 读取第一行
var line: String = bufferedReader.readLine()
// 在Scala中赋值和判断不能写在一起
while (line != null) {
println(line)
// 读取下一行
line = bufferedReader.readLine()
}
}
}
在 java 类中 new Scala 类的对象
package com.shujia.scala
/**
* scala中类
*/
class Demo3ScalaClass {
/**
* 类中定义的方法
*/
def print(s: String): Unit = {
println(s)
}
}
/**
* java中类
*/
package com.shujia.scala;
public class Demo4JavaCode {
public static void main(String[] args) {
/*
* java 和 scala 类可以相互兼容，
* 语法(关键字)不兼容
*/
Demo3ScalaClass demo3ScalaClass = new Demo3ScalaClass();
demo3ScalaClass.print("java");
}
}
变量和常量
增强for循环
while 循环
foreach
scala可以使用java中的io流
Scala 中读文件的方式 -- Source
scala 字符串拼接
scala mysql jdbc
package com.shujia.scala
import java.sql.{Connection, DriverManager, PreparedStatement, ResultSet}
import scala.io.{BufferedSource, Source}
object Demo5Base {
def main(args: Array[String]): Unit = {
/**
* 变量和常量
* val : 常量
* var : 变量
*
* 尽量使用val 因为性能更好一点
*
* scala中变量的类型可以自动推断
* 通过等号右边的对象推断类型
* 当然也可以手动添加类型(推荐)
*/
val a: Int = 1
// scala中变量的类型可以自动推断
// var str = "java"
// 也可以手动添加类型
var str: String = "java"
/**
* 循环
*/
// Array(1, 2, 3, 4, 5, 6, 7, 8, 9) Scala 中 定义数组
val array: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)
// 增强for循环
for (i <- array) {
println(i)
}
println("=" * 100)
// while 循环
var i = 0
while (i < array.length) {
// 通过下标获取元素
println(array(i))
i += 1
}
println("=" * 100)
/**
* foreach
*
* (i => println(i)) 匿名函数
*/
array.foreach(i => println(i))
/**
* io流: scala可以使用java中的io流
*/
println("=" * 100)
// Scala 中读文件的方式 -- Source
// 链式调用
val lines: Iterator[String] = Source.fromFile("data/students.txt").getLines()
for (line <- lines) {
println(line)
}
println("=" * 100)
/**
* scala 字符串拼接
*/
// java的方式
val s: String = "java" + "scala" + "hadoop"
val stringBuffer = new StringBuffer()
stringBuffer
.append("java")
.append("scala")
.append("hadoop")
println(stringBuffer.toString)
/**
* scala 字符串拼接
*/
val s2 = "java"
val s3 = "scala"
val s4 = "hadaoop"
/**
* s"$s2$s3${s4}shujia"
* ${} : 表示引用变量、{} 可以省略
* s : 是一个函数，底层调用还是 append
* ${s4}shujia : s4 后面有字符串 shujia 会产生冲突，因为并没有s4shujia这个变量，所以需要用 {} 将他俩分开
*/
val s5 = s"$s2$s3${s4}shujia"
println(s5)
/**
* scala mysql jdbc
*/
/*
在Scala模块的pom.xml文件中添加依赖
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.40</version>
</dependency>
*/
// 1、加载驱动 Scala 默认会抛出异常
Class.forName("com.mysql.jdbc.Driver")
// 2、创建链接
val con: Connection = DriverManager.getConnection("jdbc:mysql://rm-bp1h7v927zia3t8iwho.mysql.rds.aliyuncs.com:3306/students", "shujia012", "123456")
// 3、查询数据
val stat: PreparedStatement = con.prepareStatement("select * from students")
// 4、执行查询
val resultSet: ResultSet = stat.executeQuery()
while (resultSet.next()) {
val id: Long = resultSet.getLong("id")
val age: Long = resultSet.getLong("age")
val name: String = resultSet.getString("name")
val clazz: String = resultSet.getString("clazz")
val gender: String = resultSet.getString("gender")
println(s"$id\t$name\t$age\t$gender\t$clazz")
}
//关闭链接
con.close()
}
}
Scala中的类的用法
package com.shujia.scala
object Demo6Class {
def main(args: Array[String]): Unit = {
//创建对象
val student = new Student("001", "张三", 23)
println(student)
student.setId("002")
println(student)
}
}
/**
* 类中可以定义属性，方法，构造函数，还可以继承父类，实现接口
*/
// scala 中类的默认无参构造函数就是 类名后面的 {……}
// class Student {
//
// println("默认构造函数")
//
// }
// 给默认的构造函数加上参数
// class Student(变量名:变量类型,……) {
//
// println("默认构造函数")
//
// }
// 默认构造函数的重载
class Student(id: String, name: String) {
println("默认构造函数")
/**
* 定义类的属性
*
* private: 私有化
*
* _ 占位符，这里相当于区分了一下名字 _id和id
*
*/
private var _id: String = id
val _name: String = name
/**
* _ 占位符，相当于给变量一个默认值
*/
var _age: Int = _
/**
* 重载构造函数
*/
def this(id: String, name: String, age: Int) {
//在重载构造函数的第一行需要先调用默认构造函数
this(id, name)
println("重载构造函数")
this._age = age
}
/* override def toString(): String = {
return s"Student($_id, $_name, $_age)"
}*/
/**
* scala中函数的省略
* 1、如果函数没有参数，() 可以省略
* 2、返回值类型可以不写，会自动推断
* 2、如果函数最后一行作为返回值，return可以省略
* 4、如果函数中代码只有一行 {} 可以省略
*/
//重写父类的方法
// _ 在Scala中有特殊意义，$ 引用 以_开头的变量 的时候需要加上{}，例如:${_id}
override def toString = s"Student(${_id}, ${_name}, ${_age})"
/**
* get set 方法
* IDEA不能自动生成
*/
def getId: String = this._id
def setId(id: String): Unit = {
this._id = id
}
}
样例类
package com.shujia.scala
object Demo7CasrClass {
def main(args: Array[String]): Unit = {
//使用样例类
val user = new User("001", "李四")
println(user)
//获取属性的值
println(user.name)
//修改属性的值
user.name = "张三"
println(user)
/**
* 样例类创建对象的另一种方法，不用 new
*/
val user2 = User("002", "王五")
println(user2)
}
}
/**
* 样例类
*
* scala 在编译的过程中会动态的给样例类增加方法（toString,hashCode,equals,……）
* 并将参数变成类的属性，默认是常量
* 若想将属性设置为变量，则需要在变量名(属性名)之前加上 var
*/
case class User(id: String, var name: String)
Scala 类的继承
package com.shujia.scala
object Demo8Extends {
def main(args: Array[String]): Unit = {
val a = new B("001", "张三", 23)
// 调用方法 就近原则
println(a)
}
}
// B 继承 A
/*
class A() {
}
/**
* 类的继承
* 会继承父类的属性，方法
*/
class B() extends A() {
}
*/
// B 继承 A 时，父类 A 的构造方法需要传参
// 父类 A 的默认有参构造方法 需要传入 id name
class A(id: String, name: String) {
val _id: String = id
val _name: String = name
override def toString = s"A(${_id}, ${_name})"
}
// B 需要将 参数传过去
// 要想初始化子类 必须先初始化父类 ，所以子类 B 的默认有参构造方法 会先调用父类 A 的默认有参构造方法
// B 的默认有参构造方法需要将 id name 传给父类 A 的默认有参构造方法
class B(id: String, name: String, age: Int) extends A(id, name) {
val _age: Int = age
// 重写父类Object的方法
// 调用方法 就近原则
override def toString = s"B(${_id}, ${_name},${_age})"
}
Scala 特征(接口)
抽象类
package com.shujia.scala
object Demo9Trait {
def main(args: Array[String]): Unit = {
val dog = new Dog
dog.print()
dog.cry()
/**
* 父类的引用指向子类的对象
*
*/
val cat: Cry = new Cat
cat.cry()
cat.print()
}
}
/**
* scala中的特征，trait可以写抽象方法也可以写普通方法
*
*/
trait Cry {
/**
* 抽象方法
*
*/
def print()
/**
* 普通方法
*
*/
def cry(): Unit = {
println("动物叫")
}
}
// 在 Scala 中只有继承 extends 的关键字，所以 trait 特征也是用继承 extends 关键字来实现特
// 征
class Dog() extends Cry {
/**
* 实现特征中的抽象方法
*
*/
override def print(): Unit = {
println("狗叫")
}
}
class Cat() extends Cry {
/**
* 实现特征中的抽象方法
*
*/
override def print(): Unit = {
println("猫叫")
}
}
// scala 中也有抽象类，例如
// abstract class Dog(){
// }
Scala 对象 Object
apply 方法
package com.shujia.scala
object Demo10Object {
def main(args: Array[String]): Unit = {
Test.print()
//调用apply 方法
Test()
//调用有参的apply方法
Test("scala")
}
}
/**
* object: 是scala的对象，是这个类的一个单例对象
*
* 对象中的方法可以直接调用
*
* object : 相当于java中static
*/
object Test {
def print(): Unit = {
println("test")
}
/**
* apply : 可以直接通过对象加上括号调用
* 这是对象里面一个很特殊的方法，只要方法名称叫 apply 即可
*/
def apply(): Unit = {
println("apply")
}
def apply(s: String): Unit = {
println(s)
}
}
样例类与apply
package com.shujia.scala
object Demo11Apply {
def main(args: Array[String]): Unit = {
val s1: Score = new Score("001", 100)
// 通过伴生对象来 new Score 的对象，可以达到类似样例类的效果
val s2: Score = Score("002", 80)
}
}
class Score(id: String, sco: Int) {
val _id: String = id
val _sco: Int = sco
override def toString = s"Score(${_id}, ${_sco})"
}
/**
* 伴生对象
* 伴生对象并不是上面Score类的对象，上面Score类的对象是需要new出来的
*/
object Score {
//创建上面 Score 类的对象，并返回
def apply(id: String, sco: Int) = new Score(id, sco)
}
Scala 类型转换
package com.shujia.scala
object Demo12CastType {
def main(args: Array[String]): Unit = {
/**
* scala中类型转换
*
*/
val s: String = "1000"
// java的方式
val i: Int = Integer.parseInt(s)
println(i)
// scala的方式
// 只要在 Scala 中涉及到类型转换的问题 to 就完事了
val i2: Int = s.toInt
println(i2)
//如果类型不匹配会出现类型转换异常
//val i3: Int = "asdsa".toInt
val j = 1000
println(j.toDouble)
}
}
Scala 异常处理
package com.shujia.scala
object Demo13Exception {
def main(args: Array[String]): Unit = {
/**
* scala中的异常会自动抛出，可以不处理
*
*/
//1、抛出异常对象
//throw new RuntimeException
// try …… catch …… finally …… 处理异常
try {
val i: Int = "asdasd".toInt
// try 中出现异常，报错代码下面的代码就不会执行了
println(i)
} catch {
//case 是匹配的意思，如果出现的异常是后面的异常类型，就走大括号中的代码
case e: NumberFormatException => {
println(e)
}
case e: RuntimeException => {
println(e)
}
} finally {
println("finally")
}
// 因为异常被处理，所以println照常输出
println("main函数接收")
}
}
