Scala语言的面向对象

1、面向对象的基本概念

把数据及对数据的操作方法放在一起，作为一个相互依存的整体——对象

面向对象的三大特征：

封装
继承
多态

2、类的定义

简单类和无参方法：

案例：注意class前面没有public关键字修饰。

如果要开发main方法，需要将main方法定义在该类的伴生对象中，即：object对象中

3、属性的getter和setter方法

（1）当定义属性是private时候，scala会自动为其生成对应的get和set方法

private var stuName:String = "Tom"

get方法:
stuName    ----> s2.stuName() 由于stuName是方法的名字，所以可以加上一个括号

set方法:
stuName_=  ----> stuName_= 是方法的名字

（2）定义属性：private var money:Int = 1000 希望money只有get方法，没有set方法？？

办法：将其定义为常量private val money:Int = 1000

（3）private[this]的用法：该属性只属于该对象私有，就不会生成对应的set和get方法。如果这样，就不能直接调用，例如：s1.stuName —> 错误

4、内部类（嵌套类）

我们可以在一个类的内部在定义一个类，如下：我们在Student类中，再定义了一个Course类用于保存学生选修的课程。

开发一个测试程序进行测试：

import scala.collection.mutable.ArrayBuffer

//嵌套类：内部类
class Student3 {

  //定义一个内部类：记录学生选修的课程信息
  class Course(val courseName:String,val credit:Int){
    //定义其他方法
  }

  //属性
  private var stuName:String = "Tom"
  private var stuAge:Int = 20

  //定义一个ArrayBuffer记录该学生选修的所有课程
  private var courseList = new ArrayBuffer[Course]()

  //定义方法往学生信息中添加新的课程
  def addNewCourse(cname:String,credit:Int){
    //创建新的课程
    var c = new Course(cname,credit)
    //将课程加入list
    courseList += c
  }
}

//测试
object Student3{
  def main(args: Array[String]) {
    //创建学生对象
    var s3 = new Student3

    //给该学生添加新的课程
    s3.addNewCourse("Chinese",2)
    s3.addNewCourse("English",3)
    s3.addNewCourse("Math",4)

    //输出
    println(s3.stuName+"\t"+s3.stuAge)
    println("**********选修的课程**********")
    for(s <- s3.courseList) println(s.courseName+"\t"+s.credit)
  }
}

5、类的构造器

类的构造器分为：主构造器、辅助构造器

（1）主构造器：和类的声明结合在一起，只能有一个主构造器

Student4(val stuName:String,val stuAge:Int)

1)定义类的主构造器：两个参数

2)声明了两个属性：stuName和stuAge 和对应的get和set方法

（2）辅助构造器：可以有多个辅助构造器，通过关键字this来实现

/*
类的构造器：
1. 主构造器：和类的声明结合在一起；只能有一个主构造器
      Student4(val stuName:String,val stuAge:Int)
      (1) 定义类的主构造器：两个参数
      (2) 声明了两个属性：stuName和stuAge 和对应的get和set方法

2.辅助构造器：可以有多个辅助构造器
              通过关键字this来实现
 */
class Student4(val stuName:String,val stuAge:Int) {

  //定义辅助构造器
  def this(age:Int){
    //调用主构造器
    this("no name",age)
  }
}

object Student4{
  def main(args: Array[String]) {
    //创建Student4的一个对象
    var s4 = new Student4("Tom",20)

    println(s4.stuName +"\t" + s4.stuAge)

    //创建一个新的student4 的对象
    var s42 = new Student4(25)
    println(s42.stuName +"\t" + s42.stuAge)
  }
}

6、Scala中的Object对象

Scala没有静态的修饰符，但Object对象下的成员都是静态的 ，若有同名的class，这其作为它的伴生类。在Object中一般可以为伴生类做一些初始化等操作。

下面是Java中的静态块的例子。在这个例子中，我们对JDBC进行了初始化。

而Scala中的Object就相当于Java中的静态块。

Object对象的应用：

单例对象：

使用应用程序对象：可以省略main方法；需要从父类App继承。

7、Scala中的apply方法

遇到如下形式的表达式时，apply方法就会被调用：

Object(参数1,参数2,…,参数N)

通常，这样一个apply方法返回的是伴生类的对象；其作用是为了省略new关键字

Object的apply方法举例：

//object的apply方法
class Student5(val stuName:String) {

}

object  Student5{
  //定义自己的apply方法
  def apply(stuName:String) = {
    println("********** Apply in Object*************")
    new Student5(stuName)
  }

  def main(args: Array[String]) {
    //创建Student5的一个对象
    var s51 = new Student5("Tom")
    println(s51.stuName)

    //创建Student5的一个对象
    var s52 = Student5("Mary")
    println(s52.stuName)
  }
}

8、Scala中的继承

Scala和Java一样，使用extends关键字扩展类。

（1）案例一：Employee类继承Person类

（2）案例二：在子类中重写父类的方法

（3）案例三：使用匿名子类

//演示Scala的继承

//父类
class Person(val name:String,val age:Int){
  //定义方法
  def sayHello():String = "Hello " + name +" and the age is " + age
}

//子类
class Employee(override val name:String,override val age:Int,val salary:Int) extends  Person(name,age){
  //重写父类中的sayHello方法
  override def sayHello():String = "子类中的sayHello方法"
}

object Demo1 {
  //测试程序
  def main(args: Array[String]) {
    //创建一个Person的对象
    var p1 = new Person("Tom",20)
    println(p1.sayHello())

    //创建一个Employee的对象
    var p2:Person = new Employee("Mike",25,1000)
    println(p2.sayHello())

    //使用匿名子类来创建新的Person对象
    var p3:Person = new Person("Jerry",26){
      override  def sayHello() = "匿名子类中的sayHello方法"
    }
    println(p3.sayHello())
  }
}

（4）案例四：使用抽象类。抽象类中包含抽象方法，抽象类只能用来继承。

（5）案例五：使用抽象字段。抽象字段就是一个没有初始值的字段

9、Scala中的trait（特质）

trait就是抽象类。trait跟抽象类最大的区别：trait支持多重继承

10、包的使用

Scala的包和Java中的包或者C++中的命名空间的目的是相同的：管理大型程序中的名称。

Scala中包的定义和使用：

（1）包的定义
（2）包的引入：Scala中依然使用import作为引用包的关键字，例如

而且Scala中的import可以写在任意地方

11、包对象

包可以包含类、对象和特质，但不能包含函数或者变量的定义。很不幸，这是Java虚拟机的局限。

把工具函数或者常量添加到包而不是某个Utils对象，这是更加合理的做法。Scala中，包对象的出现正是为了解决这个局限。

Scala中的包对象：常量，变量，方法，类，对象，trait（特质）

12、Scala中的文件访问

（1）读取行

（2）读取字符

source就指向了这个文件中的每个字符。

（3）从URL或其他源读取：注意指定字符集UTF-8

（4）读取二进制文件：Scala中并不支持直接读取二进制，但可以通过调用Java的InputStream来进行读入。

（5）写入文本文件