Scala之面向对象 Day -3

面向对象

类和对象

1. 在Scala中，通过class来定义类

   package com.fesco.objectx
   
   object PersonDemo {
   
     def main(args: Array[String]): Unit = {
   
       val p = new Person
       p.setName("Amy")
       p setAge 15
   
       println(p.getName)
       println(p.getAge)
       println(p.id)
   
     }
   
   }
   
   // 通过class定义类
   class Person {
   
     // 属性
     // 在Scala中，不支持先声明后给值
     // _表示给这个属性默认值
     var name: String = _
     var age: Int = _
     // 常量必须给值，不能使用默认值
     val id:String = "xxx"
   
     // 方法
     def setName(name: String): Unit = this.name = name
   
     def getName = this.name
   
     def setAge(age: Int) = this.age = age
   
     def getAge = this.age
   
   }

2. 如果类中没有属性和函数，那么这个类在定义的时候可以省略{}不写

   class Driver

3. 在Scala中，所有的类默认都是公共的，不需要使用public来修饰。一个scala文件中可以包含多个类

构造器

1. 在Scala中，没有构造函数的说法，取而代之的是构造器。Scala中，构造器可以定义多个，分为主构造器和辅构造器

2. 主构造器的结构

   class 类名(参数列表){ // 主构造器
       类体
   }

3. 如果不指定，那么主构造器默认是无参的

   // 默认无参
   class Person() {}
   // 含参构造
   class Student(var name:String){}

4. 如果需要提供新的构造方式，那么需要通过辅构造器来完成

   class 类名(参数列表){ // 主构造器
       def this(参数列表){} // 辅构造器
   }

5. 辅构造器可以有多个

6. 辅构造器中不能定义类的属性！！！

7. 辅构造器中第一行必须先调用主构造器

   package com.fesco.objectx
   
   object StudentDemo {
   
     def main(args: Array[String]): Unit = {
   
       val s = new Student("David", 15, "fesco")
       println(s.name)
       println(s.school)
       // age不认为是属性，所以s.age是错误的
       s.info()
       val s2 = new Student("Bob", 10, 3)
       println(s2.grade)
     }
   
   }
   
   // 主构造器
   // var和val定义的参数，默认会编译成这个类的属性
   // 没有var和val定义的参数，就是普通变量
   class Student(var name: String, age: Int, val school: String) {
   
     var grade: Int = _
   
     def this(name: String, age: Int, grade: Int) {
       // 辅构造器中第一行必须先调用主构造器，或者调用其他的辅构造器
       this(name, age, "fesco")
       this.grade = grade
     }
   
     def info(): Unit = println(s"name:${this.name}, age:$age, school:${this.school}")
   }

权限控制

1. 在Scala中一共有三种权限：公共（默认，啥也不用写）、protected和private

2. 如果类、属性或者方法之前没有写其他的权限修饰符，那么默认就是公共权限，因此Scala中没有public关键字

3. private和Java一样，修饰的属性和方法只能在本类中使用

4. Scala中的protected比Java中更严格，只能在本类中和子类中使用，同包类和其他类中不能使用

5. 案例

   package com.fesco.objectx
   
   object ControlDemo {
   
   }
   
   // 职业
   class Profession {
   
     // 没有限定就是公共的
     val id: Long = 12865496L
     // 只能在本类和子类中使用
     protected var department: String = _
     // 只能在本类中使用
     private var name: String = _
     // 限定包的范围 - private[包名]
     private[objectx] var address: String = _
   
   }
   
   class Teacher extends Profession {
   
     def info(): Unit = println(s"$id, $department")
   
   }

6. 案例

   package com.fesco.objectx
   
   object RectangleDemo {
   
     def main(args: Array[String]): Unit = {
   
       val r = new Rectangle
       r.height = 5.2
       println(r.height)
       r.width = 4.5
       println(r.width)
       println(r.area)
   
     }
   
   }
   
   class Rectangle {
   
     // 在Scala中，推荐属性使用_开头，和方法做区分
     private var _height: Double = _
     private var _width: Double = _
   
     /*
     def setHeight(height: Double): Unit = this._height = height
     def getHeight: Double = this._height
      */
     def height: Double = _height
   
     def height_=(height: Double): Unit = this._height = height
   
     def width: Double = _width
   
     def width_=(width: Double): Unit = this._width = width
   
     def area: Double = this._height * this._width
   
   }

包

定义

1. 在Scala中，依然是通过package来定义包

   package 包名
   // 例如
   package com.fesco

2. 注意：在Java中，一个.java文件中只能有一个package语句；在Scala中，允许定义多个package语句，根据定义顺序，后定义的包是前边包的子包

   // 方式一：
   package com.fesco.pa
   // 方式二
   package com
   package fesco
   package pa
   // 方式三
   package com.fesco
   package pa
   // 方式四
   package com
   package fesco.pa

3. 为了表示层级关系，还提供了嵌套风格

   package com {
       package fesco {
           package pa{}
       }
   }

4. 注意：在Java中，package语句需要放在.java文件的第一行，Scala中不做要求

   // 如果父包和子包之间没有其他代码，那么不需要写{}
   package com
   package fesco
   // 如果父包和子包之间有其他的代码，那么子包需要写{}
   package com
   class Student{} // Student的全路径名是com.Student
   // fesco是com的子包
   package fesco {
       class Pupil{} // Pupil的全路径名是com.fesco.Pupil
   }
   // test是com的子包
   package test {
       class Junior{} // Junior的全路径名是com.test.Junior
   }

导包

1. 在Scala中，依然是通过import来导入包，但是Scala中，导包语句可以书写在任何地方

   object PackageDemo2 {
   
     def main(args: Array[String]): Unit = {
   
       // 导包语句可以定义在任何位置
       import java.util.ArrayList
       val list = new ArrayList[String]()
   
     }
   
   }

2. 导包的时候，用_表示通配符

   // 导入util包下的所有的类但是不包含子包的类
   import java.util._
   // 导入Collections类中的所有属性和函数
   import java.util.Collections._

3. 如果导入同一个包下的多个类，可以使用{}将类放到同一行上

   import java.util.{List, ArrayList, Map}

4. Scala中，还允许在导包的时候给类来起别名

   import scala.collection.mutable.{Map => MulMap}
   import scala.collection.immutable.{Map => ImMap}
   // 导入java.util包下的所有的类，同时将ArrayList的别名定义为AL
   import java.util.{ArrayList => AL, _}
   // 可以利用这个方式来屏蔽类
   // 表示禁止使用HashMap类
   import java.util.{HashMap => _}
   // 导入java.util包下除了HashMap以外的类
   import java.util.{HashMap => _, _}

5. _root_表示根目录

6. Scala中，默认导入了三个包中的类：java.lang包，scala包，scala.Predef类

包对象(package object)

1. 在Scala中，可以为每一个包来定义一个同名对象，称之为包对象package object

2. 包对象必须和包同名，所以每一个包只能有1个包对象

3. 在包对象中，可以定义属性和方法。在同一个包中的所有的类都可以访问同名包对象中的函数和属性（在com.fesco.objectx.test下的所有类都可访问test包对象）

   package com.fesco.objectx
   package test
   
   // 对象
   object PackageDemo {
   
     def main(args: Array[String]): Unit = {
   
       println(test.add(3, 7))
       println(test.id)
       
     }
   
   }
   
   // 包对象
   package object test {
   
     val id = 5846
   
     def add(x: Int, y: Int): Int = x + y
   
   }

4. 在Scala中，可以将这个包中所有的类共享的属性或者函数定义到包对象中

面向对象的特征

1. 面向对象的特征：封装、继承、多态。Scala作为一门完全面向对象的语言，一定是符合三大特征

2. 封装：Scala中，提供了对象的封装和函数的封装

3. 继承：Scala也是通过extends关键字来完成继承。同样，Scala支持类和类之间的单继承而不是多继承，子类同样可以通过继承来使用父类中的部分方法或者属性

4. 多态：包含了对象的多态(向上造型)和行为的多态(方法的重载和重写)

5. 向上造型：父类声明，子类实现

   package com.fesco.dt
   
   object ExtendsDemo {
   
     def main(args: Array[String]): Unit = {
   
       val s: Student = new Pupil
   
     }
   
   }
   
   class Student
   
   class Pupil extends Student

6. 方法的重写：子类继承父类之后，可以覆盖/重写父类中的方法。在Scala中，需要通过override关键字来明确定义这个函数是重写的

   package com.fesco.dt
   
   object ExtendsDemo {
   
     def main(args: Array[String]): Unit = {
   
       val s: Student = new Pupil
       s.study()
   
     }
   
   }
   
   class Student {
     def study(): Unit = println("studying")
   }
   
   class Pupil extends Student {
     // 明确的使用override来定义
     override def study(): Unit = println("the pupil is studying")
   }

7. 在Scala中，还支持属性的重写。如果父子类中存在同名属性，且该属性用val来定义，那么可以进行属性的重写

   package com.fesco.dt
   
   object ExtendsDemo {
   
     def main(args: Array[String]): Unit = {
   
       val s: Student = new Pupil
       s.study()
       println(s.versionUID)
   
     }
   
   }
   
   class Student {
   
     val versionUID: Long = 54896524L
   
     def study(): Unit = println("studying")
   }
   
   class Pupil extends Student {
   
     // 属性的重写
     // 只有父类中val定义的属性可以在子类中重写
     // 父子类中不允许存在同名的var定义的属性！！！
     override val versionUID: Long = 3248203578L
   
     // 明确的使用override来定义
     override def study(): Unit = println("the pupil is studying")
   }

8. 如果需要判断对象是否是某一个类型，那么可以使用isInstanceOf

   println(s.isInstanceOf[Pupil])

9. 类型转换

   val p = s.asInstanceOf[Pupil]