Scala之面向对象 Day -3

笔记分享2024-04-16 11:41

面向对象

类和对象

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

    scala 复制代码 
    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. 如果类中没有属性和函数，那么这个类在定义的时候可以省略{}不写

    scala 复制代码 
    class Driver

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

构造器

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

  2. 主构造器的结构

    scala 复制代码 
    class 类名(参数列表){ // 主构造器
    类体
}

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

    scala 复制代码 
    // 默认无参
class Person() {}
// 含参构造
class Student(var name:String){}

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

    scala 复制代码 
    class 类名(参数列表){ // 主构造器
    def this(参数列表){} // 辅构造器
}

  5. 辅构造器可以有多个

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

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

    scala 复制代码 
    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. 案例

    scala 复制代码 
    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. 案例

    scala 复制代码 
    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来定义包

    scala 复制代码 
    package 包名
// 例如
package com.fesco

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

    scala 复制代码 
    // 方式一：
package com.fesco.pa
// 方式二
package com
package fesco
package pa
// 方式三
package com.fesco
package pa
// 方式四
package com
package fesco.pa

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

    scala 复制代码 
    package com {
    package fesco {
        package pa{}
    }
}

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

    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中，导包语句可以书写在任何地方

    scala 复制代码 
    object PackageDemo2 {

  def main(args: Array[String]): Unit = {

    // 导包语句可以定义在任何位置
    import java.util.ArrayList
    val list = new ArrayList[String]()

  }

}

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

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

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

    scala 复制代码 
    import java.util.{List, ArrayList, Map}

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

    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包对象）

    scala 复制代码 
    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. 向上造型：父类声明，子类实现

    scala 复制代码 
    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关键字来明确定义这个函数是重写的

    scala 复制代码 
    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来定义，那么可以进行属性的重写

    scala 复制代码 
    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

    scala 复制代码 
    println(s.isInstanceOf[Pupil])

  9. 类型转换

    scala 复制代码 
    val p = s.asInstanceOf[Pupil]
相关推荐
bcbnb2 分钟前
iOS 崩溃日志分析工具全指南，多工具协同构建稳定性分析体系
后端
无限进步_2 分钟前
C语言字符串连接实现详解：掌握自定义strcat函数
c语言·开发语言·c++·后端·算法·visual studio
Han.miracle3 分钟前
Java的多线程——多线程（二）
java·开发语言·线程·多线程
舒一笑4 分钟前
PandaCoder 2.4.3 震撼发布！
后端·程序员·intellij idea
阿登林13 分钟前
Unity3D与Three.js构建3D可视化模型技术对比分析
开发语言·javascript·3d
没有bug.的程序员16 分钟前
Spring Boot 整合第三方组件：Redis、MyBatis、Kafka 实战
java·spring boot·redis·后端·spring·bean·mybatis
tonydf26 分钟前
如何正确统计网络用户数量？别再被连接数和独立IP骗了！
后端·网络协议
清空mega31 分钟前
从零开始搭建 flask 博客（1）实验
后端·python·flask
JohnYan36 分钟前
Bun技术评估 - 20 YAML
后端·代码规范·bun
cherryc_36 分钟前
JavaSE基础——第十二章 集合
java·开发语言
热门推荐
01GitHub 镜像站点02UV安装并设置国内源03BongoCat - 跨平台键盘猫动画工具04GitLab 零基础入门指南：从安装到项目管理全流程05Linux下V2Ray安装配置指南06NVIDIA显卡驱动、CUDA、cuDNN 和 TensorRT 版本匹配指南07Labelme从安装到标注：零基础完整指南08安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）09在VSCode配置Java开发环境的保姆级教程（适配各类AI编程IDE）10jdk21下载、安装（Windows、Linux、macOS）