Scala类和对象

1.面向对象

Scala的类与java、C++的一些比起来更简洁，速度更快

对象：使用object关键字修饰的

类：使用class关键字修饰的new Person()实例对象

new类：类的实例（对象）

1.1.单例对象

（1）scala中没有静态方法和静态字段，没有static

(2) java中，没有关键字修饰的方法,只能用new class()来修饰方法

（3）队友一个class来说，所有的方法和成员变量在市里被new出来之前都无法访问

（4）虽然在class中的定义main方法，可是并没有什么用，按时可以用object达到同样的目的

（5）用object修饰的对象是单例的，成为单例对象，静态对象

（6）单例模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建，这个类提供了一种访问其唯一对象的方式，可以直接访问，不需要实例化该类的对象。注意：1.单例类只能有一个实例 2.单例类必须自己按创建自己的唯一实例 3.单例类必须给其他对象提供这一实例

代码：

object SIngeDemo {
var name="娜娜"
  def eat():Unit={
    println(name+"是吃货！")
  }
}

object test{
  def main(args: Array[String]): Unit = {
    SIngeDemo.eat()
  }
}

1,2.伴生对象

伴生对象是一种特殊的单例对象，是一种相对概念，需要两个条件：

条件1：在同一个源文件中

条件2：对象名和类名相同

这样的单例对象，被称为这个类的伴生对象。类被称为这个实例的单例对象的伴生类。

特点：类和伴生对象之间可以相互访问私有的方法和属性

代码：

class AssociatedDemo {
private val  name="笑笑"
  private def eat():Unit={
    println(name+"是吃货！")
    println(name+"喜欢"+AssociatedDemo.action)
  }
}

object AssociatedDemo{
  private val name="娜娜"
  private val action="跑步"
  def main(args: Array[String]): Unit = {
    val associatedDemo = new AssociatedDemo
     associatedDemo.eat()
  }
}

运行结果：

1.3.apply方法

（1）我们通常会在伴生对象中定义apply方法，当遇到对象名（参数1，。。参数n）时apply方法会被调用

（2）当使用对象（参数列表）时，回去对象中找对应参数的apply方法，如果找到就执行相应的逻辑，如果找不到，就报错

注意：只能找到和参数列表相对应的apply方法

该语法的目的：更方便的完成类或实例对象的初始化方法，赋值等工作，类似于java的方法重载

代码：

//当scala中类或者对象有一个主要用途的时候，apply方法是一个湖人好的语法糖
class Test01(name:String) {

}

object Test01{
  def apply(name: String): Test01 ={
    new Test01 ( name )
  }
}
//定义一个Test01类，并且在这个类中，有一个半生对象Test01,里面定义了apply方法，有了这个apply方法以后，我们在调用这个Test01类的时候，用函数方式来调用
object Client1{
  def main(args: Array[String]): Unit = {
    val stu=Test01("娜娜")
  }
}

总结：

（1）apply方法，是object上的方法

（2）一般情况下，对象没有构造方法，不能加参数

object Test1（name:String）写法错误{

def main(args: Array[String]): Unit = {

Test1// 这是一个对象，对象上不能有参数

Test1(a:Int) // 添加参数之后，就报错了(错误的写法)

}

}

（3）但是，如果对象（参数列表），实际上调用的是对象上的apply方法，具体会根据参数列表的个数、参数的类型去找对象上对应的apply方法，如果没有找到就会报错。返回值取决于apply的返回类型

（4）apply方法相当于java中的方法重载，可以定义多个apply方法，具体的参数类型，参数个数，以及返回值都是可以自定义。

1.4.unapply方法

unapply方法是接受一个对象，从对象中提取相应的值。主要用于模式匹配

代码：

class Money(val price:Double,val name:String) {

}

object Money{
  def apply(price: Double, name: String): Money = new Money ( price, name )

  def unapply(money: Money): Option[(Double, String)] = {
    if (money==null){
      None
    }else{
      Some(money.price,money.name)
    }
  }
}

object Client2{
  def main(args: Array[String]): Unit = {
    val ap=Money(11.2,"书")
    ap match {
      case Money(num,"书")=>println(num)
      case _=>println("宝宝不开心！")
    }

  }
}

结果：

1.5.应用程序对象

scala程序都必须从一个对象的main方法开始，可以通过继承APP特质，不用写main方法（APP里面封装了main方法）

object AppDemo extends App{
 println("I love you ")
}

2.类

2.1.类的定义

（1）在 scala中，类并不用生命为public

(2) scala源文件中可以包含多各类，所有的类都具有可见性

（3）var修饰的变量，这个变量对外提供了get set方法

（4）val修饰的变量，是只读属性，对外提供了get方法，没有set方法（相当于java中的final变量）

2.2.构造器

scala构造器分为两类：主构造器（只能有一个），辅助构造器（可以有多个）

（1）主构造器直接在类名后面定义，每个类都有主构造器，主构造器的参数直接放置雷鸣后面，与类交织在一起

class test(val name:String,var age:Int)

(2)如果没有定义构造器，类会有一个默认的空参构造器

（3）辅助函数的定义，使用dfs this关键字，而且必须调用主构造器，或者其他构造器

注意：主构造器会执行类定义中的所有语句

代码：

class ConstructorDemo(val name: String, var age: Int) {

  println ( "主构造器运行了。。。" )

  //辅助构造器必须定义在类中(主和辅参数不能一样)
  def this(name: String, age: Int, sex: String) {
    this ( name, age )
    println ( "第一个辅助构造器运行了。。。。" )
  }

  def this(name: String, age: Int, sex: String, address: String) {
    this ( name, age, sex )
    println ( "第二个辅助构造器运行了。。。。" )
  }
}

object Text {
  def main(args: Array[String]): Unit = {
    new ConstructorDemo ( "娜娜",  )
    new ConstructorDemo ( "娜娜", , "女" )
    new ConstructorDemo ( "娜娜", , "女", "河南" )
  }
}

总结：

1.有两类构造器，主构造器和付构造器

2.构造器定义的位置，主构造器和类交织在一起，class ConstructorDemo(val name: String, var age: Int)

3.辅助构造器是一个特殊的方法，定义在类中 def this(name: String, age: Int, sex: String, address: String)

4.辅助构造器，第一行必须是主构造器（或者其他构造器）

5.辅助构造器的参数不能和主构造器的参数完全一致（参数个数、类型、顺序）

6.可以定义空参的辅助构造器，但是主构造器参数必须进行初始化赋值

7.作用域：辅助构造器的作用于，只在方法中，主构造的作用于是类中除去成员属性和成员方法之外的所有范围（可以通过反编译查看源码）

2.3.访问权限

成员变量的访问权限

1.默认权限是public,任何地方都可以访问

2.prive作用域（用于类的内部和伴生对象中）

3.private[this],作用域在当前类中，伴生对象无效

方法的访问权限

1.通用于主构造器，辅助构造器，以及普通方法

2.默认权限是共有的

3.private作用域为类和其伴生对象

4. private [this] ，作用域为当前类中，伴生对象中无效

类的访问权限：

1.默认： 共有的

2. private private[this] 在当前包及其子包范围内有效，其他地方无效

3. private [包名] 在指定包及其子包访问内有效 其他地方无效