16

文章目录

• 1.声明Scala函数
• 2.访问伴生对象
• 3.空对象直接用的方法
• 4.构造对象
• • --通过object获取单例对象
  • --直接new
  • --scala独有apply()方式
  • --scala有参构造
  • --scala构造方法两大类
  • • 使用辅构造如下
    • 上述代码主构造为
    • 辅助构造方法甚至可以多个
    • 多个辅助构造形参内容不能重
    • 不使用辅助构造和使用辅助构造区别
    • 主构造函数属性使用this访问，辅助构造函数属性使用属性名访问
    • 主构造私有化构建对象
    • 小结
    • Appendix

      1.声明Scala函数

      抛出问题：创建两个类，互为伴生对象，当我new时候，然后调用，我调用的是谁？

      object Solution {
        def main(args: Array[String]): Unit = {
          var user=  new User
          user.test()   //class test
        }
        class User{
          def test(): Unit = {
            println("class test")
          }
        }
        object User{
          def test(): Unit = {
            println("object test")
          }
        }
      }
      

      

      2.访问伴生对象

      伴生对象章节已经讲过；伴生对象中放的一般都是静态方法或属性或工具类，访问的话直接 类名.方法即可

      User.test()   //静态方式访问,直接类.方法
      

      且可以继续简化

      User test	  //也就是伴生对象的访问方式
      

      3.空对象直接用的方法

      object类中的方法都可以使用；

      

      scala提供的一些方法都可以使用

      

      重点

      //    判断是否是父类实例
          println(user.isInstanceOf[User])
      //      将普通对象 转化 目标对象
          val value = user.asInstanceOf[Object]
          println(value)    //_15Scala方法.Solution$User@19bb089b     //至此不能使用user的方法了
      

      4.构造对象

      –通过object获取单例对象

      //    1.1直接使用object构建对象
          println(Solution01)   
      

      //_15Scala方法.Solution01$@19bb089b 打印的就是一个对象地址,直接可以拿来使用

      

      反编译以后得到的是静态代码块直接实例化对象且仅有一份，私有化Instance方法，创建一个公共的本类型的私有化对象；通过类名访问；

      –直接new

      //    1.2直接new
      val user = new User
      

      –scala独有apply()方式

      //    1.3Scala独有方式      object伴生对象,且对象中存在apply方法即可使用      繁琐
      val user1 = User.apply() //如果
      

      

      目前我的编译器已经无法动态识别apply()
      不建议使用
      

      

      

      最终结果：

      

      –scala有参构造

      概念：

      scala默认是无参构造

      如果给类传递任何参数，scala会默认抹杀掉任何构造方法仅保留一份构造方法，与类的声明一致；

      //    --有参构造
          val zhangsan = new EMP("sad");
      //    val zhangsan1 = new EMP   //构造方式不对
          class EMP(name:String){}
      

      –scala构造方法两大类

      • 主构造 -> 完成类的初始化

        • 辅助构造有重载概念,主构造没有

        • 辅构造 -> 完成类的辅助功能,属性赋值

          • 辅构造方法必须直接或见解调用主构造方法
          • 使用this声明
          • 辅助构造有重载概念,主构造没有

            使用辅构造如下

            class FuGenerate(){
              //定义一下空构造的内容
              println("空构造方法体")
              def this(name:String){
                this()  //必须直接或间接调用主构造方法    FuGenerate()    调用一次执行空构造
                println("辅助构造完成")
              }
            }
            

            上述代码主构造为

            FuGenerate()

            scala中函数就是方法

            辅助构造方法甚至可以多个

            

            上述第二个辅助构造方法使间接调用主构造器 ，也就是先调用name:String		然后通过第一个辅助构造方法调用this()	主构造方法
            

            多个辅助构造形参内容不能重

            

            不使用辅助构造和使用辅助构造区别

            

            

            主构造函数属性使用this访问，辅助构造函数属性使用属性名访问

            

            主构造函数的形参就是 类的属性；直接拿this关键字访问即可；

            主构造私有化构建对象

            主构造私有化，形参前假如private

            

            一旦私有化，子类无法进行访问，原因是无法显示的调用父类构造器

            私有化后如何创建对象

            –使用辅助构造器

            

            使用辅助构造器，传入name，再将name赋值给主构造

            –使用伴生对象(伴生对象可以访问类中私有内容)

            

            小结

            1.类和伴生对象访问方式	
                    类访问
                    实例化对象user，通过实例化对象访问
                    伴生对象访问
                    直接类名访问
                    
            2.scala函数在编译的时候都会发生改变与定义有所不同，例如eq 编译阶段都会编程equals，但是方法m编译阶段不会发生改变例如equals
            3.scala的构建对象的方式
                --直接new       scala中独有方式  val user = User.apply()
                --反射构建
                --clone
                --反序列化      磁盘中对象写入到内存构建对象
                --scala使用object构建单例对象
                
            4.注意scala中类名和方法名相同但是并不代表其是构造方法;
            5.scala是强数据类型,完全面向函数式编程语言   ==>   声明类 == 声明函数
            6.如果给类传递任何参数，scala会默认抹杀掉任何构造方法仅保留一份构造方法，与类的声明一致；
            7.使用辅助构造使代码更加灵活，形式上和Java一致
            --必须调用主构造，会执行方法体(类中代码语句)所有
            --this声明
            --可以多个
            

            

            类{}包的是函数体，甚至可以直接println，和Java类中五大成分不同。函数体new几次执行几次；

            Appendix

            对象创建在实例化之后会发生如下情况

            

            

            为了避免此情况，请尽可能将类放的远一点，以至于先定义 变量，后实例化对象赋值；