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)
