16_Scala面向对象编程_函数

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")

    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

2.访问伴生对象

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

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

且可以继续简化

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

3.空对象直接用的方法

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

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

重点

//    判断是否是父类实例
    println(user.isInstanceOf[User])

//      将普通对象 转化 目标对象
    val value = user.asInstanceOf[Object]
    println(value)    //_15Scala方法.Solution$User@19bb089b     //至此不能使用user的方法了
1
2
3
4
5
6

4.构造对象

–通过object获取单例对象

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

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

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

–直接new

//    1.2直接new
val user = new User
1
2

–scala独有apply()方式

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

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

最终结果：

–scala有参构造

概念：

scala默认是无参构造

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

//    --有参构造
    val zhangsan = new EMP("sad");
//    val zhangsan1 = new EMP   //构造方式不对

    class EMP(name:String){}
1
2
3
4
5

–scala构造方法两大类

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

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

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

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

使用辅构造如下

class FuGenerate(){
  //定义一下空构造的内容
  println("空构造方法体")

  def this(name:String){
    this()  //必须直接或间接调用主构造方法    FuGenerate()    调用一次执行空构造
    println("辅助构造完成")
  }
}
1
2
3
4
5
6
7
8
9

上述代码主构造为

FuGenerate()

scala中函数就是方法

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

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

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

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

主构造函数属性使用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声明
--可以多个
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

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

Appendix

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

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