Scala--静态，接口，特质，嵌套

最新推荐文章于 2021-10-29 17:42:58 发布

风吹我亦散

最新推荐文章于 2021-10-29 17:42:58 发布

阅读量619

点赞数 1

文章标签： scala

本文链接：https://blog.csdn.net/weixin_45468845/article/details/106165822

版权

Scala 专栏收录该内容

23 篇文章 2 订阅

订阅专栏

静态属性和静态方法

思考：有一群小孩子在玩堆雪人，不时有新的小孩加入，请问如何知道现在共有多少人在玩？请使用面向对象的思想编写程序解决问题。

注意，这里是使用面向对象的思想解决问题。我第一眼看题目感觉很容易，觉得定义一个方法，来一个孩子，数量 +1 。
但是这并不是面向对象的思想

Java 中的静态概念

public static 返回值类型 方法名(参数列表){
	方法体
}

说明：Java 中静态方法并不是通过对象调用的，而是通过类对象调用的，所以静态操作并不是面向对象的。

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

1.当在一个文件中，有 class ScalaPerson 和 object ScalaPerson
2.class ScalaPerson 称为伴生类，将非静态内容写到该类中
3.object ScalaPerson 称为伴生对象，将静态内容写到该类中
4.class ScalaPerson 编译后底层生成 ScalaPerson类： ScalaPerson.class
5.object ScalaPerson 编译后底层生成 ScalaPerson$类： ScalaPerson$.class
6.对于伴生对象的内容，我们可以直接通过 ScalaPerson.属性 或者方法

在这里插入图片描述

小结：
1）Scala 中伴生对象采用 object 关键字声明，伴生对象中声明的全是“静态”内容，可以通过伴生对象名称直接调用
2）伴生对象对应的类称之为伴生类，伴生对象的名称应该和伴生类名一致
3）伴生对象中的属性和方法都可以荣光伴生对象名（类名）直接调用访问
4）从语法角度来讲，所谓的伴生对象其实就是类的静态方法和成员的集合
5）从技术角度来讲，Scala 还是没有生成静态的内容，只不过将伴生对象生成了一个新的类，实现属性和方法的调用
6）从底层原理看，伴生对象实现静态特性是依赖于 public static final MODULE$ 实现的
7）伴生对象的声明应该和伴生类的声明在同一个源码文件中（不在同一个就会出错）。但是如果没有伴生类，也就没有所谓的伴生对象，放在哪里都无所谓
8）如果 class A 独立存在，那么 A 就是一个“静态”性质的对象【即类对象】，在 object A 中声明的属性和方法可以通过A.属性和 A.方法来实现调用
9）如果文件中同时存在伴生类和伴生对象，文件图标会变成：

解决小孩堆雪人问题：
在这里插入图片描述

伴生对象中 apply() 方法
在伴生对象中定义 apply 方法，可以实现：类型（参数）方式创建对象实例
在这里插入图片描述
下面这样定义是不可以的
错误提示是：Create ‘apply’ method in object Pig

特质

Java 接口回顾：
声明接口：interface 接口名
实现接口: class 类名 implements 接口名1，接口名2…
富接口：该特质中既有抽象方法，又有非抽方法

1)在Java 中，一个类可以实现多个接口
2)在 Java 中，接口之间支持多继承
3)接口中属性都是常量
4)接口中的方法都是抽象的
5)接口可以对Java 的单继承进行弥补
6)接口能够解耦 //？？？

Scala 接口介绍：
从面向对象看，接口并不属于面向对象的语言，Scala 是纯面向对象的语言，在Scala 中，没有接口

在Scala 中，采用特质 trait （特征）来代替接口的概念
即：多个类具有相同的特征（特质）时，就可以将这个特质（特征）独立出来，采用关键字 trait 声明
理解： trait <=等价于=> interface + abstrct class

Scala 中不叫实现特质，叫继承特质
在这里插入图片描述
trait 的声明：

trait  特质名{//特质名首字母一般大写
	trait 体
}

在Scala 中，Java 的接口都可以当作特质使用

trait 的使用
1）类没有父类

class 类名  extends  特质1  with  特质2  with  特质3 ...

2）类有父类

class 类名  extends  父类  with   特质1  with  特质2  with  特质3 ...

trait 的案例
可以把特质看作是对继承的一种补充
在这里插入图片描述
上面代码的示意图

特质的说明
1）特质可以同时拥有抽象方法和具体方法

当一个trait 有抽象方法和非抽象方法时
trait 在底层对应
Trait.class 接口
还对应 Trait$class.class 这个抽象类

当trait 有接口和抽象类时
class Jack extend Trait 在底层对应
class Jack implements Trait —实现接口
挡在 Jack 类中要使用 Trait 的实现的方法，就通过 Trait$class 调用 —继承抽象类
在这里插入图片描述

2）特质中没有实现的方法就是抽象方法，类通过extends 继承特质，通过 with 继承多个特质

3）所有的 Java 接口都可以当作Scala 特质使用

动态混入

动态混入真正实现了解耦

1）除了可以在类声明时继承特质外，还可以在构建对象时混入特质，扩展目标类的功能

2）此种方式也可以应用于抽象类功能进行扩展

3）动态混入时Scala 特有的方式，Java 中没有动态混入，可在不修改类声明/定义的情况下，扩展类的功能，非常灵活，耦合性低【ocp闭合原则，修改源码关闭，功能扩展开放】

4）动态混入可以在不影响原有的继承关系的基础上，给指定的类扩展功能

5）同时要注意动态混入时，如果抽象类有抽象方法，如何混入
在这里插入图片描述

Scala 种创建对象共有几种方式？

**
1） new 对象
2） apply 创建
3）匿名子类方式
4）动态混入**

叠加特质

构建对象的同时如果混入多个特质，称之为叠加特质
那么特质声明顺序从左到右，方法执行顺序从右到左
注意其中的super 方法
当执行一个动态混入对象的方法时，其执行顺序是从右往左开始执行
当执行到super 时，指的时左边的特质
如果左边没有特质，super 就是父特质
*/
案例

package com.amhu.yx.test1.xh
object TraitTest {
  def main(args: Array[String]): Unit = {
    /*说明：
    1.创建MySQL的实例时，动态的混入 DB 和 File
      创建动态混入对象时，其顺序时怎么样的
      从从往右开始执行
    2.当执行一个动态混入对象的方法时，其执行顺序是怎么样的
      从右往左开始执行
      当执行到super 时，指的时左边的特质
      如果左边没有特质，super 就是父特质
    */
    val mysql = new MySQL with DB with File
    println(mysql)

    mysql.insert(100)
  }
}
trait Operate{
  println("Operate")
  def insert(id: Int)
}
trait Data extends  Operate{
  println("Data")
  //继承的是父特质的抽象方法，可以不加 override
  override def insert(id: Int): Unit = {//实现/重写 insert
    println("插入数据 = " + id)
  }
}
trait DB extends Data{
  println("DB")
  //继承的是父类的普通方法，重写必须加入 override
  override def insert(id: Int)={
    println("向数据库")
    super.insert(id)
  }
}

trait File extends Data{
  println("File")
  override def insert(id: Int): Unit = {
    println("向文件")
    //调用了insert 方法，这里super 在动态混入时，不一定时父类
    super.insert(id)
  }
}
class MySQL{} //普通类

输出结果：
在这里插入图片描述
叠加特质小结：
1）特质声明顺序从左到右，如果有若干个叠加的特质继承自同一父特质，先执行最左边的，再执行右边的，如果左边已经实现了父特质的方法，右边就不会再执行
2）Scala 在执行叠加对象的方法时，会首先从后面的特质（从右向左）开始执行（即先执行有右边特质中的方法，再执行左边特质中的方法）
3）Scala 中特质中如果调用 super ，并不是调用父特质的方法，而是向前面（左边）继续查找特质，若找不到，才回去父特质查找
4）如果想要调用具体特质的方法，可以指定

super[特质].xxx(...)

其中的泛型必须是该特质的直接超类类型
在这里插入图片描述

特质中重写抽象方法特例

再特质中重写抽象方法
理解 abstract override 的小技巧：
可以理解成，当我们给某个方法增加了abstract override 后，就是明确的告诉编译器，该方法确实是重写了父特质的抽象方法，但是重写后，该方法仍然是一个抽象方法（因为没有完全实现，需要其它特质继续实现【通过混入顺序】）
在这里插入图片描述