Scala入门系列(7)-Scala之面向对象编程

最新推荐文章于 2023-04-06 15:26:49 发布

云烟成雨TD

最新推荐文章于 2023-04-06 15:26:49 发布

阅读量557

点赞数

分类专栏： # Scala 文章标签：编程语言 java 大数据 scala

本文链接：https://blog.csdn.net/qq_43437874/article/details/113565988

版权

Scala 专栏收录该内容

10 篇文章 3 订阅

订阅专栏

类与对象

Java是面向对象的编程语言，由于历史原因，Java中还存在着非面向对象的内容:基本类型，null，静态方法等。Scala语言来自于Java，所以天生就是面向对象的语言，而且Scala是纯粹的面向对象的语言，即在Scala中，一切皆为对象。

在这里插入图片描述
类和对象的区别和联系：

类是抽象的，概念的，代表一类事物,比如人类,猫类…
对象是具体的，实际的，代表一个具体事物
类是对象的模板，对象是类的一个个体，对应一个实例
Scala中类和对象的区别和联系和 Java是一样的。

定义类

基本语法：

[修饰符] class 类名 { 
类体 
}

注意事项:

scala语法中，类并不声明为public，所有这些类都具有公有可见性(即默认就是public)
一个Scala源文件可以包含多个类
属性是类的一个组成部分，一般是值数据类型,也可是引用类型。

属性/成员变量

注意事项:

属性的定义语法同变量，示例：[访问修饰符] var 属性名称 [：类型] = 属性值
属性的定义类型可以为任意类型，包含值类型或引用类型
Scala中声明一个属性,必须显示的初始化，然后根据初始化数据的类型自动推断，属性类型可以省略(这点和Java不同)。
如果赋值为null,则一定要加类型，因为不加类型, 那么该属性的类型就是Null 类型
如果在定义属性时，暂时不赋值，也可以使用符号_(下划线)，让系统分配默认值. 整数0，浮点0.0，布尔false,引用null。
不同对象的属性是独立，互不影响，一个对象对属性的更改，不影响另外一个,这点和java完全一样

class Cat {
  var name: String = "cat"
  var age: Int = _
  var color: String = _
  var friend: Dog = new Dog()
}

class Dog {
}

创建对象

基本语法:

val | var 对象名 [：类型] = new 类型()

注意事项：

如果我们不希望改变对象的引用(即：内存地址), 应该声明为val 性质的，否则声明为var, scala设计者推荐使用val ,因为一般来说，在程序中，我们只是改变对象属性的值，而不是改变对象的引用。
scala在声明对象变量时，可以根据创建对象的类型自动推断，所以类型声明可以省略，但当类型和后面new 对象类型有继承关系即多态时，就必须写了

方法

Scala中的方法其实就是函数
基本语法：

def 方法名(参数列表) [：返回值类型] = { 方法体 }

调用机制：

当我们scala开始执行时，先在栈区开辟一个main栈。main栈是最后被销毁
当scala程序在执行到一个方法时，总会开一个新的栈。
每个栈是独立的空间，变量（基本数据类型）是独立的，相互不影响（引用类型除外）
当方法执行完毕后，该方法开辟的栈就会被jvm机回收。

构造器

构造器(constructor)又叫构造方法，是类的一种特殊的方法，它的主要作用是完成对新对象的初始化。和Java一样，Scala构造对象也需要调用构造方法，并且可以有任意多个构造方法（即scala中构造器也支持重载）。 Scala类的构造器包括：主构造器和辅助构造器

基本语法：

class 类名(形参列表) { // 主构造器 
	// 类体 
	def this(形参列表) { 
	// 辅助构造器 }
	def this(形参列表) { 
	//辅助构造器可以有多个... 
	} 
}

注意事项:

Scala构造器作用是完成对新对象的初始化，构造器没有返回值。
主构造器的声明直接放置于类名之后
主构造器会执行类定义中的所有语句，这里可以体会到Scala的函数式编程和面向对象编程融合在一起，即：构造器也是方法（函数），传递参数和使用方法和前面的函数部分内容没有区别
如果主构造器无参数，小括号可省略，构建对象时调用的构造方法的小括号也可以省略
辅助构造器名称为this（这个和Java是不一样的），多个辅助构造器通过不同参数列表进行区分，在底层就是f构造器重载。
如果想让主构造器变成私有的，可以在()之前加上private，这样用户只能通过辅助构造器来构造对象了
辅助构造器的声明不能和主构造器的声明一致,会发生错误(即构造器名重复)

object Oop001 {
  def main(args: Array[String]): Unit = {
    val person1: Person = new Person("张三", 18)

  }
}

//private主构造器变成私有
class Person private(name: String, age: Int, sex: Int) { // 主构造器

  def this(name: String, age: Int) { //辅助构造器
    //辅助构造器无论是直接或间接，最终都一定要调用主构造器，执行主构造器的逻辑
    //而且需要放在辅助构造器的第一行[这点和java一样，java中一个构造器要调用同类的其它构造器，也需要放在第
    this(name, age, 1)
    println("辅助构造器")
  }

  println("主构造器")

  def test001(): Unit = {
    println("test001")
  }
}

构造器参数

Scala类的主构造器的形参未用任何修饰符修饰，那么这个参数是局部变量。
如果参数使用val关键字声明，那么Scala会将参数作为类的私有的只读属性使用
如果参数使用var关键字声明，那么那么Scala会将参数作为类的成员属性使用,并会提供属性对应的xxx()[类似getter]/xxx_$eq()[类似setter]方法，即这时的成员属性是私有的，但是可读写。

Bean属性

JavaBeans规范定义了Java的属性是像getXxx（）和setXxx（）的方法。许多 Java工具（框架）都依赖这个命名习惯。为了Java的互操作性。将Scala字段加@BeanProperty时，这样会自动生成规范的 setXxx/getXxx 方法。这时可以使用对象.setXxx() 和对象.getXxx() 来调用属性。给某个属性加入@BeanPropetry注解后，会生成getXXX和setXXX的方法并且对原来底层自动生成类似xxx(),xxx_$eq()方法，没有冲突，二者可以共存。

class Animal {
  @BeanProperty
  var name: String = _
  @BeanProperty
  var age: Int = _
}

对象创建的流程分析

加载类的信息(属性信息，方法信息)
在内存中(堆)开辟空间
使用父类的构造器(主和辅助)进行初始
使用主构造器对属性进行初始化
使用辅助构造器对属性进行初始化
将开辟的对象的地址赋给变量引用

包

和Java一样，Scala中管理项目可以使用包，但Scala中的包的功能更加强大，使用也相对复杂。

基本语法：

package 包名

三大作用：

区分相同名字的类
当类很多时,可以很好的管理类
控制访问范围

命名规则：
只能包含数字、字母、下划线、小圆点.,但不能用数字开头, 也不要使用关键字。

命名规范：
一般是小写字母+小圆点，一般是 com.公司名.项目名.业务模块名

注意事项：

包也可以像嵌套类那样嵌套使用（包中有包），可以在同一个文件中，将类(class / object)、trait 创建在不同的包中，这样就非常灵活了。

在这里插入图片描述

也可以写成多行
作用域原则：可以直接向上访问。即: Scala中子包中直接访问父包中的内容, 大括号体现作用域。 (提示：Java中子包使用父包的类，需要import)。在子包和父包类重名时，默认采用就近原则，如果希望指定使用某个类，则带上包名即可。
父包要访问子包的内容时，需要 import对应的类
包名可以相对也可以绝对，比如，访问BeanProperty的绝对路径是： root. scala.beans.BeanProperty ，在一般情况下：我们使用相对路径来引入包，只有当包名冲突时，使用绝对路径来处理。

包对象

包可以包含类、对象和特质trait（接口），但不能包含函数/方法或变量的定义。这是 Java虚拟机的局限。为了弥补这一点不足，scala提供了包对象的概念来解决这个问题。

基本语法：

package object 包名

注意事项：

包对象中可以定义变量，函数
创建包对象必须和包的名字一致
包对象中的义变量，函数可字节在包中使用

package object Oop004{
  var name:String="张三"
  def test(): Unit ={
    println(" package object Oop004 test ")
  }
}

package Oop004 {

  object Test008{
    def main(args: Array[String]): Unit = {
      println(name)
      test()
    }
  }
}

包对象的底层实现机制:

当创建包对象后，在该包下生成 public final class package 和 public final class package$
通过 package$ 的一个静态实例完成对包对象中的属性和方法的调用。

包的可见性

Java访问修饰符

在这里插入图片描述

Scala中包的可见性

在Java中，访问权限分为: public，private，protected和默认。在Scala中，你可以通过类似的修饰符达到同样的效果。但是使用上有区别。

当属性访问权限为默认时，从底层看属性是private的，但是因为提供了 xxx_$eq()[类似setter]/xxx()[类似getter] 方法，因此从使用效果看是任何地方都可以访问)
当方法访问权限为默认时，默认为public访问权限
private为私有权限，只在类的内部和伴生对象中可用
protected为受保护权限，scala中受保护权限比Java中更严格，只能子类访问，同包无法访问 (编译器)
在scala中没有public关键字,即不能用public显式的修饰属性和方法。
包访问权限（表示属性有了限制。同时包也有了限制），这点和Java不一样，体现出Scala包使用的灵活性。

包的引入

Scala引入包也是使用import, 基本的原理和机制和Java一样，但是Scala中的 import功能更加强大，也更灵活。因为Scala语言源自于Java，所以java.lang包中的类会自动引入到当前环境中，而 Scala中的scala包和Predef包的类也会自动引入到当前环境中，即起其下面的类可以直接使用。如果想要把其他包中的类引入到当前环境中，需要使用import语言。

注意事项：

在Scala中，import语句可以出现在任何地方，并不仅限于文件顶部，import语句的作用一直延伸到包含该语句的块末尾。这种语法的好处是：在需要时在引入包，缩小import 包的作用范围，提高效率。

import scala.List
class Oop005 {

  import scala.beans.BeanProperty
  @BeanProperty
  var name:String="张三"
}

Java中如果想要导入包中所有的类，可以通过通配符*，Scala中采用下 _

import scala.collection._

如果不想要某个包中全部的类，而是其中的几个类，可以采用选取器

import scala.collection.{Searching,GenIterable}

如果引入的多个包中含有相同的类，那么可以将不需要的类进行重命名进行区分，这个就是重命名。

  import java.util.{ HashMap=>JavaHashMap, List}
  var map1 = new JavaHashMap();

如果某个冲突的类根本就不会用到，那么这个类可以直接隐藏掉。

 import java.util.{ HashMap=>_, List}

封装

封装(encapsulation)就是把抽象出的数据和对数据的操作封装在一起,数据被保护在内部,程序的其它部分只有通过被授权的操作(成员方法),才能对数据进行操作。
注意事项:

Scala中为了简化代码的开发，当声明属性时，本身就自动提供了对应setter/getter 方法，如果属性声明为private的，那么自动生成的setter/getter方法也是private的，如果属性省略访问权限修饰符，那么自动生成的setter/getter方法是public的。
因此我们如果只是对一个属性进行简单的set和get ，只要声明一下该属性(属性使用默认访问修饰符) 不用写专门的getset，默认会创建，访问时，直接对象.变量。这样也是为了保持访问一致性
从形式上看 dog.food 直接访问属性，其实底层仍然是访问的方法, 看一下反编译的代码就明白
有了上面的特性，目前很多新的框架，在进行反射时，也支持对属性的直接反射

继承

继承可以解决代码复用,让我们的编程更加靠近人类思维.当多个类存在相同的属性(变量)和方法时,可以从这些类中抽象出父类(比如Student),在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过extends语句来声明继承父类即可。

基本语法：

class 子类名 extends 父类名 { 类体 }

注意事项：

使用继承代码的复用性、代码的扩展性和维护性提高了。
子类继承了所有的属性，只是私有和受保护的属性不能直接访问，需要通过公共的方法去访问。
重写一个非抽象方法需要用override修饰符，调用超类的方法使用super关键字

class Person {
  var name: String = _
  var age: Int = _
  // 私有属性不能访问
  private var test: String = _

  protected var test001: String = _

  def sayHello(): Unit = {
    println("sayHello")
  }

  // 私有方法不能访问
  private def privateSayHello(): Unit = {
    println("privateSayHello")
  }

  // 受保护的方法不能访问
  protected def protectedSayHello(): Unit = {
    println("protectedSayHello")
  }
}

class Student extends Person {
  var className: String = _
  var stuNo: Int = _

  def study(): Unit = {
    println("study")
  }
  // 重写父类方法
  override def sayHello(): Unit ={
    println("重写父类方法")
  }
}

object Oop006 {
  def main(args: Array[String]): Unit = {
    val student = new org.pearl.scala.demo.oop.Student()
    // 父类方法
    student.sayHello()
    // 父类属性
    //println(student.test)
    // student.privateSayHello
    //student.protectedSayHello
    println(student.name)
  }
}

类型检查和转换

要测试某个对象是否属于某个给定的类，可以用 isInstanceOf方法。用asInstanceOf方法将引用转换为子类的引用。classOf获取对象的类名。可以判断传入对象的类型，然后转成对应的子类对象，进行相关操作，这里也体现出多态的特点。

注意事项：

classOf[String]就如同Java的 String.class 。
obj.isInstanceOf[T]就如同Java的obj instanceof T 判断obj是不是T类型。
obj.asInstanceOf[T]就如同Java的(T)obj 将obj强转成T类型。

class Oop008 {
  var name: String = _
  var age: Int = _

  def sayHello: Unit = {
    println("sayHello")
  }
}

class SubOop008 extends Oop008 {

}

object Test008 {
  def main(args: Array[String]): Unit = {
    val oop008 = new SubOop008()
    println(oop008.isInstanceOf[Oop008])
    // 子类转为父类
    val test008: Oop008 = oop008.asInstanceOf[Oop008]
    // 打印类
    val subOop008 = classOf[SubOop008]
    println(subOop008)
    println()
  }
}

超类的构造

在Java中，创建子类对象时，子类的构造器总是去调用一个父类的构造器(显式或者隐式调用)。在Scala中，类有一个主构器和任意数量的辅助构造器，而每个辅助构造器都必须先调用主构造器(也可以是间接调用)。只有主构造器可以调用父类的构造器。辅助构造器不能直接调用父类的构造器。

覆写字段

在Scala中，子类改写父类的字段，我们称为覆写/重写字段。覆写字段需使用 override修饰。在Java中只有方法的重写，没有属性/字段的重写，准确的讲，是隐藏字段代替了重写。

抽象类

在Scala中，通过abstract关键字标记不能被实例化的类。方法不用标记abstract，只要省掉方法体即可。抽象类可以拥有抽象字段，抽象字段/属性就是没有初始值的字段。抽象类的价值更多是在于设计，是设计者设计好后，让子类继承并实现抽象类。
基本语法：

abstract class Person() { 
// 抽象类 
var name: String // 抽象字段, 没有初始化 
def printName // 抽象方法, 没有方法体 
}

注意事项：

抽象类不能被实例
抽象类不一定要包含abstract方法。也就是说,抽象类可以没有abstract方法
一旦类包含了抽象方法或者抽象属性,则这个类必须声明为abstract
抽象方法不能有主体，不允许使用abstract修饰。
如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法和抽象属性，除非它自己也声明为abstract类。【
抽象方法和抽象属性不能使用private、final 来修饰，因为这些关键字都是和重写/实现相违背的。
抽象类中可以有实现的方法.
子类重写抽象方法不需要override，写上也不会错

匿名子类

和Java一样，可以通过包含带有定义或重写的代码块的方式创建一个匿名的子类.

继承层级

在这里插入图片描述

在scala中，所有其他类都是AnyRef的子类，类似Java的Object。
AnyVal和AnyRef都扩展自Any类。Any类是根节点
Any中定义了isInstanceOf、asInstanceOf方法，以及哈希方法等。
Null类型的唯一实例就是null对象。可以将null赋值给任何引用，但不能赋值给值类型的变量[案例演示]。
Nothing类型没有实例。它对于泛型结构是有用处的，举例：空列表Nil的类型是List[Nothing]，它是List[T]的子类型，T可以是任何类。

静态属性和静态方法

Java中静态方法并不是通过对象调用的，而是通过类对象调用的，所以静态操作并不是面向对象的。Scala语言是完全面向对象(万物皆对象)的语言，所以并没有静态的操作 (即在Scala中没有静态的概念)。但是为了能够和Java语言交互(因为Java中有静态概念)，就产生了一种特殊的对象来模拟类对象，我们称之为类的伴生对象。这个类的所有静态内容都可以放置在它的伴生对象中声明和调用。

注意事项：

Scala中伴生对象采用object关键字声明，伴生对象中声明的全是 “静态” 内容，可以通过伴生对象名称直接调用。
伴生对象对应的类称之为伴生类，伴生对象的名称应该和伴生类名一致。
伴生对象中的属性和方法都可以通过伴生对象名(类名)直接调用访问
从语法角度来讲，所谓的伴生对象其实就是类的静态方法和成员的集合
从技术角度来讲，scala还是没有生成静态的内容，只不过是将伴生对象生成了一个新的类，实现属性和方法的调用。
从底层原理看，伴生对象实现静态特性是依赖于 public static final MODULE$ 实现的。伴生对象的声明应该和伴生类的声明在同一个源码文件中(如果不在同一个文件中会运行错误!)，但是如果没有伴生类，也就没有所谓的伴生对象了，所以放在哪里就无所谓了。
如果 class A 独立存在，那么A就是一个类，如果 object A 独立存在，那么A就是一个"静态"性质的对象[即类对象], 在 object A中声明的属性和方法可以通过 A.属性和 A.方法来实现调用当一个文件中，存在伴生类和伴生对象时，文件的图标会发生变化
伴生对象中定义apply方法，可以实现：类名(参数) 方式来创建对象实例

// 伴生类 同一个文件中名字相同的class和object,互为伴生类伴生对象
class Demo001 {
  def test001(): Unit = {
    Demo001.test001()
  }
}

// 伴生对象
object Demo001 {
  def main(args: Array[String]): Unit = {

  }

  def apply(): Demo001 = new Demo001()

  def test001(): Unit = {
    println("test001")
  }
}

trait

从面向对象来看，接口并不属于面向对象的范畴，Scala是纯面向对象的语言，在Scala中，没有接口。 Scala语言中，采用特质trait（特征）来代替接口的概念，也就是说，多个类具有相同的特征（特征）时，就可以将这个特质（特征）独立出来，采用关键字 trait声明。理解trait 等价于(interface + abstract class)。Scala的继承是单继承,也就是一个类最多只能有一个父类,这种单继承的机制可保证类的纯洁性,比c++中的多继承机制简洁。但对子类功能的扩展有一定影响.所以我们认为: Scala引入trait特征第一可以替代Java的接口, 第二个也是对单继承机制的一种补充。

基本语法：

trait 特质名 { trait体 }

注意事项：

Scala提供了特质（trait），特质可以同时拥有抽象方法和具体方法，一个类可以实现/继承多个特质。
特质中没有实现的方法就是抽象方法。类通过extends继承特质，通过with 可以继承多个特质
所有的java接口都可以当做Scala特质使用
和Java中的接口不太一样的是特质中的方法并不一定是抽象的，也可以有非抽象方法(即：实现了的方法)。
除了可以在类声明时继承特质以外，还可以在构建对象时混入特质，扩展目标类的功能
动态混入是Scala特有的方式（java没有动态混入），可在不修改类声明/定义的情况下，扩展类的功能，非常的灵活，耦合性低。
动态混入可以在不影响原有的继承关系的基础上，给指定的类扩展功能。

trait TraitTest01 {
  // 抽象方法
  def test001()
}

trait TraitTest02 {
  // 非抽象方法
  def test002(): Unit = {
    println("test002")
  }
}
trait TraitTest03 {
  // 非抽象方法
  def test003(): Unit = {
    println("test003")
  }
}
// 类通过extends继承特质，通过with 可以继承多个特质,
class ClassTest extends Serializable with TraitTest01 with TraitTest02 {
  override def test001(): Unit = {
    println("实现方法test001")
  }
}

object Test003{
  def main(args: Array[String]): Unit = {
    //特质的动态混入功能，可以在new一个对象的时候with N个特质，就有with的每个特质的已实现方法和已定义的属性
    val classTest = new ClassTest() with TraitTest03
    // 直接调用动态混入的方法
    classTest.test003()
  }
}

叠加特质

构建对象的同时如果混入多个特质，称之为叠加特质，那么特质声明顺序从左到右，方法执行顺序从右到左。

特质声明顺序从左到右。
Scala在执行叠加对象的方法时，会首先从后面的特质(从右向左)开始执行
Scala中特质中如果调用super，并不是表示调用父特质的方法，而是向前面（左边）继续查找特质，如果找不到，才会去父特质查找
如果想要调用具体特质的方法，可以指定：super[特质].xxx(…).其中的泛型必须是该特质的直接超类类型

object TraitTest002 {
  def main(args: Array[String]): Unit = {
    // 叠加特质 混入多个特质
    // 创建动态混入对象，构造器按照叠加顺序从左到右被构造
    val tt = new TT() with T2 with T3 with T1
    // 方法执行按照叠加顺序从右到左被构造
    tt.say11()
  }
}

// 特质1
trait T1 {
  println("T1 ")

  def say11()
}

// 特质2
trait T2 extends T1 {
  println("T2 ")

  override def say11(): Unit = {
    println("T2 say")
  }
}

// 特质3
trait T3 extends T2 {
  println("T3 ")

  override def say11(): Unit = {
    println("T3 say")
  }
}

class TT {

}

在特质中重写抽象方法特例

调用父特质的抽象方法，那么在实际使用时，没有方法的具体实现，无法编译通过，为了避免这种情况的发生。可重写抽象方法，这样在使用时，就必须考虑动态混入的顺序问题。

object TraitTest003 {
  def main(args: Array[String]): Unit = {
    //val ttt = new TTT with TraitTest003Sub // 报错
    val ttt = new TTT with TraitTest003 // 无错
    println("=======")
  }
}

trait TraitTest003 extends TraitTest003Sub {
  override def insert(id: Int) = {
    println("TraitTest003.实现方法。。。。。")
  }
}

trait TraitTest003Base {
  def insert(id: Int)
}

trait TraitTest003Sub extends TraitTest003Base {
  // 当我们给某个方法增加了abstract override 后，就是明确的 告诉编译器，
  // 该方法确实是重写了父特质的抽象方法，但是重写后，
  // 该方法 仍然是一个抽象方法（因为没有完全的实现，需要其它特质继续实现)
  // 重写抽象方法时需要考虑混入特质的顺序问题和完整性问题
  abstract override def insert(id: Int) = {
    println("TraitTest003Sub.insert")
    super.insert(id)
  }
}

class TTT{

}

富接口

即该特质中既有抽象方法，又有非抽象方法, 这种特质叫富接口。

特质中的具体字段

特质中可以定义具体字段，如果初始化了就是具体字段，如果不初始化就是抽象字段。混入该特质的类就具有了该字段，字段不是继承，而是直接加入类，成为自己的字段。特质中未被初始化的字段在具体的子类中必须被重写。

class TraitTest004 extends TraitTest004Base{
  override var name: String = _
}

trait TraitTest004Base {
  var name: String 
}

特质构造顺序

特质也是有构造器的，构造器中的内容由“字段的初始化” 和一些其他语句构成。

扩展类的特质

特质可以继承类，以用来拓展该类的一些功能。所有混入该特质的类，会自动成为那个特质所继承的超类的子类。如果混入该特质的类，已经继承了另一个类(A类)，则要求A类是特质超类的子类，否则就会出现了多继承现象，发生错误。

trait TraitTest004Base extends Exception{
  var name: String
  println(getMessage)
}

嵌套类

在Scala中，你几乎可以在任何语法结构中内嵌任何语法结构。如在类中可以再定义一个类，这样的类是嵌套类，其他语法结构也是一样。嵌套类类似于Java中的内部类。

云烟成雨TD

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录