当前位置：极客教程 > Scala > Scala教程 > Scala 特质线性化

Scala 特质线性化

Scala 特质线性化

Scala线性化 是一个确定的过程，当创建一个使用不同特质和类的继承来定义的类的对象时，它就会发挥作用。线性化有助于解决钻石问题，当一个类或特质从两个不同的具体类或特质中继承相同的属性时，就会出现钻石问题。

语法:

trait C{}
trait B{}
class A{}
object a_obj= new class A extends B with C
Scala

线性化的结果将如下：-

C-> AnyRef-> Any   
B-> AnyRef-> Any   
A-> AnyRef-> Any    
a_obj-> A-> C-> B-> AnyRef-> Any
Scala

这里 Any 是所有类的超类，也叫顶类。它定义了某些通用方法，如equals、hashCode和toString。 AnyRef 代表引用类。所有非值类型都被定义为引用类型。AnyRef对应的是java.lang.object。每一个Scala trait和类都在线性化层次结构的末端隐式地扩展这些Scala对象。

例子。

// Scala program defining trait A
trait A
{
    def name: String
}
  
// defining trait B inheriting A
trait B extends A
{
    override def name: String ="class b"
}
  
// defining trait C inheriting A
trait C extends A
{
    override def name: String ="class c"
}
  
// defining class D inheriting B and C both
class D extends B with C
{
    override def name: String = super.name
}
  
// Creating object
object GFG
{
    // Main method
    def main(args: Array[String])
    {
        var class_d = new D
          
        // whose property will be inherited
        println(class_d.name)
    }
}
Scala

输出:

class c
Scala

D类的 线性化 遵循黑体箭头。 D类的 继承 遵循浅色箭头。

Scala中的特质线性化

特质线性化和继承图

正如我们在上图中看到的，线性化与继承结构不一样。Scala特质/类是以线性顺序动态放置的，其中线性化将被应用，如下所示。

D-> C-> B-> A-> AnyRef-> Any
Scala

以下是确定线性化的规则

  1. 取第一个 扩展 特质/类，以垂直形式写出其完整的继承层次结构，将此层次结构存储为X。
  2. 在 与 子句之后取下一个特质/类，写出其完整的层次结构，并取消在层次结构X中重复出现的类或特质，将剩余的特质/类添加到层次结构X的前面。
  3. 转到第2步，重复这个过程，直到没有特质/类被遗漏。
  4. 将类本身放在层次结构的前面，作为编写层次结构的头。

让我们来了解一些例子。

例子:

// Scala program for linearization
// defining old_car class
class old_Car
{
    def method: String= "old car "
}
  
// defining new_Car_Designs trait
trait new_Car_Designs extends old_Car
{
    override def method: String ="Designing-> "+ super.method
}
  
// defining new_Car_Part trait
trait new_Car_Part extends old_Car
{
    override def method: String = "Add new part-> "+ super.method
}
  
// defining new_Car_Paint trait
trait new_Car_Paint extends old_Car
{
    override def method: String = "Repainting-> "+ super.method
}
  
// defining new_Car class
class new_Car extends new_Car_Paint with 
new_Car_Part with new_Car_Designs
{
    override def method: String = "new car-> "+ super.method
}
  
// Creating object
object geekforgeeks
{
    // Main method
    def main(args: Array[String])
    {
        // new_Car object
        var car1 = new new_Car
        println(car1.method)
    }
}
Scala

输出:

new car-> Designing-> Add new part-> Repainting-> old car
Scala

例子 :

// Scala program for trait linearization
// defining classes and traits
class flavour 
{
    def make (flavour: String): Unit = 
    {
        println(flavour)
    }
}
  
// defining texture trait
trait texture extends flavour
{
    abstract override def make (flavour : String) 
    {
        super.make(flavour + "texture ")
    }
}
  
// defining cream trait
trait cream extends texture 
{
    abstract override def make (flavour : String)
    {
        super.make(flavour + "with cream ")
    }
}
  
// defining jelly trait
trait jelly extends texture 
{
    abstract override def make (flavour : String)
    {
        super.make(flavour + "with jelly ")
    }
}
// defining cone trait
trait cone extends flavour 
{
    abstract override def make (flavour : String)
    {
        super.make(flavour + "in cone ")
    }
}
  
// creating new ice-cream flovours 
// with above traits and classes
// inheriting different traits and classes
class Myflavour extends flavour with jelly 
{
    override def make (flavour : String) 
    {
        super.make(flavour)
    }
}
class Myflavour2 extends flavour with cream with cone
{
    override def make (flavour : String)
    {
        super.make(flavour)
    } 
}
  
// Creating object
object GFG
{
    // Main method
    def main(args: Array[String])
    {
        // creating new objects
        var icecream1 = new Myflavour
        var icecream2 = new Myflavour2 with jelly
        println(icecream1.make("chocolate "))
        println(icecream2.make("vanilla ")) 
    }
}
Scala

输出:

chocolate with jelly texture 
()
vanilla with jelly in cone with cream texture 
()
Scala

关于线性化的重要观点

  • Scala通过线性化过程解决了特质/类的模糊性。
  • 每当一个新类被实例化时，Scala都会使用线性化。将所有的特质/类形成一个线性顺序，指向相应的超类/特质，从而 使超 方法知道其父方法。
  • 这些超级方法的调用是以一种可堆叠的方式进行的。
  • 线性化可能与继承的混杂物的写法相同，也可能不相同。
  • 当一个类在线性化中已经被隐式继承时，我们不能明确地将其添加到继承中，否则会导致 两次继承的 错误 。
  • 在线性化中没有特质/类是重复的。

Python教程

Python 教程

Python 教程
Tkinter 教程

Tkinter 教程
Pandas 教程

Pandas 教程
NumPy 教程

NumPy 教程
Flask 教程

Flask 教程
Django 教程

Django 教程
PySpark 教程

PySpark 教程
wxPython 教程

wxPython 教程
SymPy 教程

SymPy 教程
Seaborn 教程

Seaborn 教程
SciPy 教程

SciPy 教程
RxPY 教程

RxPY 教程
Pycharm 教程

Pycharm 教程
Pygame 教程

Pygame 教程
PyGTK 教程

PyGTK 教程
PyQt 教程

PyQt 教程
PyQt5 教程

PyQt5 教程
PyTorch 教程

PyTorch 教程
Matplotlib 教程

Matplotlib 教程
Web2py 教程

Web2py 教程
BeautifulSoup 教程

BeautifulSoup 教程

Java教程

Java 教程

Java 教程

Web教程

HTML 教程

HTML 教程
CSS 教程

CSS 教程
CSS3 教程

CSS3 教程
jQuery 教程

jQuery 教程
Ajax 教程

Ajax 教程
AngularJS 教程

AngularJS 教程
TypeScript 教程

TypeScript 教程
WordPress 教程

WordPress 教程
Laravel 教程

Laravel 教程
Next.js 教程

Next.js 教程
PhantomJS 教程

PhantomJS 教程
Three.js 教程

Three.js 教程
Underscore.JS 教程

Underscore.JS 教程
WebGL 教程

WebGL 教程
WebRTC 教程

WebRTC 教程
VueJS 教程

VueJS 教程

数据库教程

SQL 教程

SQL 教程
MySQL 教程

MySQL 教程
MongoDB 教程

MongoDB 教程
PostgreSQL 教程

PostgreSQL 教程
SQLite 教程

SQLite 教程
Redis 教程

Redis 教程
MariaDB 教程

MariaDB 教程

图形图像教程

Vulkan 教程

Vulkan 教程
OpenCV 教程

OpenCV 教程

大数据教程

R语言 教程

R语言 教程

开发工具教程

Git 教程

Git 教程
VSCode 教程

VSCode 教程
Docker 教程

Docker 教程
Gerrit 教程

Gerrit 教程
Excel 教程

Excel 教程

计算机教程

Go语言 教程

Go语言 教程
C++ 教程

C++ 教程

Scala 精品教程

登录

找回密码？

注册