元组的创建方式：
回顾
object 回顾 {
/**
* Array(定长数组),ArrayBuffer(变长数组)
*
* 集合
* 可变集合（collection.mutable)
* ListBuffer => 内容和长度都可以改变
*
* 不可变集合(collection.immutable)
* List => 长度和内容不可变
* var list = List(1,3,4)
*
* Map
* val mp = Map[String, String]("a" -> "a", "b" -> "b")
* mp.get("c") => Option[String]
* mp.getOrElse("a", "00") => String
*
* Set
* 存储的元素是无序的，且里面的元素是没有重复的。
*
* 元组:元组中可以放任意类型的数据,最多可以放22个
* val tp = (1, true, "", Object)
* 获取元组中的元素: tp._3
*
* Seq Nil
* Seq 中分为 head,tail
* 第一个元素是head,剩余的是tail
* List(0) head=9 tail.Nil
*
* Option Some None
* Some(100).get
* Some和None都是Option子类
* 获取Some中的值是通过他的get方法
* None
*
* 集合相关的API操作
* aggregate()(seqOp, combOp) 对集合进行某种聚合操作
* count(boolean) 返回是符合条件的元素个数
* diff 某个集合和另外一个集合的差值
* distinct 对集合中的元素进行去重
* filter(boolean) 过滤出符合条件的元素集合
* flatMap 对集合进行某种映射操作，然后再进行扁平化操作
* flatten 扁平化操作
* fold(初始值)(操作规则) 折叠操作
* foldLeft()() 从左到右折叠
* foreach(f: A => Unit)
* groupBy(key) 按照key进行分组
* grouped(Int) 将集合按照Int个数进行分组
* head 获取集合中的头元素
* indices 返回集合的角标范围
* intersect 求两个集合的交集
* length 返回集合的元素个数
* map 对集合进行某种映射操作
* mkString 对集合进行格式化输出
* nonEmpty 判断集合是否为空
* reduce 聚合
* reverse 将集合进行返转
* size 返回集合的长度
* slice(start, end) 截取集合
* sortBy(key) 集合按照某个key进行排序
* sortWith(boolean) 将集合按照某种规则进行排序，比较规则
* sorted 集合按照升序排序
* sum 对集合进行求和操作
* tail 返回集合的尾部元素列表
* zip 拉链操作，相同角标位置的元素组合到一起，并返回一个新的集合
*/
}
1.对象的方法成员调用
/**
* 在scala中的object是一个单例对象，没办法new
* object中定义的成员变量和方法都是静态的
*
* 可以通过对象名.方法 或者 .成员变量
*/
object ScalaStatic {
val name: String = "zhangsan"
var age: Int = 18
def saySomething(msg: String) = {
println(msg)
}
def apply(food: String) = {
println(s"什么食物：$food")
}
}
def main(args: Array[String]): Unit = {
println(ScalaStatic.name)
ScalaStatic.age = 29
println(ScalaStatic.age)
ScalaStatic.saySomething("今天有点冷")
ScalaStatic.apply("番茄炒西红柿")
//默认调用了apply方法
ScalaStatic("油闷大虾")
}
2.类的定义
/**
* 在Scala中定义类的用class关键字修饰
* 这个类默认有一个空参构造器
*
* 定义在类名称后面的构造器叫主构造器
* 类的主构造其中的属性会定义成类的成员变量
*
* 如果主构造器中成员属性没有val/var修饰的话，该属性不能被访问，相当于没有对外提供get方法
* 如果主构造器中成员属性使用var修饰的话，该属性可以被访问，相当于对外提供了get/set方法
* 如果主构造器中成员属性使用val修饰的话，相当于对外提供了get方法
*
*/
class Teacher(var name: String, var age: Int) {
var sex: String = _
var prov: String = _
//定义一个辅助构造器,def this()
def this(name: String, age: Int, sex: String) = {
//在辅助构造其中必须先调用主构造器方法
this(name, age)
this.sex = sex
}
def this(name: String, age: Int, sex: String, prov: String) = {
this(name, age, sex)
this.prov = prov
}
}
object TestApp extends App {
private val teacher = new Teacher("灰灰", 19)
teacher.name = "慧慧"
println(teacher.name)
private val ttTeacher = new Teacher("TT", 35, "nan", "XX")
println(ttTeacher.prov)
}
3.构造器的访问权限
4.类成员属性的访问权限
5.类的访问权限
6.Scala中的伴生对象
class Teacher(private var name: String, var age: Int) {
var sex: String = _
var prov: String = _
//定义一个辅助构造器,def this()
def this(name: String, age: Int, sex: String) = {
//在辅助构造其中必须先调用主构造器方法
this(name, age)
this.sex = sex
}
private def this(name: String, age: Int, sex: String, prov: String) = {
this(name, age, sex)
this.prov = prov
}
}
//object Teacher 叫类的伴生对象
//在伴生对象中可以访问类的私有成员方法和属性
object Teacher{
def apply(name: String, age: Int) : Teacher = {
//初始化工作
new Teacher(name, age, "male", "taiguo")
}
def main(args: Array[String]): Unit = {
var teacher = new Teacher("喵喵", 33)
println(teacher.name)
val taotaoTeeacher = Teacher("taotao", 20)
println(taotaoTeeacher.sex, taotaoTeeacher.prov)
}
}
下午回顾
object 下午回顾 {
/**
* object
* 单例对象，里面定义的成员变量 和 方法都是静态的，相当与用static修饰的成员变量和成员方法
*
* 伴生对象
* 当object的名称和类的名称一致的时候，该对象称为伴生对象，（必须在同一个文件中）
*
* apply
* object对象() -> object中的apply()方法
*
* class
* 类
*
* 类的主构造器：定义在类的名称后面的构造器
* 类的辅助构造器：定义在类体中，def this()类的辅助构造器，在类的辅助构造其中必须先调用类的主构造器
* 类的成员变量：
* var 对外提供了 get/set
* val 对外提供了 get
*
* 访问权限：
* 成员变量 private 标识外部没法访问它get/set方法
* 方法的 private 表示外部没法调用这个方法
* 构造器 private 在外部无法访问
* 类的 private[包名] 表示这个类在这个包名及其子包下可见（可访问）
* private[this] 表示这个类在当前类下可见
*
* 伴生对象可以访问类中的私有方法private,不能访问private[this]修饰的成员变量及方法
*/
}
并行化集合
7.Scala特质Trait定义使用
object ScalaTraitImpl extends ScalaTrait {
/**
* 如果特质中hello方法中没有具体实现，可以不加override关键字
*/
override def hello(name: String): Unit = {
println(s"hello $name")
}
/**
* 如果特质中small方法有具体实现，覆盖必须加override关键字
*/
override def small(name: String): Unit = {
println(s"丁丁 对 $name 哈哈大笑")
}
def main(args: Array[String]): Unit = {
ScalaTraitImpl.hello("scala")
ScalaTraitImpl.small("老杨")
}
}
trait ScalaTrait {
/**
* 没有任何实现的方法
*/
def hello(name: String)
def small(name: String) = {
println(s"老赵对$name 妩媚一笑")
}
}
在创建类的时候可以动态的混入多个特质
class Student{
}
object Person {
def main(args: Array[String]): Unit = {
/**
* 在scala中可以动态的混入n个特质
*/
val student = new Student with Fly with ScalaTrait
student.fly("小鸟")
student.hello("小鸟")
}
}
trait ScalaTrait {
/**
* 没有任何实现的方法
*/
def hello(name: String) = {
println(s"hello $name")
}
def small(name: String) = {
println(s"老赵对$name 妩媚一笑")
}
}
Scala中的抽象类abstract
/**
* 使用关键字abstract定义一个抽象类
* 可以具体实现的方法
* 也可以有具体实现的方法
*/
abstract class AbsClass {
def eat(food: String): String
def swimming(style: String) = {
println(s"$style 这么游")
}
}
/**
* 在Scala中第一个继承抽象类或者特质，只能使用关键字extends
* 如果想继承多个特质的话，可以在extends之后使用with关键字
*/
object AbsClassImpl extends AbsClass {
override def eat(food: String): String = {
s"$food 炒着吃"
}
def main(args: Array[String]): Unit = {
AbsClassImpl.swimming("躺着游")
println(AbsClassImpl.eat("竹笋"))
}
}
如果特质中的某个方法不能被覆盖，可以加上final关键字
在Scala中，final修饰的
类：类不能被继承
方法：方法不能被override
成员变量：不能被重新修改
object Student1 extends Student0 {
override type T = String
def main(args: Array[String]): Unit = {
Student1.learn("String")
}
}
object Student2 extends Student0{
override type T = Int
def main(args: Array[String]): Unit = {
Student1.learn("99")
}
}
trait Student0 {
type T
def learn(s: T) = {
println(s)
}
}
8.Scala中的样例类和样例对象
/**
* 支持模式匹配，默认实现了Serializable接口
*
* 样例类：case class 类名(属性...)
* 类名的定义必须是驼峰式,属性名第一个字母小写
*/
case class Message(sender: String, messageContent: String)
/**
* 样例对象：case object 对象名
* 模式匹配
* 样例对象不能疯传数据
*/
case object CheckHeartBeat
object TestCaseClass{
def main(args: Array[String]): Unit = {
val message = new Message("刘亦菲", "今天晚上吃饭")
}
}
9.模式匹配
/**
* 模式匹配
* 一旦一个模式匹配上以后，就不会往后匹配了
*/
object ScalaMatchCase {
def main(args: Array[String]): Unit = {
//匹配字符串内容
def contentMatch(str: String) = str match {
case "hello" => println("hello")
case "Dog" => println("Dog")
case "1" => println("1")
case _ => println("匹配不上")
}
println("=======匹配字符串内容=========")
contentMatch("hello")
contentMatch("Dog")
contentMatch("1")
contentMatch("fuck")
println("---------------------")
//匹配数据类型
def typeMatch(tp: Any) = tp match {
case x: Int => println(s"Int $x")
case y: Long => println(s"Long $y")
case b: Boolean => println(s"boolean $b")
case _ => println("匹配不上")
}
typeMatch(1)
typeMatch(10L)
typeMatch(true)
typeMatch("scala")
println("------------------------")
//匹配Array
def arrayMatch(arr: Any) = arr match {
case Array(0) => println("只有一个0元素的数组")
case Array(0, _) => println("以0开头的，拥有2个元素的数组")
case Array(1,_,3) => println("以1开头，3结尾，中间为任意元素的三个元素的数组")
case Array(8, _*) => println("以8开头，n个元素的数组")//_*表示0或多个任意类型的数据
}
arrayMatch(Array(0))
arrayMatch(Array(0,1))
arrayMatch(Array(1,"ture",3))
arrayMatch(Array(8,5,55,5))
println("---------------------")
//匹配List
def listMatch(list: Any) = list match {
case 0::Nil => println("只有一个0元素的List")
case 7::9 :: Nil => println("只有7和9元素的List")
case x::y::z::Nil => println("只有三个元素的List")
case m::n if n.length > 0 => println("-----")//拥有head,和tail的数组
}
listMatch(List(0))
listMatch(List(7,9))
listMatch(List(88,9,2))
listMatch(List(0,8888,211,23,3))
println("---------------------")
//匹配元组
def tuple(tuple: Any) = tuple match {
case (0, _) => println("元组的第一个元素为0，第二个元素为任意类型的数据，且只有2个元素")
case (x, m, k) => println("元组拥有三个元素")
case (_, "AK47") => println("AK47")
}
tuple((0, 3))
tuple((true, 10L, "ll"))
tuple(("aaa", "AK47"))
println("---------------------")
//匹配对象
def objMatch(obj: Any) = obj match {
case SendHeartBeat(x, y) => println(s"$x $y")
case ChickTimeOutWork => println("CheckTimeOutWork")
case "registerWork" => println("registerWork")
}
objMatch(SendHeartBeat("appid00001", System.currentTimeMillis()))
objMatch(SendHeartBeat("xx", 100L))
objMatch(ChickTimeOutWork)
objMatch("registerWork")
}
}
/**
=======匹配字符串内容=========
hello
Dog
1
匹配不上
---------------------
Int 1
Long 10
boolean true
匹配不上
------------------------
只有一个0元素的数组
以0开头的，拥有2个元素的数组
以1开头，3结尾，中间为任意元素的三个元素的数组
以8开头，n个元素的数组
---------------------
只有一个0元素的List
只有7和9元素的List
只有三个元素的List
-----
---------------------
元组的第一个元素为0，第二个元素为任意类型的数据，且只有2个元素
元组拥有三个元素
AK47
---------------------
appid00001 1556546410115
xx 100
CheckTimeOutWork
registerWork
*/
9万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
