scala中的self =>

最新推荐文章于 2022-05-31 08:31:40 发布
最新推荐文章于 2022-05-31 08:31:40 发布
阅读量2.4k 收藏
点赞数 1
CC 4.0 BY-SA版权
分类专栏： scala 文章标签： scala self
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/worldchinalee/article/details/80521381
本文通过一个简单的Scala代码示例介绍了self关键字的作用，并将其与this关键字进行了对比，展示了如何在Scala程序中同时使用这两个关键字。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

self 可以当做是this的别名，我们看下面的代码：

object SelfCase {
  self =>

  val num = 5
  def main(args: Array[String]): Unit = {
    println(this.num)
    println(self.num)
  }

}
运行结果如下：




                

        

    

    
  



    



                



	

		

			

				
					
Scala系列-5、scala中的泛型、actor、akka

				
			

			

				

					不积跬步无以至千里，不积小流无以成江河
				

				

					11-29
					
					637
					
				

			

		

		

			
				
Scala系列-5、scala中的泛型、actor、akka

			
		

	



                

            
              



	

		

			

				
					
6、Scala 中的类型与函数深度解析

					
最新发布

				
			

			

				

					ik678901的博客
				

				

					06-17
					
					13
					
				

			

		

		

			
				
本文深入探讨了 Scala 编程语言中的类型系统与函数特性。内容涵盖类型别名、类型 lambda、幻影类型、自递归类型等高级类型技术，以及函数作为方法、局部函数、闭包、部分应用函数等多种定义方式。文章还介绍了多态函数、高阶函数、递归与尾递归优化、蹦床技术等函数式编程核心概念，并结合面向对象特性解析了函数对象的实现机制。通过这些内容，帮助开发者更好地利用 Scala 的强大类型系统和灵活的函数模型来构建安全、可维护和高效的程序。

			
		

	



              


  
              

                


	

		

			

				
					
第56讲：Scala中Self Types实战详解学习笔记

				
			

			

				

					slq1023的博客
				

				

					09-02
					
					1128
					
				

			

		

		

			
				
第56讲：Scala中Self Types实战详解学习笔记
本讲主要内容：
1. Scala的Self Type解析
2. Self Type代码实战详解
 
class self {
  self =>    //self是this的别名。每一个类本身都有一个this指针指向自己的实例。
             //=>就是把this指针命名了别名。
  val tmp="Sc

			
		

	





	

		

			

				
					
Scala 语法——self =＞

				
			

			

				

					大数据技术分享
				

				

					07-16
					
					489
					
				

			

		

		

			
				
第一种指代thisclass A(name:String){
	self=>
	def  printName()={
		print(self.name)
	}
}


第二种指代this,但是申明类型
此时 self不单指代this，而且表示此类的实例依赖于申明的类型
简单来说就是变相继承了B的意思trail B {
	printB()
}

class A(name:String){
	self: B =>
	def  printName()={
		print(self.name)
	}.

			
		

	



		

			
		



	

		

			

				
					
Scala 入门-自类型（self）

				
			

			

				

					2.wa
				

				

					01-08
					
					1022
					
				

			

		

		

			
				
专栏原创出处：github-源笔记文件  ，github-源码 ，欢迎 Star，转载请附上原文出处链接和本声明。

Scala 编程语言专栏系列笔记，系统性学习可访问个人复盘笔记-技术博客 Scala 编程语言 
什么是自类型
自类型用于声明一个特质必须混入其他特质，该特质不需要直接实现其他特质，但是子类在实现该特质的时候必须混入被声明的特质。


在没有引入其他特质的时候，可以直接使用其他特...

			
		

	





	

		

			

				
					
scala进阶14-自身类型self type

				
			

			

				

					千里冰封
				

				

					08-16
					
					1859
					
				

			

		

		

			
				
/**
  * self不是关键字,是this的别名,具有更强的可读性,无代码中的outer =>
  */
class Self {
  self =>
  val tmp = "Scala"
  def foo = self.tmp + this.tmp //可以用self和this访问自身成员
}

trait S1

/**
  * 高级用法:
  * 1、如下所示,this:S1合在一起

			
		

	





	

		

			

				
					
scala中的self =＞

				
			

			

				

					monkeyboy_tech的博客
				

				

					12-10
					
					545
					
				

			

		

		

			
				
在scala的一些开源项目的源码中总是能看到类似self =>关键字，那这到底代表什么呢？在此，记录一下，仅作为笔记

this 别名
这种相当于给this起了一个别名self,这里的self可以换成其他的你自己喜欢的字符串，看一下spark的源码sparkSession的定义：

class SparkSession private(
    @transient val sparkContext: SparkContext,
    @transient private val existingS

			
		

	





	

		

			

				
					
Scala编程详解 第21讲-Scala编程详解：Actor入门 共8页.pptx

				
			

			

				

					11-25
				

			

		

		

			
				
 case Hangup(from) if from == self => println(s"$name hung up the phone")  }  }  }  }   val caller = new PhoneActor("Alice")  val callee = new PhoneActor("Bob")  caller.start(); callee.start()  caller...

			
		

	





	

		

			

				
					
Spark算子系列第1篇： reduceByKey 和 groupByKey

				
			

			

				

					zhumr的专栏
				

				

					02-08
					
					725
					
				

			

		

		

			
				
第一步：创建RDD


val words = Array("one", "two", "two", "three", "three", "three")
val wordsRDD = sc.parallelize(words).map(word => (word, 1))
wordsRDD.foreach(println)

RDD运行结果如下：


/*
(one,1)
(two,1)
...

			
		

	





	

		

			

				
					
【scala类型系统】this别名（self）、自身类型

				
			

			

				

					檐前潜心学种瓜
				

				

					05-31
					
					396
					
				

			

		

		

			
				
self、自身类型

			
		

	





	

		

			

				
					
【Scala类型系统】自身类型(self type)引用

				
			

			

				

					Jason Ding的专栏
				

				

					03-17
					
					6355
					
				

			

		

		

			
				
定义特质可以要求混入它的类扩展自另一个类型，但是当使用自身类型（self type）的声明来定义特质时（this: ClassName =>），这样的特质只能被混入给定类型的子类当中。 
如果尝试将该特质混入不符合自身类型所要求的类时，就会报错。从技术角度上看，自身类型是在类中提到this时，对于this的假设性类型。从实用角度上看，自身类型指定了对于特质能够混入的具体类的需求。如果你的特质仅用于混

			
		

	





	

		

			

				
					
Scala 自身类型(self-type) 解析

				
			

			

				

					weixin_43527847的博客
				

				

					08-13
					
					1505
					
				

			

		

		

			
				
Scala 自身类型(self-type) 解析



			
		

	





	

		

			

				
					
scala--self type

				
			

			

				

					weixin_43172032的博客
				

				

					07-14
					
					305
					
				

			

		

		

			
				
self type 一，功能二，语法规则
一，功能
声明一个trait混合到另一个trait或class中而不需要直接继承该trait，最常见的用法是将一个大类划分为几个trait。
trait A{
    //statements
}
trait B{
    this: A => //here we can use methods & variables of trait A
}

trait B 没有继承 trait A，但是trait B中可以访问trait A中的成员。
二，语法规

			
		

	





	

		

			

				
					
scala self =＞自身类型简单介绍

				
			

			

				

					杂记
				

				

					04-22
					
					850
					
				

			

		

		

			
				
介绍scala自身类型及self=>常见用法

			
		

	





	

		

			

				
					
自身类型（self type）

				
			

			

				

					
				

				

					07-18
					
					2896
					
				

			

		

		

			
				
看scala的源码的话很发现很多源码开头都有一句：self => 这句相当于给this起了一个别名为selfclass Self {
    self =>   //代表this指针  ，也就是说 self 就 this的别名
    val tmp = "scala"
    def foo = self.tmp + this.tmp
}self不是关键字，可以用除了this外的任何名字命名(除关

			
		

	





	

		

			

				
					
Scala类型 9：自身类型 & this别名

				
			

			

				

					Freecloud
				

				

					02-28
					
					1760
					
				

			

		

		

			
				
自身类型(self type)： 
格式：this: T =>
trait A { 
    this: Exception =>
}this也可替换为self或其它不是关键字的别名。 
 指定可以混入的类的超类。这个特质只能混入给定类型的子类中。 
 注：特质extends一个类时，可以保证其混入的类都是该类的子类；而特质指定自身类型时，可以保证它只能混入该类的子类。class A {
    t

			
		

	





	

		

			

				
					
scala中self type 与 依赖注入

				
			

			

				

					xxx的博客
				

				

					12-22
					
					324
					
				

			

		

		

			
				
准备
1.self type
/**
  *
  * self =>
  * self 并非关键字，你可以用任意其他字符替代
  * self只是给this 关键字起了一个别名
  * @author Yyyyy
  * @version 1.0
  *
  **/

/**
  * 在内部类中的应用
  */
object World extends App {

  //当前对象 thi...

			
		

	





	

		

			

				
					
Scala之自身类型（Self Type）与蛋糕模式（Cake Pattern）

				
			

			

				

					Laurence的技术博客
				

				

					03-07
					
					7403
					
				

			

		

		

			
				
目录设计一辆车
第一版的实现基于继承
第二版的实现基于组合
引入自身类型Self Type
引入蛋糕模式Cake Pattern
利弊得失
本文基于Gregor Heine分享的PPT《Scala Self-Types》注解式地介绍自身引用（Self Type）和蛋糕模式（Cake Pattern），原PPT解释地非常好，感兴趣的朋友可以自行下载阅读。设计一辆车一辆汽车往往会包含这样一些组件：
En

			
		

	





	

		

			

				
					
如何修改scala

				
			

			

				

					06-16
				

			

		

		

			
				
### Scala 中非法循环继承涉及 Iterable 的解决方案

在 Scala 中，`illegal cyclic inheritance involving trait Iterable` 错误通常表明存在循环继承的问题。以下是可能导致此错误的原因及解决方法：

#### 1. 检查类或特质的定义
如果一个类或特质直接或间接地扩展了自身，则会导致循环继承问题。例如：
```scala
trait A extends B[A]
trait B[T] extends A
```
上述代码中，`A` 和 `B` 形成了循环依赖关系，因此会引发编译错误[^2]。

解决方法是重新设计类层次结构，确保没有循环依赖。可以通过引入中间特质或调整泛型参数来解决问题。例如：
```scala
trait A[T]
trait B[T] extends A[B[T]]
```

#### 2. 确保 Scala 和第三方库版本兼容
当使用 Spark 或其他第三方库时，Scala 版本与库版本不匹配可能会导致此类错误。例如，Spark 2.1.1 仅支持 Scala 2.11.x，而使用 Scala 2.13.x 则可能引发兼容性问题[^5]。

解决方法是确保使用的 Scala 版本与第三方库兼容。可以通过以下方式验证和调整版本：
- 在 `build.sbt` 文件中指定正确的 Scala 版本：
```scala
scalaVersion := "2.11.8"
```
- 确保项目中所有依赖项都与指定的 Scala 版本兼容。

#### 3. 避免与标准库冲突
某些情况下，自定义代码可能与 Scala 标准库中的定义发生冲突。例如，重定义 `Iterable` 或其子类型可能会导致意外行为[^4]。

解决方法是避免重定义标准库中的关键类型。如果需要扩展功能，可以考虑使用隐式转换或其他设计模式。例如：
```scala
implicit class EnhancedIterable[A](iterable: Iterable[A]) {
  def customMethod(): Unit = println("Custom method called")
}
```

#### 4. 检查代码中的泛型定义
泛型定义不当也可能导致循环继承问题。例如：
```scala
trait MyIterable[A] extends Iterable[A]
class MyList[A](val elements: Array[A]) extends MyIterable[A] {
  override def iterator: Iterator[A] = elements.iterator
}
```
如果 `MyIterable` 的定义与其他部分存在冲突，则可能导致错误。可以通过调整泛型约束来解决问题。例如：
```scala
trait MyIterable[A] { self: Iterable[A] => }
class MyList[A](val elements: Array[A]) extends Iterable[A] with MyIterable[A] {
  override def iterator: Iterator[A] = elements.iterator
}
```

#### 5. 使用正确的编译器版本
Scala 编译器的不同版本对语法的支持可能存在差异。确保使用的 Scala 编译器版本与项目需求一致。例如，对于 Spark 项目，推荐使用与 Spark 兼容的 Scala 版本（通常是 2.12.x 或 2.13.x）[^5]。

---

### 示例代码修正
假设问题出现在类似以下代码中：
```scala
trait MyIterable[A] extends Iterable[A]
class MyList[A](val elements: Array[A]) extends MyIterable[A] {
  override def iterator: Iterator[A] = elements.iterator
}
```
如果 `MyIterable` 的定义与其他部分存在冲突，可以尝试调整为：
```scala
trait MyIterable[A] { self: Iterable[A] => }
class MyList[A](val elements: Array[A]) extends Iterable[A] with MyIterable[A] {
  override def iterator: Iterator[A] = elements.iterator
}
```

通过这种方式，明确声明 `MyIterable` 是作为 `Iterable[A]` 的扩展，而不是直接继承。

---

### 总结
`illegal cyclic inheritance involving trait Iterable` 错误通常是由于代码中存在循环依赖或非法扩展引起的。解决方法包括检查类或特质的定义、确保 Scala 和第三方库版本兼容、避免与标准库冲突以及使用正确的编译器版本。

---

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

  
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值