----------目录---------------------------------------------------------
3.Scala的函数
-------------------------------------------------------------------------------------------------------------
Scala的面向对象
一、类
1、概述
1）scala中的类和java中基本类似。
2）scala中的类同样通过class来进行声明。
3）scala中的类同样可以具有成员变量和成员方法。
4）scala中的类同样可以通过new关键字来创建出对象。
5）Scala中的类的成员默认的访问权限是public。也可以加private或protected。
6）当成员变量或成员方法是私有属性时，外部将不能直接访问，这个同java一样。
1．创建类
示例：
class Person() {
//创建一个类，并定义类里的两个成员变量name和age。以及一个成员方法 eat()
//需要注意的是：scala中变量(var)声明时需要指定初始值，
private var name = “”
private var age = 0
def eat(){
println("eat")
}
}2．类的构造
1>主构造器
和java不同，scala中的类不需要明确声明一个构造器，而是直接将构造参数通过构造参数列表声明为类的一部分。
而直接写在类的体中的既不是类的成员变量也不是成员函数的部分，会自动收集为构造函数的体。
scala声明主构造的形式是在类右侧声明，如果不声明，Scala也提供了默认构造器。注意：当显示声明主构造器之后，默认的空构造器失效。
示例：
//scala中的类不需要明确声明一个构造器，而是直接将构造参数通过构造参数列表声明为类的一部分
class Person(v1: String, v2: Int) {
//创建一个类，并定义类里的两个成员变量name和age。以及一个成员方法 eat()
//需要注意的是：scala中变量(var)声明时需要指定初始值，
private var name = v1
private var age = v2
//而直接写在类的体中的既不是类的成员变量也不是成员函数的部分，会自动收集为构造函数的体。
//当调用构造方法时，会打印 …… 和***
println("…………")
println("***")
}2>辅助构造器
有些时候，一个类里需要多个构造器。scala里除主构造器之外的构造器被称为辅助构造器。
1）Scala的辅助构造器定义开始于def this()。
2）Scala里每个辅助构造器的第一个动作都是调用同类的构造器。
示例：
class Person(v1: String, v2: Int) {
private var name = v1
private var age = v2
//Scala的辅助构造器定义开始于 def this()
//Scala里每个辅助构造器的第一个动作都是调用同类的构造器
def this(v1: String) = {
this(v1, 0)
}
def this(v2: Int) {
this("", v2)
}
def this() {
this("", 0)
}
}一个完整的示例：
class Person(v1: String, v2: Int) {
private var name = v1
private var age = v2
println("…………")
println("***")
def this(v1: String) = {
this(v1, 0)
}
def this(v2: Int) {
this("", v2)
}
def this() {
this("", 0)
}
def getName() = {
this.name
}
def setName(name: String) = {
this.name = name
}
def getAge() = {
this.age
}
def setAge(age: Int) = {
this.age = age
}
def say() {
println("say word")
}
}2、单例对象(object)
1）scala中的类(class)不能定义静态成员（或静态方法），而代之以定义单例对象来替代。
2）单例对象需要通过object关键字来声明。
3）一个单例对象可以单独存在，也可以绑定到一个类上。
4）单例对象当中的所有方法，都可以不需要创建对象而直接通过object单例对象的名字直接来调用，用起来感觉就像一个静态方法一样。
5）当一个单例对象和某个类写在同一个源文件中且共享同一个名字时，他们就产生了一个绑定的关系。此时单例对象称为该类的伴生对象。类称为该对象的伴生类。
6）类和他的伴生对象可以互相访问其私有成员。
7）以伴生的方式为类增加静态成员成为了可能。
8）单例对象不能new，因此也没有构造参数。
9）可以把单例对象当作是java中可能会用到的静态方法工具类。
10）作为程序的入口main方法必须是静态的，所以main方法必须处在一个单例对象中，而不能写在一个类中。
11）单例对象在第一次被访问时才会被初始化。
示例：
class Person(v1: String, v2: Int) {
//此私有变量，伴生类可以访问
private var name = v1
private var age = v2
}
//Person的单利对象，也即伴生类Person
object Person {
def shownamespace() {
val p = new Person
//可以访问类的私有变量
println(p.name)
}
def eat() {
println("eat")
}
}3、抽象类
scala中同样支持抽象类的使用，抽象类的内部可以包含抽象方法和非抽象方法。抽象类不允许被实例化，抽象类主要是用来被继承的。
Scala的抽象类同java，通过abstract关键字来定义。抽象方法的特点：没有｛｝方法体。
示例：
abstract class Teacher {
//抽象方法，返回值为Unit
def makeNote()
//抽象方法，返回值为String
def teach():String
def compute():Int
//实体方法
def say(){}
}4、特质trait
1）可以类比java中的接口，但是又和接口非常不一样，特质相当于java中的接口，java中称为类实现了接口，scala中称为混入了特质。
2）和java中的接口不同的是，scala中的特质可以包含具有方法体的方法。
和抽象类不同的地方在于，scala的类只能单继承，但是可以多混入，利用这种方式可以实现类似c语言中多继承的特性。
3）在类中可以通过extends或with关键字来让类混入特质，如果类没有明确继承父类，extends关键字没有被占用就可以使用extends。
4）但是如已经使用了extends显示的继承了父类，再向混入特质就要用with关键字了。
一个类的声明中只能有一个extends，但是可以有多个with。
示例：
trait Dance {
def Balei()
def floor()
//trait类似于java的接口，但可以做具体方法的实现
def eat(){}
}
trait Driver {
def shache():String
def piaoyi()
}
//scala中，只能继承一个父类，但是可以混入多个特质（trait)
//需要实现特质中未实现的方法
//此外，需要注意的是，如果未继承任何类或抽象类，在混入特质时，
//比如有且仅有一个特质需要用extends来混入，而其他特质用with混入
class ZhangTeacher extends Dance with Driver {
def Balei(): Unit = {
???
}
def floor(): Unit = {
???
}
def piaoyi(): Unit = {
???
}
def shache(): String = {
???
}
}5、样例类case class
1）只要在声明类时，在class关键字前加上case关键字，这个类就成为了样例类。样例类必须要显式的声明一个主构造器。
2）当样例类声明一个主构造器后，会默认隐式的声明一个空构造器。
3）样例类默认实现序列化接口。
序列化的两个作用：①数据持久化；②网络数据传输。
4）样例类默认自动覆盖toString、equals、hashCode方法。
5）样例类不需要new可以直接生成对象。
示例：
//需要声明一个主构造器，主构造器可以是一个空构造器
case class Item(v1:Int,v2:String) {
var id=v1
var title=v2
}
//样例类不需要new，并且隐式的含有空构造器
val v1=Item(1,"phone")
//> v1 : Item = Item(1,phone)
val v2=Item
//> v2 : Item.type = Item6、option
在Scala中用来表示一个结果，它可能有值，也可能没有值，它有两个子Option。一个是Some，一个是None。
示例：
def f1(a:Int,b:Int)={
if(b!=0){
Some(a/b)
}else{
None
}
}
//表示如果有正确结果，返回正确结果，没有则返回指定的默认值
f1(4,0).getOrElse("error") 7、包的引用
类似于java中通过import关键字引入包/类，scala也可以实现这种方式引入，但是更强大一些。
1）scala中的import可以出现在代码任何地方。
2）scala中的import时可以指的是对象和包。
3）scala中的import可以重命名或隐藏一些被引用的成员。
4）scala默认会自动引入如下三个包下的所有内容。
java.lang：java中的通用类。
scala._：scala提供的通用类 主要是基本类型除了String。
Predef._：提供了单例对象 以及一些常用方法 print println。
示例：
import cn.tedu._
import cn.tedu.{Apple,Orange}二、面向对象
1、重写和重载
1）重写是指覆盖父类中的方法来在子类中做其他事项。
格式：
override def 父类方法名 参数列表 返回值 方法体
2）重载是指在同一个类中提供方法名相同但是参数不同的方法和java中基本一致。
示例：
2、final
可以用在成员变量、成员方法、类本身上，作用和java中相同。
3、多态
示例：
object Demo13{
def main(args: Array[String]): Unit = {
val t1:Teacher=new TeacherChen("chen",32)
val t2:Teacher=new TeacherLiu("liu",32)
}
}4、泛型
基本和java中相同，不同的是，泛型是用方括号引起来的。
val arr = Array[String]();上一篇：Scala中的集合类型