scala面向对象-类和对象

一、类 对象

一切皆为对象，类是抽象的，对象是具体的，类是对象的模板；

类的定义：

class Student{
   val name :String  = "tom"
}

类前不需要加修饰符
类的变量也不要加修饰符，默认是加private
如果是想增加getter setter ，加注解@BeanProperty
@BeanProperty
val name :String  = "tom"

val cat = new Cat //创建对象

cat.age = 10 //赋值

println(cat.age )   // 10  取值

var age: Int = _    // _ 表示给 age 一个默认的值 ，如果 Int 默认就是 0

var age: String= _    // _ 表示给 age 一个默认的值 ，如果 String默认就是 null

属性和成员变量：

1) [访问修饰符] var 属性名称 [：类型] = 属性值

2) 属性的定义类型可以为任意类型，包含值类型或引用类型

3) Scala 中声明一个属性,必须显示的初始化，然后根据初始化数据的类型自动推断，属性类型可以

省略

4) 如果赋值为 null,则一定要加类型，因为不加类型, 那么该属性的类型就是 Null 类型.

5) 如果在定义属性时，暂时不赋值，也可以使用符号_(下划线)，让系统分配默认值.

var var1 :String = _ // null
var var2 :Byte = _ // 0
var var3 :Double = _ //0.0
var var4 :Boolean = _ //false

创建对象

val | var 对象名 [：类型] = new 类型()

推荐使用 val，只是改变对象属性的值，而不是改变对象的引用；

scala 在声明对象变量时，可以根据创建对象的类型自动推断，所以类型声明可以省略，但当类型和后面 new 对象类型有继承关系即多态时，就必须写了

// emp 类型就是 Emp
val emp = new Emp 
//如果我们希望将子类对象，交给父类的引用，这时就需要写上类型
val emp2: Person = new Emp

二、方法

方法即为函数

三、类和对象实例

四、构造器

scala也支持重载，分为主构造器和辅助构造器

class 类名(形参列表) { // 主构造器
 // 类体
 def this(形参列表) { // 辅助构造器
 }
 def this(形参列表) { //辅助构造器可以有多个...
 }
} 
//1. 辅助构造器 函数的名称 this, 可以有多个，编译器通过不同参数来区分.

def main(args: Array[String]): Unit = {
    //下面这句话就会调用 def this(name:String)
    val p2 = new Person("tom")
    println(p2)
  }

  class Person(inName: String, inAge: Int) {
    var name: String = inName
    var age: Int = inAge
    age += 10
    println("~~~~~~~~~~~~")
    
    override def toString = s"Person(name=$name, age=$age)"
    
    println("ok~~~~~")
    println("age=" + age)
    
    def this(name :String){
      //辅助构造器，必须在第一行显式调用主构造器(可以是直接，也可以是间接)
      this("jack", 10)
      this.name = name //重新赋值
    }
  }

结果：
~~~~~~~~~~~~
ok~~~~~
age=20
Person(name=tom, age=20)

1.构造器的作用是完成对象的初始化

2.主构造器的声明直接放置于类名之后

3.主构造器会执行类定义中的所有语句，这里可以体会到 Scala 的函数式编程和面向对象编程融合在一起，即：构造器也是方法（函数），传递参数和使用方法和前面的函数部分内容没有区别

4.如果主构造器无参数，小括号可省略，构建对象时调用的构造方法的小括号也可以省略

5.辅助构造器名称为 this，多个辅助构造器通过不同参数列表进行区分， 在底层就是 f 构造器重载，辅助构造器无论是直接或间接，最终都一定要调用主构造器，执行主构造器的逻辑，需要放在辅助构造器的第一行

6.如果想让主构造器变成私有的，可以在()之前加上 private，这样用户只能通过辅助构造器来构造对象了，class Person private() {}

7.辅助构造器的声明不能和主构造器的声明一致,会发生错误(即构造器名重复)

五、属性高级知识点补充

1) Scala 类的主构造器的形参未用任何修饰符修饰，那么这个参数是局部变量。

2) 如果参数使用 val 关键字声明，那么 Scala 会将参数作为类的私有的只读属性使用

3) 如果参数使用 var 关键字声明，那么那么 Scala 会将参数作为类的成员属性使用,并会提供属性对应的 xxx()[类似 getter]/xxx_$eq()[类似 setter]方法，即这时的成员属性是私有的，但是可读写。

ef main(args: Array[String]): Unit = {
    val worker = new Worker("smith")
    println(worker.name)
//    println(worker.inName)//不能访问 inName

    val worker2 = new Worker2("smith2")
    println(worker2.inName)//可以访问 inName
    println("*******")

    val worker3 = new Worker3("jack")
    worker3.inName = "mary"
    println(worker3.inName)
  }

  //1. 如果主构造器是 Worker(inName: String) ，那么 inName 就是一个局部变量
  class Worker(inName: String) {
    var name = inName
  }
  //. 如果 主构造器是 Worker2(val inName: String) ，那么 inName 就是 Worker2 的一个 private 的只读属性
  class Worker2(val inName: String) {
    var name = inName
  }
  // 如果主构造器是 Worker3(var inName: String) ，那么 inName 就是 Worker3 的一个
  // 一个 private 的可以读写属性
  class Worker3(var inName: String) {
    var name = inName
  }

结果：
smith
smith2
hello!
mary

给某个属性加入@BeanPropetry 注解后，会生成 getXXX 和 setXXX 的方法

class Car {
 @BeanProperty var name: String = null
}

val car = new Car
car.setName("奔驰")

class Person {
 var age: Short = 90
 var name: String = _
 def this(n: String, a: Int) {
 this()
 this.name = n
 this.age = a
 }}
var p : Person = new Person("小倩",20)


流程分析
1) 加载类的信息(属性信息，方法信息)
2) 在内存中(堆)开辟空间
3) 使用父类的构造器(主和辅助)进行初始
4) 使用主构造器对属性进行初始化 【age:90, naem nul】
5) 使用辅助构造器对属性进行初始化 【 age:20, naem 小倩 】
6) 将开辟的对象的地址赋给 p 这个引用