Scala之面向对象 Day -3

发布于：2024-04-19 ⋅ 阅读:(22) ⋅ 点赞:(0)

面向对象

类和对象

  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]

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布