Scala之面向对象(2)

这篇具有很好参考价值的文章主要介绍了Scala之面向对象(2)。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

Scala之面向对象(2)

目录

单例对象(伴生对象):

创建对象常用的两种方法:

(1)使用构造器构造(new)

(2)使用静态方法

 伴生对象的定义:

apply方法:

apply方法的调用:

单例模式:

单例模式分为两种:

1.懒汉式

2.饿汉式:(推荐)

特质(Trait):

基本语法:

说明

特质叠加:

特质和抽象类的区别:

单例对象(伴生对象):

Scala语言是完全面向对象的语言,所以并没有静态的操作(即在Scala中没有静态的概 念)。但是为了能够和Java语言交互(因为Java中有静态概念),就产生了一种特殊的对象 来模拟类对象,该对象为单例对象。若单例对象名与类名一致,则称该单例对象这个类的伴 生对象,这个类的所有“静态”内容都可以放置在它的伴生对象中声明。

创建对象常用的两种方法:

(1)使用构造器构造(new)

    val person0 = new Person09()

(2)使用静态方法

(在Scala中没有静态方法与之等价的是object---伴生对象)

    val person01: Person09 = Person09.getPerson()

 伴生对象的定义:

object Person09{
  def getPerson():Person09=new Person09
}

          方法2主要是在将构造器私有化的时候是无法new的  这时就需要使用伴生对象构造           

class Person09 private{
  val name :String="张三"
}

apply方法:

在Scala中引入了一个apply()方法模板  来替代上述的伴生对象的构造方法   在伴生对象中创建了方法,直接在main方法中调用apply方法即可

apply()方法在Scala中是做出了改进 在函数进行调用的时候可以不写方法名,直接进行调用

apply方法的调用:

    val person0: Person09 = Person09()

apply方法也是可以进行任意自定义的  没必要一定跟模板一样创建一个对象

特点就是可以不写方法名

直接Person09() 就能调用apply方法

系统在集合当中使用非常广泛,调用对象的apply方法

下边集合 Array就是一个对象  使用.var 自动生成对象  其实是Array集合

    val ints: Array[Int] = Array(1, 2, 3, 4)  

单例模式:

单例模式是确保一个类只有一个实例,即不能随便被创建对象,所以构造方法要使用private进行私有化,不能被外界进行实例化,这个实例是当前类的类成员变量,即类静态成员变量,这个静态变量需要提供给外界,所以需要提供静态方法向外界提供当前实例

单例模式分为两种:

1.懒汉式

占用内存少(减少创建对象的数量),线程不安全(在某个时间段 都进入if判断,都为真,都会赋值产生变量   就会产生线程安全---只会出现在第一次初始化的时候)

  class Singleton09 private{
  }
  object Singleton09{        //相当于静态方法 在静态方法中创建对象 便于外边的访问
    //先声明属性     先声明为null  后边获取的时候再赋值
    private var singleton:Singleton09=null;
    def apply(): Singleton09 = {
              if (singleton==null)
                {
                  singleton = new Singleton09
                }
                  singleton
    }
  }

2.饿汉式:(推荐)

饿汉式没有线程安全问题,写起来简单,占用内存多(提前创建)   它是在伴生对象中先进行创建对象 在jvm中进行类加载,这样就避免了线程安全问题

object Singleton09 {
  private var singleton: Singleton09 = new Singleton09;
  def apply(): Singleton09 = singleton
}

判断单例模式:

  def main(args: Array[String]): Unit = {
    //判断单例模式是否正确
    val singleton:Singleton09=Singleton09();
    val singleton1:Singleton09=Singleton09();
    println(singleton)
    println(singleton1)
  }

 可以看到地址值相同

Scala之面向对象(2)

特质(Trait):

Scala 语言中,采用特质 trait (特征)来代替接口的概念 ,也就是说,多个类具有相同
的特质(特征)时,就可以将这个特质(特征)独立出来,采用关键字 trait 声明。
Scala 中的 trait 中即 可以有抽象属性和方法,也可以有具体的属性和方法 一个类可
以混入( mixin )多个特质 。这种感觉 类似于 Java 中的抽象类( 现在就是接口--->现在的接口是可以有具体的属性和方法 )。
一个类具有某种特质(特征),就意味着这个类满足了这个特质(特征)的所有要素,
所以在使用时,也采用了 extends 关键字 ,如果有多个特质或存在父类,那么需要采用 with
关键字 连接。

基本语法:

没有父类 class 类名 extends 特质 1 with 特质 2 with 特质 3 …
有父类 class 类名 extends 父类 with 特质 1 with 特质 2 with 特质 3…

说明

1 )类和特质的关系:使用继承的关系。
2 )当一个类去继承特质时,第一个连接词是 extends ,后面是 with
3 )如果一个类在同时继承特质和父类时,应当把父类写在 extends
(4)一个类可以混入多个特质
(5)所有的Java接口都可以当作Scala的特质进行使用
  class Person11 extends Young11 with old11 with java.io.Serializable{}

(6)动态混入:可灵活的扩展类的功能

        (6.1)动态混入:创建对象时混入 trait,而无需使类混入该 trait
        (6.2)如果混入的 trait 中有未实现的方法,则需要实现
        (6.3)如果特质中有抽象的方法和属性也是需要重写的
(7)特质冲突:如果继承的父类和特质中有相同的名称的具体数据(非抽象属性--抽象的可                   以重写)会报错冲突
如果属性是val  是可以在类中创建一个新的对象进行赋值改变 
如果属性是var 是不可以的 报错误

特质叠加:

        
        由于一个类可以混入(mixin )多个 trait ,且 trait 中可以有具体的属性和方法,若混入
的特质中具有相同的方法(方法名,参数列表,返回值均相同),必然会出现继承冲突问题。
冲突分为以下两种:
(1)第一种,一个类( Sub )混入的两个 trait TraitA TraitB )中具有相同的具体方法,且
两个 trait 之间没有任何关系,解决这类冲突问题,直接在类( Sub )中重写冲突方法。
(2)第二种,一个类( Sub )混入的两个 trait TraitA TraitB )中具有相同的具体方法,且
两个 trait 继承自相同的 trait TraitC ),及所谓的“钻石问题”,解决这类冲突问题, Scala
采用了 特质叠加 的策略。
钻石问题测试:
package chapter04
object Test11_TraitMinxin2 {
  def main(args: Array[String]): Unit = {
    val person1 = new Person12
    println(person1.Info())
  }
}
trait Age12{
val age:Int
  def Info()="age "
}
//下边两个特质均继承自Age12
trait Young12 extends Age12{
  override val age: Int = 12
  override def Info(): String = super.Info()+"Young "
}
trait Old12 extends  Age12{
  override val age: Int = 13
  override def Info(): String = super.Info()+"Old12 "
}
//钻石效应
class Person12 extends Young12 with  Old12 {
  override def Info(): String = super.Info()+"Person12 "
}

测试结果:

Scala之面向对象(2)

 上述结果说明,在产生钻石问题的时候会按照继承关系进行一个排序来进行调用

当我们如果只想调用某一个类的时候方法的时候,可以对继承的类进行指定

对Person12类进行了修改:

class Person12 extends Young12 with  Old12 {
  override def Info(): String = super[Young12].Info()+"Person12 "
}

执行结果:

Scala之面向对象(2)文章来源地址https://www.toymoban.com/news/detail-429512.html

特质和抽象类的区别:

1. 优先使用特质。一个类扩展(继承)多个特质是很方便的,但却只能扩展一个抽象类。
2. 如果你需要构造函数参数,使用抽象类。因为抽象类可以定义 带参数 的构造函数,
   而特质不行(只有无参构造)。
面向对象的扩展:
(1)类型检查和转换
在使用多态的时候,无法调用子类独有的方法,所以需要进行强制类型转换(在Scala中是使用方法进行强制类型转换)
代码样例:
package chapter04
object Test_14_Rxtends {
  def main(args: Array[String]): Unit = {
//多态
    var son:father14 =new son14
    val son1: son14 = son.asInstanceOf[son14]
    son1.sayHi()
  }
}
class father14{
}
class son14 extends father14 {
def sayHi(): Unit ={
  println("hi son")
}
}

到了这里,关于Scala之面向对象(2)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 大数据——Scala面向对象

    案例 定义类表示矩形(Rectangle),提供对外获取周长(girth)和面积(area)的函数,并且为这个矩形类提供一个子类表示正方形(Square) 抽象类和抽象方法 在Scala中,依然是通过 abstract 来定义抽象类。不同的地方在于,Scala中不需要使用 abstract 来定义抽象方法;如果一个方法在定义的

    2024年04月27日
    浏览(37)
  • 06-Scala面向对象

    ​ Scala是一门完全面向对象的语言,摒弃了Java中很多不是面向对象的语法。 ​ 虽然如此,但其面向对象思想和 Java的面向对象思想还是一致的 1)基本语法 Scala中基本的package包语法和 Java 完全一致 例如: 2)Scala包的三大作用(和Java一样) 区分相同名字的类 当类很多时,可

    2024年02月07日
    浏览(38)
  • 【Scala】——面向对象

      Scala 有两种包的管理风格。 第一种 Java 的包管理风格相同,每个源文件一个包(包 名和源文件所在路径不要求必须一致),包名用“.”进行分隔以表示包的层级关系,如 com.atguigu.scala。 另一种风格,通过嵌套的风格表示层级关系,一个源文件中可以声明多个 package,子

    2024年01月25日
    浏览(44)
  • Scala(第六章 面向对象)

    1、 Scala的面向对象思想和Java的面向对象思想和概念是一致的。 2、Scala中语法和Java不同,补充了更多的功能。 1)基本语法 1 2)Scala包的三大作用(和Java一样) 1、区分相同名字的类 2、当类很多时,可以很好的管理类 3、控制访问范围 6.1.1 包的命名 1)命名规则 只能包含数

    2024年02月13日
    浏览(48)
  • Scala之面向对象

    目录 Scala包: 基础语法: Scala包的三大作用: 包名的命名规范: 写包的好处: 包对象: 导包说明: 类和对象: 定义类: 封装: 构造器:  主从构造器的加载机制: 继承: 基础语法: 抽象属性: 多态: Java中的多态测试 Scala测试如下: Scala的面向对象思想和Java是一致的

    2023年04月15日
    浏览(33)
  • Scala面向对象编程(高级部分)

    (1)回顾Java中的静态概念 public static 返回值类型 方法名(参数列表) {方法体} 静态属性… 说明: Java中静态方法并不是通过对象调用的,而是通过类对象调用的,所以静态操作并不是面向对象的。 (2)Scala中静态的概念-伴生对象 ①Scala语言是完全面向对象(万物皆对象)的语言

    2024年02月09日
    浏览(52)
  • 面向对象中的单例模式

    设计模式就是前人根据实际的问题提出的问题解决方案,我们把这种就称之为设计模式。 单例模式是一种常见的设计模式! 所谓的设计模式,不是一种新的语法,而是人们在实际的应用中,面对某种特定的情形而设计出来的某种常见的有效的解决方案,所以,设计模式只是

    2024年02月05日
    浏览(47)
  • Python 面向对象之单例模式

    单例模式是一种设计模式,其核心思想是确保一个类只有一个实例,并提供一个全局访问点。 单例模式通常用于管理共享的资源,例如配置信息、数据库连接、线程池等。 关键点在于如何判断这个类是否已经实例化 通过模块导入:借助模块的底层导入原理 通过元类实现:元

    2024年01月25日
    浏览(61)
  • 2023_Spark_实验五:Scala面向对象部分演示(一)(IDEA开发)

    1、面向对象的基本概念 把数据及对数据的操作方法放在一起,作为一个相互依存的整体——对象,面向 对象的三大特征:  封装  继承  多态 2、类的定义 简单类和无参方法 如果要开发main方法,需要将main方法定义在该类的伴生对象中,即:object对 象中,(后续做详细的讨

    2024年02月10日
    浏览(41)
  • 2023_Spark_实验六:Scala面向对象部分演示(二)(IDEA开发)

    7、Scala中的apply方法() 遇到如下形式的表达式时,apply方法就会被调用: Object(参数1,参数2,......,参数N) 通常,这样一个apply方法返回的是伴生类的对象;其作用是为了省略new Object的apply方法举例: 8、Scala中的继承 Scala和Java一样,使用extends扩展类。 案例一:

    2024年02月10日
    浏览(53)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包