Sgg：Scala面向对象语法（包的用法）

最新推荐文章于 2021-02-26 12:48:47 发布
最新推荐文章于 2021-02-26 12:48:47 发布
阅读量163 收藏
点赞数
分类专栏： Scala 文章标签： scala
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43123615/article/details/103862831
版权

包的用法

1 属性

1.1 构造器参数

Scala 类的主构造器函数是可以添加参数的。如果参数未用任何修饰符修饰，那么这个参数是局部变量。

class Scala05_Field(name:String = "zhang3",age:Int){
	//此处的 name 未加任何修饰，是局部变量，无法通过对象进行访问
}

object Scala05_Field {
  def main(args: Array[String]): Unit = {
    val fiObj = new Scala05_Field(age = 10)
  }
}

如果参数使用 val 关键字声明，那么 Scala 会将参数作为类的只读属性（不能修改）使用.

class Scala05_Field(val name:String = "zhang3",age:Int){

}

object Scala05_Field {
  def main(args: Array[String]): Unit = {
    val fiObj = new Scala05_Field(age = 10)
    println(fiObj.name) 
    //这里调用对象的 name 属性，其实并不是属性，而是方法，因为方法无参数，所以省略了小括号，感觉和调用属性一样，这体现了 Scala 语言访问一致性
  }
}

运行结果：

zhang3

Process finished with exit code 0
  • 如果参数使用 var 关键字声明，那么那么 Scala 会将参数作为类的成员属性使用,并会提供属性对应的 setter/getter 方法
class Scala05_Field(val name:String = "zhang3",var age:Int){
  @BeanPropertry
}

object Scala05_Field {
  def main(args: Array[String]): Unit = {
    val fiObj = new Scala05_Field(age = 10)
    println(fiObj.name)

    fiObj.age = 20; // setter方法
    println(fiObj.age)  //getter方法
  }
}

1.2 Bean 属性

  • JavaBeans 规范定义了 Java 的属性是像getXXX（）和 setXXX（）的方法。许多 Java工具（框架）都依赖这个命名习惯。为了 Java 的互操作性。将 Scala 字段加@BeanProperty时，这样会自动生成 setter/getter 方法。
package com.nefu.scala.chaptor03

import scala.beans._

/** *******************
 *
 * @auther Dr.Li 
 * @create 2020-01-06 18:38
 * ********************/

/*
如果需要使用Java类型的方法，那么还需要在属性之前用BeanProperty修饰
 */
class Scala05_Field(val name:String = "zhang3",@BeanProperty var age:Int){

}

object Scala05_Field {
  def main(args: Array[String]): Unit = {
    val fiObj = new Scala05_Field(age = 10)
    println(fiObj.name)

    fiObj.age = 20; // setter方法
    println(fiObj.age)  //getter方法

    println(fiObj.getAge)   //Java的get方法。
  }
}

2 包

2.1 包的作用域

在 Java 和 Scala 中管理项目可以使用包结构， C 和 C#使用命名空间。
对于 package，有如下几种形式：

2.1.1 形式体现

package com.nefu.scala.chaptor03

/** *******************
 *
 * @auther Dr.Li 
 * @create 2020-01-06 19:05
 * ********************/
class Scala06_Package {

}

等价于

package com.nefu.scala
package chaptor03

/** *******************
 *
 * @auther Dr.Li 
 * @create 2020-01-06 19:05
 * ********************/
class Scala06_Package {

}

等价于

package com.nefu.scala {
  package chaptor03{
    class Scala06_Package {

    }
  }
}

注： 位于文件顶部不带花括号的包声明在对当前整个文件内的包声明有效。
通过以上形式，总结如下：
1、 包也可以像嵌套类那样嵌套使用（包中有包） 。
2、 作用域原则：可以直接向上访问。即，子包中直接访问父包中的内容。 (即： 作用域)
3、 源文件的目录和包之间并没有强制的关联关系
4、 可以在同一个.scala 文件中，声明多个并列的 package
5、 包名可以相对也可以绝对，比如，访问 BeanProperty 的绝对路径是：
root. scala.beans.BeanProperty

package com.nefu.scala {

  import com.nefu.scala.chaptor03.Scala06_Package
  package chaptor03{

    class Scala06_Package {

    }
    
  }

  object PackageTest{
    def main(args: Array[String]): Unit = {
      //使用这个对象需要导包；作用域问题
      //import com.nefu.scala.chaptor03.Scala06_Package
      val paObj = new Scala06_Package
    }
  }
}

package com.nefu.scala {

  package chaptor03{

    class Scala06_Package {

    }

  }

  object PackageTest{
    def main(args: Array[String]): Unit = {
      //  也可以在声明之前加上包的名
      val paObj = new chaptor03.Scala06_Package
    }
  }
}

package com.nefu.scala {

  package chaptor03{

    class Scala06_Package {

    }

  }

  object PackageTest{
    def main(args: Array[String]): Unit = {
      //  也可以在任何位置导包
      import chaptor03._
      val paObj = new Scala06_Package
    }
  }
}

package com.nefu.scala {

  package chaptor03{

    class Scala06_Package {

    }

  }

  object PackageTest{
    def main(args: Array[String]): Unit = {
      //  也可以在任何位置导包
      import chaptor03._
      val paObj = new Scala06_Package
    }
  }
}

package com.nefu.test{
  //可以多个包并列

  //引用绝对路径
  import _root_. scala.beans.BeanProperty

  class Test111(@BeanProperty val name:String = "abc"){

  }
}

使用方便；

2.2 包对象

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

  package object charter03{
    //每个包都可以有一个包对象。你需要在父包中定义它,且名
    //称与子包一样。
    val name = "zhang3"
    def testFunction(){

    }
  }

  object PackageTest{
    def main(args: Array[String]): Unit = {
      //  也可以在任何位置导包
      import chaptor03._
      val paObj = new Scala06_Package
    }
  }

  package chaptor03{

    class Scala06_Package {

    }

  }

  package object chaptor03{
    //每个包都可以有一个包对象。你需要在父包中定义它,且名
    //称与子包一样。
    val name = "zhang3"
    def testFunction(){
      println("包的函数")
    }
  }

  object PackageTest{
    def main(args: Array[String]): Unit = {
      import com.nefu.scala.chaptor03._
      testFunction()  //调用包的方法
    }
  }

2.3 包可见性

  • 在 Java 中， 访问权限分为种： public, private,protected, 缺省的。在 Scala 中，你可以通过类似的修饰符达到同样的效果。 但是使用上有区别。
  1. 当访问权限缺省时， scala 默认为 public 访问权限。
  2. 私有权限
  3. 受保护权限
  4. 包访问权限
package com.nefu.scala.chaptor04

/** *******************
 *
 * @auther Dr.Li 
 * @create 2020-03-06 10:13
 * ********************/

/*
包的可见性：（权限修饰符）
  [default]<==>public   公开的（任意位置）
  private               私有的
  protected             受保护的(只能在父子类关系中可见)
  private[包路径]        复合的（本类范围和指定包路径可见）
  protected[包路径]      复合的（父子类范围和指定包路径中可见）
 */
object Scala01_Package {
  def main(args: Array[String]): Unit = {
    val sptest = new Scala01_PaTest1()
    println(sptest.name)
    println(sptest.age)
    println(sptest.sex)
  }
}

class Scala01_PaTest1{
  var name = "zhang3"
  private[subpac] var age = 40
  protected[chaptor04] var sex = false
}

class Scala01_SubTest2{
  def test():Unit = {
    val sptest = new Scala01_PaTest1()
    println(sptest.name)
    println(sptest.age)
    println(sptest.sex)
  }
}

package subpac{
  class Scala01_SubTest1 extends Scala01_PaTest1{
    def test():Unit={
      println(name)
      println(age)
      println(sex)
    }
  }
}

2.4 引用

  • 因为 Scala 语言源自于 Java，所以 java.lang 包中的类会自动引入到当前环境中，而 Scala中的 scala 包和 Predef 包的类也会自动引入到当前环境中。如果想要把其他包中的类引入到当前环境中，需要使用 import 语言
  1. 在 Scala 中， import 语句可以出现在任何地方，并不仅限于文件顶部。
    import java.util.HashMap
    /*
    任意位置可以导包
     */
    val map = new util.HashMap()

注： import 语句的效果一直延伸到包含该语句的块末尾

    /*
    Scala中以下三个位置的内容在使用不需要导包;
    scala,java.lang,PreDef
     */
    val str: Integer = 0;
  1. 在 Java 中如果想要导入包中所有的类，可以通过通配符星号， Scala 中采用下划线
class User {
	import scala.beans._ // 这里采用下划线作为通配符
	@BeanProperty var name : String = ""
}
  1. 如果不想要某个包中全部的类，而是其中的几个类，可以采用选取器（大括号）
    import java.util.{HashMap,ArrayList}
    val map2 = new HashMap()

2.5 重命名和隐藏

  • 如果引入的多个包中含有相同的类，那么可以将不需要的类进行重命名进行区分。
    重命名：
    import java.util.{HashMap=>JavaHashMap,ArrayList}
    import scala.collection.immutable.{HashMap=>ScalaHashMap}

    val map2 = new JavaHashMap()
  • 这样一来， JavaHashMap 就是 java.utiI.HashMap，而 HashMap 则对应scala.collection.mutable.HashMap。
    如果某个冲突的类根本就不会用到，那么这个类可以直接隐藏掉。
    import java.util.{HashMap=>_ ,_}
    import scala.collection.mutable._
    
    var map1 = new HashMap()
极度丶浚爱
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
map写法 scala语言_Scala语言
weixin_36050671的博客
01-15 405
Scala中函数是一等公民，可以不依赖对象直接创建函数，Scala将函数式编程和面向对象编程融合在一起。​Scala中将对象属性和对象方法与类属性和类方法进行了分离，Scala中的对象相关属性和方法通过 class关键字定义在对象域中，而类相关的属性和方法通过 object关键字定义在 伴生对象中(Scala中没有 static关键字，伴生对象编译后会生成 原始对象的class文件(类名.clas...
RecommendationSystem_SGG:尚硅谷推荐系统教程课件
03-11
在"RecommendationSystem_SGG"项目中，尚硅谷提供了详细的推荐系统教程，旨在帮助学习者理解和构建自己的推荐系统。 【尚硅谷推荐系统教程】 尚硅谷是一家知名的在线教育平台，其推出的推荐系统教程涵盖了推荐系统...
Scala中包的操作
weixin_42796403的博客
12-15 193
Scala中包的操作 package com.scala.charpter06 class BB{ private[charpter06] val name = "zhangsan" private[charpter06] var age = 20 } object Package_test { /** * 包的命名规则：包名一般使用小写字母， 公司.项目.业务 * 包的好处： * 1.方便管理 * 2.便于区分同名类 * * jav
java map 转换 scala_将java.util.HashMap转换为java中的scala.collection.immutable.Map
weixin_39630140的博客
02-26 1092
完全可以在Java代码中使用JavaConverters – 只需要几个额外的跳转来跳过：import java.util.HashMap;import scala.Predef;import scala.Tuple2;import scala.collection.JavaConverters;import scala.collection.immutable.Map;public class ...
scala 导入 java.util_scala入门 包和引入
weixin_30789297的博客
02-16 612
支持嵌套，下层可以访问上层作用域中的名称可串联顶部标记包对象包可见性包在任何地方都可以引入，作用域至该语句所在块的末尾重命名引入成员(xx => yy)隐藏方法(xx =>_)自动引入(java.lang._ scala._ Predef._)支持嵌套，下层可以访问上层作用域中的名称包可以嵌套，一个包可以定义在多个文件当中，也不需要将源文件和包之间对应起来；packagecom...
Scala基础语法
Winterto1990的博客
08-03 1231
如果你之前是一名 Java 程序员，并了解 Java 语言的基础知识，那么你能很快学会 Scala 的基础语法。 Scala 与 Java 的最大区别是：Scala 语句末尾的分号 ; 是可选的。 我们可以认为 Scala 程序是对象的集合，通过调用彼此的方法来实现消息传递。接下来我们来理解下，类，对象，方法，实例变量的概念： 对象 - 对象有属性和行为。例如：一只狗的状
Sgg：Scala面向对象语法（类&构造器）
qq_43123615的博客
12-19 143
类&构造器1 类2 对象构造器主构造器辅助构造器 Scala 是基于 Java 的语言，所以基本的语法非常的类似，但是， 为了能好的体现，高效，简单，灵活等特性， Scala 语言做了极大的努力。 对 Java 的很多语法进行了改进。 1 类 在 Scala 中，你几乎可以在任何语法结构中内嵌任何语法结构。 如在类中可以再定义一个类，这样的类是嵌套类， 其他语法结构也是一样。嵌套类类...
Sgg:Scala 面向对象编程的基本认知
qq_43123615的博客
11-08 319
1 面向对象编程 Scala是完全面向对象编程的，没有static、接口等概念。 结构化编程是遵循按部就班的解决问题原则，俗称面向过程，先做什么后做什么，而面向对象编程是把一个问题分成多个小问题，把一个系统分成多个不同的组成部分，每个 部分有他自己的功能，最后整合在一起。 面向对象编程中，一切事物皆对象，小到每个元素，大到飞机轮船，完事万物皆对象，不一定是物体，还可以是事件，计划等。 具有相同属性...
Sgg：Scala的基础语法（中）
qq_43123615的博客
12-18 167
Scala的基础语法（中）1 控制结构 1 控制结构 Scala的控制结构基本思想与Java相似，但是语法不同。 if else的语句输出结果还可以单独赋值给一个变量。 val i = 10; val result = if(i > 10){ println("大于10") }else{ println("小于等于10") } ...
项目文档 sgg vue 2022
11-20
在"项目文档 sgg vue 2022"中，我们可以预见到这个项目可能是关于使用Vue.js进行开发的一个实例，其中可能包含了一些特定的sgg（可能代表某种特定的功能或模块）相关的代码和设计。文档可能涵盖了以下关键知识点： ...
mysqlplus文档，sgg
07-24
mysqlplus文档，sgg
sgg-os
03-07
C++是一种强大的、面向对象的编程语言，被广泛用于操作系统开发，因为它能够高效地处理底层资源，同时具备良好的抽象能力和性能。 1. **C++基础**：在"sgg-os"项目中，C++可能被用作主要的编程语言。理解C++的基础...
sgg javase视频
最新发布
07-10
sgg javase视频
Scala面向对象编程练习
qq_43123615的博客
03-09 588
Scala面向对象编程练习1 类2 对象 1 类 编写一个 Time 类，加入只读属性 hours 和 minutes，和一个检查某一时刻是否早于另一时刻的方法 before(other:Time):Boolean。Time 对象应该以 new Time(hrs,min)方式构建。 class Time(val hrs:Int,val min:Int){ val hours = hrs ...
Scala模式匹配的用法
qq_43123615的博客
03-11 522
模式匹配1 switch2 守卫3 模式中的变量 1 switch Scala 中的模式匹配类似于 Java 中的 switch 语法，但是更加强大。 模式匹配语法中， 采用 match 关键字声明， 每个分支采用 case 关键字进行声明，当需要匹配时，会从第一个 case 分支开始，如果匹配成功，那么执行对应的逻辑代码，如果匹配不成功，继续执行下一个分支进行判断。 如果所有 case 都不匹...
Scala 函数式编程中的高阶函数练习
qq_43123615的博客
03-13 506
Scala 函数式编程中的高阶函数练习 编写一个 compose 函数，将两个类型为 Double=>Option[Double]的函数组合在一起，产生另一个同样类型的函数。如果其中一个函数返回 None，则组合函数也应返回 None。例如： def f(x : Double) = if ( x >= 0) Some(sqrt(x)) else None def g(x : Dou...
Sgg:Scala函数式编程的基本认知
qq_43123615的博客
11-08 423
函数式编程 Scala函数式编程相当于面向对象编程的方法封装，是一种“编程范式”，是为了编写程序的方法论。 Scala函数式编程是“结构化编程”的一种，他的思想是把运算过程尽量写成漫画一系列嵌套的函数调用。 函数为了把一些特定功能的代码封装在一个体系之内，方便使用，提高代码的复用性。 函数编程语言的基础是λ-演算。 下面我们尝试在IDEA中进行函数式编程，首先在编程之前我们要进行一定的准备工作，就...
Scala中的Queue&Map&Set&集合操作用法
qq_43123615的博客
03-10 385
集合操作1 队列 Queue1.1 队列的创建1.2 队列元素的追加1.3 向队列中追加 List1.4 按照进入队列的顺序删除元素1.5 塞入数据1.6 返回队列的第一个元素1.7 返回队列最后一个元素1.8 返回除了第一个以外剩余的元素（尾部）2 映射 Map2.1 构造不可变映射2.2 构造可变映射2.3 空的映射2.4 对偶元组（包含键值对的二元组）2.5 取值2.6 遍历 map2.6 ...
PE-Net: 解决SGG偏见问题的紧凑表示与原型引导网络
在"Prototype-based Embedding Network for Scene Graph Generation"这篇论文中，研究者针对场景图生成（Scene Graph Generation, SGG）领域的挑战，提出了一个创新的方法PE-Net。SGG模型通常在处理细粒度谓词时表现...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值