类和对象

类和对象的区别：

1. scala中没有static关键字，所以没有静态类、静态属性、静态方法，都是通过Object来实现的，Object中的成员都是静态的
2. 对于一个class来说，所有的方法和成员变量在市里被new出来之前都无法访问，所以在class中的定义main方法，不是静态的方法，所以无法使用，不能作为程序主入口
3. 用object修饰的对象是单例对象，object 中所有成员变量和方法默认都是 static 的，可以直接访问main方法

类

类的定义

1. 类的对象的别名：变量名称=>，和this相同，都是表示这个类的实例对象

   class Person { outer=>
     val a: Person = this
     val b: Person = outer
   }

2. scala源文件中可以包含多各类，所有的类都具有可见性
3. 在 scala中，类并不用声明为public，class和方法的的默认级别是public
4. 属性的声明：属性的默认级别是private,但同时会默认生成public setter和getter方法，所有用起来像是public
   1. var:会自动生成public的set方法和get方法
   2. val：会自动生成public的get方法

注意：如果var和val用private修饰，则生成私有的getter与setter方法

主从构造器

1. 构造器的分类：主构造器和附属构造器，主构造器只有一个，附属构造器可以有多个
2. 作用：类可以根据传入的参数的不同执行不同的构造器
3. 主构造器：每一个类都有一个主构造器，主构造器的定义与类的定义交织在一起，主构造器的参数直接放置类名后面
   1. 如：class Student(name :String,age:Int) {}
   2. 构造器的参数：Student后面的(name :String,age:Int)就是构造器的参数
   3. 主构造器的范围：{}除了成员属性和成员方法外的代码都是构造器的一部分，调用构造器的时候就会执行
4. 如果没有显示的定义一个主构造器，就会自动生成一个无惨的主构造器
   1. class Student   :没有定义主构造器，会自动生成一个无参的主构造器
5. 辅助构造器：第一行必须调用主构造器或者是已经存在的构造器，所有的的附属构造器底层还是调用主构造器（调用主从构造器用关键字this）
6. 辅助构造器的定义：def this(参数：参数类型) {}来声明这是一个附属构造器，附属构造器的区别就是参数的区别
7. 辅助构造器：是一个特殊的方法,定义在类中，辅助构造器的参数不能和主构造器的参数完全一致（参数个数、类型、顺序）
8. 作用域：辅助构造器作用域是方法中，主构造器的作用域是类中除去成员属性和成员方法之外的所有范围

class ConstructorDemo(name: String) {
  println ( "主构造器" )

  def this(name: String, age: Int) {
    this ( name)  //调用主构造去器
    println ( "第一个辅助构造器" )
  }

  def this(name: String, age: Int, id: Int) {
    this ( name, age)
    println ( "第二个辅助构造器" )
  }
}
object Text {
  def main(args: Array[String]): Unit = {
    new ConstructorDemo ( "Wiki" )
    new ConstructorDemo ( "Wiki", 20 )
    new ConstructorDemo ( "Wiki", 20,12)
  }
}

对象

1. 单实例对象：使用object关键字修饰，默认级别是public
2. 实例对象：new Person()实例对象
3. scala程序都必须从一个对象的main方法开始，可以通过继承APP特质，不用写main方法（APP里面封装了main方法）

   object AppDemo extends App{
     println("hello world")
   }

单例对象

1. Object：object关键字修饰的就是单实例对象，通常在里面放一些静态的field或者method
2. Object不能接受带参数的的构造器,只有在第一次调用Object时会执行构造器，以后调用都不会执行了

object SingleDemo {
  println("对象的主构造器被调用一次")
  var name="娜娜"
  def eat():Unit={
    println(name+"是吃货！")
  }
}
object test1{
  def main(args: Array[String]): Unit = {
    println(SingleDemo.name)
    println("================")
    SingleDemo.eat()
  }
}

伴生对象

1. 伴生对象：是一种特殊的单例对象
2. 伴生对象伴生类：在一个.class文件中，如果对象的名称和类的名称相同，则互称为伴生对象伴生类
3. 特点：类和伴生对象之间可以相互访问私有的方法和属性

class SingleDemo {
  private val  name="Weiking"
  private def say={
    println(name+s"今年${SingleDemo.age}")

  }
}
object SingleDemo{
  private val age=12
  def main(args: Array[String]): Unit = {
    val single = new SingleDemo
    single.say
  }
}

apply方法

1. apply方法通常放在类的半生对象中，并在其中new出半生类的实例对象
2. 作用：创建class的实例对象时，通常就不需要通过new Class()的方式来创建实例对象了，可以直接通过Class的方式来创建实例对象，会隐式的调用伴生对象中的apply方法，会使创建对象更加简洁
3. 一般情况:一个构造方法对应一个apply方法，每一个apply方法中实现一个构造方法
4. 注意：apply方法要加上(),即是没有参数也要加上(),如果不加则该方法永远不会被调用，因为调用的时候Person表示的Person的单实例对象

class Person(name:String){
  def say = println(s"我是$name")
}
object Person{

  def apply(name: String): Person = new Person(name)
//  def apply =  {  val name = "Weiking" ;new Person(name)} 参数和单实例对象一样没有任何参数的则没有任何意义,这个apply方法无法被调用
  def apply() =  {  val name = "Weiking" ;new Person(name)}
}
object test{
  def main(args: Array[String]): Unit = {
    Person("Wiki").say
//    Person.say   报错，这个不会去调用apply这个方法，只会调用Person这个实力对象
    Person().say
  }
}