scala之基础面向对象

文章列表

scala之基础面向对象

scala 既是面向对象也是函数式编程
从Java 发展而来，依赖JVM环境

一、 scala 在linux中运行

scala 模式中直接编写运行
scala文件，load执行
scala编译程序
编译

运行

scala
java

二、scala 数据类型

基础数据类型

val 不可变变量函数式编程
var 可变变量面对对象编程

两种方式：
scala之基础面向对象
2. 数据结构

数组 Array
多元数组
元组 Tuple
可以存放不同类型（）
容器 Colection
scala.collection.mutable 可变的容器的包
scala.collection.immutable 不可变的容器的包

seq 0,1,2 索引
map 键索引
set 无序
list(值类型相同，些初始化赋值不可变)/queue <- linearSeq
List
var st = List(“Big”,“small”,“person”)
val otherList = “Apple”::st 一个新列表，前面加个字符串 apple
val intList = 1::2::3::Nil(从右向左执行) <->val intList = List(3,2,1)
vector/arrayBuffer <- indexedSeq
Vector
Range
val r = new Range(1,5,1) ->1,2,3,4,5
1 to 5 ->1,2,3,4,5
1.to(5) -> 1,2,3,4,5
1 to 5 by 2 ->1,3,5
1 unitl 5 ->1,2,3,4(不包含5)
0.1f to 2.5f by 0.4f ->0.1,0.5,0.9,1.3,1.7.2.1
Set 集合
情况一：
var myset =Set(“hadoop”,“spark”) – 一个不可变集合，但是myset 是一个可变变量
mySet += “scala” 是形成新的不可变集合后，将 mySet指向变过去，见下图

情况二：

这里 myMutableSet 是不可变变量，，但它指向的Set集合是可变的
Map 映射
键值对容器：键唯一，值不唯一
val myMap = Map(“XMU”->“xiamen University”,“THU”->“Tsinghua University”)
val xmu = if(myMao.contains(“XMU”)) myMap(“”) else 0 先判断存不存在键再取数，否则报错

三、面向对象编程

方法定义：
def 方法名(参数列表):返回结果类型={方法体}
注：
- 不返回结果时结果类型Unit，也可以省略:Unit
- 参数列表中不能用val,var来修饰
- 没参数时，()可以省略【此时调用时也不能带()】，还可以用def 方法名 {参数列表} :返回结果类型={方法体}
- 一个方法只有一个参数，可以省略圆点采用 中缀操作符调用方法
- 结果类型也可以省略，可以判断，，只要最后一行是要返回的值就可以
类定义及实例化

public private protect
private:
value_= 写（value_= 相当于 java setter）
value 读(value 相当于 Java getter)
类构造器：
class myClass(val/var name:String)
会成为myClass的一个参数，并自动给他创建读写方法 name_= 和 name
辅助构造器 this()

运行：
单例对象
object,不需要实例化便可使用
- 伴生对象：同一个代码文件中的同名的类与对象互为半生关系，可调用对方的内部成员
  
  举例：
因为new Person() 所以Person指的class,俩个类实例通用一个伴生对象，，所以结果打印一个是1 一个是2
- 孤立对象：
  仅有object,不存在伴生类
  
  举例：
  对象内部成员，，可理解其是静态的

继承
scala之基础面向对象

类	类型	存储位置	实例化
AnyVal	值类型	寄存器	不能实例化不能new Int
AnyRef	引用类型	堆	可实例化 new Array
Nothing	只能用来错误处理、异常处理		没有实例
Null	与Java Null 对应
Option	返回应用类型时无返回值不建议Null，建议Option		Some()对象封装返回，其中有一个None对象，处理返回为空

case class Book(val name:String,val price:Double)//case class 默认给生成apply这些方法
val books= Map("hadoop"->Book("Hadoop",35.1),"spark"->Book("Spark"),55.0)

scala之基础面向对象

抽象类
内有有未实现的方法 abstract修饰

abstract class Car(val name:String){val carBrand:String //未初始化，抽象字段，必须给类型声明:Stringdef info() // 抽象方法def greeting(){println("Welcome to my car"}}
}

扩展类
注意：如果是重写父类的已实现的方法或者赋值字段必须加 override关键字，否则可写可不写；只能重载val的字段，var的本身不可变不能重载

class BMWCar extends Car{override val carBrand = "BMW"def info(){printf("This is a %s Car",carBrand)}override def greeting(){println("Welcome to my BMW car")}
}

四、scala 特性

apply方法生成对象
scala 的类定义了apply方法时，类名() <-> 类名.apply()
原因：融合面向对象编程与函数式编程

举例说明函数调用->类调用

举例说明类调用->函数调用

利用这个特性可以生成一个对象工厂：
update
当对带有括号并包括一到若干参数的对象，进行赋值时，，调用update

val myStrArr = new Array[String](3)  // 声明一个长度为3的字符串组，初始化null
myStrArr(0) = "BigData" //(0) 带有括号，一个参数；=“” 赋值,其实调用了伴生类的update
myStrArr.update(0,"BigData") // 等效

unapply 提取参数

class Car(val brand:String,val price:Int){def info(){println("Car brand is "+brand+"and price is "+price)}
}
object Car{ // 伴生对象def apply(brand:String,price:Int)={println("Debug:calling apply..")new Car(brand,price)}def unapply(c:Car):Option[(String,Int)]={println("Debug:calling unapply ...")Some((c.brand,c.price))}
}
object TestUnapply{def main(args:Array[String]){ // 入口函数var Car(carbrand,carprice) = Car("BMW",800000)//Car("BMW",800000) 先调用apply生成一个Car类//var Car(carbrand,carprice)= 调用unapply  将参数提取出来 println(carbrand+":"+carprice)}
}