精华内容
下载资源
问答
  • 伴生对象

    2018-10-11 08:46:40
    与类名相同并且用object修饰的对象叫做伴生对象。 类和其伴生对象之间可以相互访问私有方法和属性。 package test /** * @author: whua * @create: 2018/09/30 11:09 */ class Dog { private var name = &...

    与类名相同并且用object修饰的对象叫做伴生对象

    类和其伴生对象之间可以相互访问私有方法和属性。

    package test
    
    /**
      * @author: whua 
      * @create: 2018/09/30 11:09
      */
    
    class Dog {
      private var name = "二哈"
    
      def printName(): Unit = {
        //在Dog类中访问其伴生对象的私有属性
        println(Dog.CONSTANT + name)
      }
    }
    
    /**
      * 伴生对象
      */
    object Dog {
      private val CONSTANT = "汪汪汪: "
    
      def main(args: Array[String]): Unit = {
        val p = new Dog
    
        //访问Dog类中的私有属性name
        println(p.name)
        p.name = "萨摩"
        println(p.printName())
      }
    }

     

    展开全文
  • Scala 中伴生对象采用 object 关键字声明,伴生对象中声明的全是 "静态"内容,可以通过伴生对象名称直接调用。 伴生对象对应的类称之为伴生类,伴生对象的名称应该和伴生类名一致。 伴生对象中的属性和方法都可以...

    • Scala 中伴生对象采用 object 关键字声明,伴生对象中声明的全是 "静态"内容,可以通过伴生对象名称直接调用。
    • 伴生对象对应的类称之为伴生类,伴生对象的名称应该和伴生类名一致。
    • 伴生对象中的属性和方法都可以通过伴生对象名(类名)直接调用访问
    • 伴生对象的声明应该和伴生类的声明在同一个源码文件中(如果不在同一个文件中会运行错,但是如果没有伴生类,也就没有所谓的伴生对象了,所以放在哪里就无所谓了。

    scala伴生对象 伴生类 声明案例

    package com.xcu.chapter08
    
    object demo01_伴生对象 {
      def main(args: Array[String]): Unit = {
        ScalaPerson.sex
        ScalaPerson.sayhello()
      }
    }
    
    /**
     * 当在同一个文件中,有 class ScalaPerson 和 object ScalaPerson
     * 则class ScalaPerson 称为伴生类,将非静态的内容写到该类中
     * 则object ScalaPerson 称为伴生对象,将静态的内容写入到该类
     * class ScalaPerson 编译后底层生成 ScalaPerson.class
     * object ScalaPerson 编译后底层生成 ScalaPerson$.class
     * 对于伴生对象的内容,我们可以直接通过 ScalaPerson.属性 或者方法
     */
    
    // 伴生类
    class ScalaPerson {
      var name: String = _
    }
    
    // 伴生对象
    object ScalaPerson {
      var sex: String = "男"
    
      def sayhello(): Unit = {
        println("hello scala")
      }
    }
    

    伴生对象-apply 方法

    object demo03_伴生对象_apply方法 {
      def main(args: Array[String]): Unit = {
        // 正常new对象
        val pig1 = new Pig("小花")
        // 使用apply方法来创建对象
        val pig2 = Pig("小黑猪")
        val pig3 = Pig()
      }
    }
    
    //案例演示 apply 方法.
    class Pig(pName: String) {
      var name: String = pName
    }
    
    object Pig {
      def apply(pName: String): Pig = new Pig(pName)
    
      def apply(): Pig = new Pig("匿名猪猪") // 会调用主构造器
    }
    
    
    """
    object Pig {  // 大括弧内如果只有一句话,可以简写成上边的形式
      def apply(): Pig = {
        new Pig("匿名猪猪")
      }
    }
    """
    
    展开全文
  • 伴生类、伴生对象

    2020-10-26 16:51:54
    单例对象称为同名类伴生对象(object) 2、伴生类与伴生对象可相互访问各自私有成员 3、伴生对象可为伴生类增加静态成员 伴生类与伴生对象 案例: 前提:同一个文件的class和object 名字相同 伴生类和伴生对象在同...

    参考博客:https://blog.csdn.net/m0_48758256/article/details/109241456

    伴生(Companion)

    • 1、单例对象与同名类定义在同一文件中时形成绑定关系
      同名类称为单例对象的伴生类(class)
      单例对象称为同名类伴生对象(object)
    • 2、伴生类与伴生对象可相互访问各自私有成员
    • 3、伴生对象可为伴生类增加静态成员

    伴生类与伴生对象

    在这里插入图片描述

    案例:
    前提:同一个文件的class和object 名字相同
    伴生类和伴生对象在同一个文件中,名字相同,class类称为object的伴生类,object称为class的伴生对象

    //伴生类和伴生对象在同一个文件中,名字相同,class类称为object的伴生类,object称为class的伴生对象
    
    //定义伴生类
    class Person(uname:String, uage:Int) {   //Scala主构造函数,主构造函数定义在类的头部
      println("class 进入到Person的class类中")
      var name:String = uname
      var age:Int = uage
      private var address:String = "亚洲"
      
      def this(){  //从构造方法 
        this("xxx",0)
        println("class this() 从构造方法")
      }
      def this(age:Int){
        this("XXX",age)
      }
      def this(name:String){
        this(name,0)
      }
      println("class 变量定义完成,准备定义方法")
      
      //定义伴生类中的方法
      def printMsg(): Unit ={
        println(Person.name+" "+Person.age+" "+address)
        Person.showMsg()
      }
      println("class类一次游,准备离开Person类")
    }
    
    
    //定义伴生对象
    object Person{  //伴生对象  相当于java中的Static
      println("object 进入到Person伴生对象中。。。")
      private val name:String = "中国"
      private val age:Int = 71
      
      //定义apply方法
      def apply(uname: String, uage: Int): Person = new Person(uname, uage)
      def apply(uname: String): Person = new Person(uname)
      def apply(uage: Int): Person = new Person(uage)
      def apply(): Person = new Person()
    
      println("object 变量定义完成,准备定义方法")
      def showMsg():Unit={
        println(Person.name+" "+Person.age)
      }
      
      //定义方法,获得class中的属性
      def showBSClass(p:Person): Unit ={
        println(p.address)
      }
      
      //main方法
      def main(args: Array[String]): Unit = {
        println("object main 进入到main方法中")
        
        //使用object的apply方法新建对象,只能使用class中的属性和方法
        val po1 = Person("zs",21)  //相当于:val person = Person.apply("aa",12)
        val po2 = Person()
        val po3 = Person("kb09")
        val po4 = Person(12)
    
        Person.showBSClass(po1)
    
    	//使用从构造方法
        var p1:Person = new Person()
        var p2:Person = new Person(21)
        var p3:Person = new Person("zhangsan")
     
     	//使用class新建对象,只能使用class中的属性和方法
     	var personNew:Person = new Person("zs",21)
     	//使用object提供的对象,只能使用object中的属性和方法
        var personObj = Person
        personObj.showMsg()
        personNew.printMsg()
      }
      println("object 伴生对象一次游结束")
    }
    

    注:

    • 伴生类中可以在域中直接使用 类名.方法 的方式调用伴生对象中的方法
    • 在main方法中:
      1.使用伴生类直接建立一个实例,属性和方法只能是class域中的
      2.使用伴生对象提供的实例,属性和方法只能是object域中的
      3.伴生对象中定义apply方法可以不使用new新建实例
    展开全文
  • 伴生类和伴生对象

    2019-09-29 09:01:02
    // 伴生对象 object Ass{} // 伴生类 class Ass{} 要求: 伴生类和伴生对象要在同一个.scala文件并且名字相同 Java的静态成员和非静态成员都写在一个类里. 而scala静态成员需要写写在伴生对象里面. 伴生类需要用 ...
    // 伴生对象
    object Ass{}
    
    // 伴生类
    class Ass{}

    要求: 伴生类和伴生对象要在同一个.scala文件并且名字相同

    Java的静态成员和非静态成员都写在一个类里. 而scala静态成员需要写写在伴生对象里面.

    伴生类需要用 new 来创建,而伴生对象不用new.

    使用伴生对象创建伴生类的实例需要定义apply()方法

    package base
    
    
    object runDM {
      def main(args: Array[String]): Unit = {
    
        //    // Array的伴生类和伴生对象
        //    // 伴生类方式创建
        //    val arrC = new Array[Int](5)
        //    // 伴生对象方式创建
        //    val arrO = Array[Int](5)
    
        // new 创建Ass类
        val assC = new Ass("new create!")
        // 使用伴生对象隐式使用apply方法创建 Ass类对象
        val assO = Ass("create!")
    
        println(assC.getName)
        println(assO.getName)
    
      }
    }
    
    // Ass类的伴生对象
    object Ass {
    
      // 静态方法
      def show(): Unit = {
        println("Object Ass!")
      }
    
      // apply方法需要 (), 类似于Ass类的构造器
      def apply(): Ass = new Ass()
    
      def apply(name: String): Ass = new Ass(name)
    
    }
    
    // Ass object的伴生类
    class Ass {
    
      private var name: String = _
    
      def this(name: String) {
        this()
        this.name = name
      }
    
      def getName: String = this.name
    
    }

    转载于:https://www.cnblogs.com/studyNotesSL/p/11443779.html

    展开全文
  • 1、单例对象和伴生对象的关系 scala中的类不能定义静态成员,而代之以定义单例对象来替代。 单例对象通过object关键字来声明。 单例对象中的所有方法,可以直接通过object单例对象的名字直接来调用。 单例对象在第...
  • 单例对象称为同名类伴生对象(object)伴生类与伴生对象可相互访问各自私有成员伴生对象可为伴生类增加静态成员 伴生类与伴生对象 //Student.scala //伴生类 class Student(n: String, a: Int) { private var ...
  • Scala伴生对象

    2021-02-20 17:50:35
    这个Object称为伴生对象,这个class称为伴生类。 伴生对象必须要和伴生类取相同的名字 伴生对象和伴生类在同一个scala源文件中 伴生对象和伴生类可以相互访问private属性 为什么用:在Java中,经常有一些类,...
  • Kotlin伴生对象

    2020-08-05 23:00:17
    Kotlin伴生对象的行为看起来就是Java的static的方法和属性。但它们本质区别还是很大的。 什么是伴生对象呢? 一个在类里面用companion关键字标记的对象声明,这个对象就是伴生对象。 class MyClass { companion ...
  • scala伴生类与伴生对象 伴生对象快速入门的分析: object TestChildGame { def main(args: Array[String]): Unit = { /* *Scala中静态的概念--伴生对象 * Scala语言是完全面向对象的(万物皆对象)语言,...
  • scala 教程 scala 是多范式编程语言。多范式,就是多种编程方法的...伴生类和伴生对象要在同一个源文件中定义,伴生对象和伴生类可以互相访问其私有成员。不与伴生类同名的单例对象称为孤立对象。 scala 对象程序...
  • //伴生类和伴生对象在同一文件中,名字相同 //class类称为object的伴生类,object称为class的伴生对象 class Person(uname:String,uage:Int){ //scala主构造方法,定义在类的头部 println("class 进入到Person的...
  • 特征:一个单例对象未必是一个伴生对象,但是一个伴生对象一定是一个单例对象 与类名相同并且用Object修饰的对象叫做伴生对象,同样类被称为是这个单例对象的伴生类,类和伴生对象之间可以互相访问对方的私有方法和...
  • scala伴生对象

    2020-03-06 17:44:03
    在Scala的类中,与类名相同并且用object修饰的对象叫做伴生对象,类和伴生对象之间可以相互访问私有的方法和属性,他们必须存在同一个源文件中 2.案例详解 package day04 /** * 类名和类文件名称可以不统一 * *...
  • 伴生类和伴生对象应在同一个文件中,名字相同; class类称为object的伴生类,object称为class的伴生对象 实例1: class Person(uname: String,Uage: Int) { println("class 进入到Person的class类中") var name: ...
  • 在Scala中,类和伴生对象可以相互访问private filed 伴生类与伴生对象 /** * 1.伴生类和伴生对象必须存放在一个.scala文件中 * 2.如果有一个class和object同名,那么就称这个object为class的伴生对象,反之class...
  • kotlin伴生对象

    2019-02-16 21:17:44
    使用伴生对象:主要用于与类有紧密联系的变量和函数; 使用@JvmStatic注解:与伴生对象搭配使用,将变量和函数声明为真正的JVM静态成员。 伴生对象 Kotlin中的对象指的是使用object关键字定义的类型声明,一般用作...
  • Scala 027 伴生对象

    2020-03-30 16:07:56
    Scala伴生对象
  • Scala进阶_伴生对象

    2021-01-07 04:33:22
    伴生对象 在Java中,经常会有一些类,同时有实例成员又有静态成员。例如: public class CustomerService { private static String SERVICE_NAME = CustomerService; public void save() { // 保存客户 System....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,451
精华内容 580
关键字:

伴生对象