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 ( "娜娜", 20 )
    new ConstructorDemo ( "娜娜", 20, "女" )
    new ConstructorDemo ( "娜娜", 20, "女", "河南" )
  }
}