Scala之面向对象（2）

单例对象（伴生对象）：

Scala语言是完全面向对象的语言，所以并没有静态的操作（即在Scala中没有静态的概 念）。但是为了能够和Java语言交互（因为Java中有静态概念），就产生了一种特殊的对象 来模拟类对象，该对象为单例对象。若单例对象名与类名一致，则称该单例对象这个类的伴 生对象，这个类的所有“静态”内容都可以放置在它的伴生对象中声明。

创建对象常用的两种方法：

（1）使用构造器构造（new）

    val person0 = new Person09()

（2）使用静态方法

（在Scala中没有静态方法与之等价的是object---伴生对象）

    val person01: Person09 = Person09.getPerson()

伴生对象的定义：

object Person09{
  def getPerson():Person09=new Person09
}

      方法2主要是在将构造器私有化的时候是无法new的  这时就需要使用伴生对象构造           

class Person09 private{
  val name :String="张三"
}

apply方法：

在Scala中引入了一个apply()方法模板 来替代上述的伴生对象的构造方法 在伴生对象中创建了方法，直接在main方法中调用apply方法即可

apply（）方法在Scala中是做出了改进 在函数进行调用的时候可以不写方法名，直接进行调用

apply方法的调用：

    val person0: Person09 = Person09()

apply方法也是可以进行任意自定义的 没必要一定跟模板一样创建一个对象

特点就是可以不写方法名

直接Person09() 就能调用apply方法

系统在集合当中使用非常广泛，调用对象的apply方法

下边集合 Array就是一个对象 使用.var 自动生成对象 其实是Array集合

    val ints: Array[Int] = Array(1, 2, 3, 4)  

单例模式：

单例模式是确保一个类只有一个实例，即不能随便被创建对象，所以构造方法要使用private进行私有化，不能被外界进行实例化，这个实例是当前类的类成员变量，即类静态成员变量，这个静态变量需要提供给外界，所以需要提供静态方法向外界提供当前实例

单例模式分为两种：

1.懒汉式

占用内存少（减少创建对象的数量），线程不安全（在某个时间段 都进入if判断，都为真，都会赋值产生变量 就会产生线程安全---只会出现在第一次初始化的时候）

  class Singleton09 private{
  }
  object Singleton09{        //相当于静态方法 在静态方法中创建对象 便于外边的访问
    //先声明属性     先声明为null  后边获取的时候再赋值
    private var singleton:Singleton09=null;
    def apply(): Singleton09 = {
              if (singleton==null)
                {
                  singleton = new Singleton09
                }
                  singleton
    }
  }

2.饿汉式：（推荐）

饿汉式没有线程安全问题，写起来简单，占用内存多（提前创建） 它是在伴生对象中先进行创建对象 在jvm中进行类加载，这样就避免了线程安全问题

object Singleton09 {
  private var singleton: Singleton09 = new Singleton09;
  def apply(): Singleton09 = singleton
}

判断单例模式：

  def main(args: Array[String]): Unit = {
    //判断单例模式是否正确
    val singleton:Singleton09=Singleton09();
    val singleton1:Singleton09=Singleton09();
    println(singleton)
    println(singleton1)
  }

可以看到地址值相同

特质（Trait）:

Scala 语言中，采用特质 trait（特征）来代替接口的概念，也就是说，多个类具有相同

的特质（特征）时，就可以将这个特质（特征）独立出来，采用关键字 trait 声明。

Scala 中的 trait 中即可以有抽象属性和方法，也可以有具体的属性和方法，**一个类可 **

以混入（mixin）多个特质。这种感觉类似于 Java 中的抽象类(现在就是接口--->现在的接口是可以有具体的属性和方法)。

一个类具有某种特质（特征），就意味着这个类满足了这个特质（特征）的所有要素，

所以在使用时，也采用了 extends 关键字，如果有多个特质或存在父类，那么需要采用 with

关键字连接。

基本语法：

没有父类：class 类名 extends特质 1 with特质 2 with特质 3 …

有父类：class 类名 extends父类with特质 1 with特质 2 **with **特质 3…

说明

（1）类和特质的关系：使用继承的关系。

（2）当一个类去继承特质时，第一个连接词是 extends，后面是 with。

（3）如果一个类在同时继承特质和父类时，应当把父类写在 extends 后

（4）一个类可以混入多个特质 


（5）所有的Java接口都可以当作Scala的特质进行使用 

  class Person11 extends Young11 with old11 with java.io.Serializable{}

（6）动态混入：可灵活的扩展类的功能

    （6.1）动态混入：创建对象时混入 trait，而无需使类混入该 trait 

    （6.2）如果混入的 trait 中有未实现的方法，则需要实现

    （6.3）如果特质中有抽象的方法和属性也是需要重写的

（7）特质冲突：如果继承的父类和特质中有相同的名称的具体数据（非抽象属性--抽象的可 以重写）会报错冲突

如果属性是val 是可以在类中创建一个新的对象进行赋值改变

如果属性是var 是不可以的 报错误

特质叠加：

    由于一个类可以混入（mixin）多个 trait，且 trait 中可以有具体的属性和方法，若混入 

的特质中具有相同的方法（方法名，参数列表，返回值均相同），必然会出现继承冲突问题。

冲突分为以下两种：

(1)第一种，一个类（Sub）混入的两个 trait（TraitA，TraitB）中具有相同的具体方法，且

两个 trait 之间没有任何关系，解决这类冲突问题，直接在类（Sub）中重写冲突方法。

(2)第二种，一个类（Sub）混入的两个 trait（TraitA，TraitB）中具有相同的具体方法，且

两个 trait 继承自相同的 trait（TraitC），及所谓的“钻石问题”，解决这类冲突问题，Scala

采用了特质叠加的策略。

  钻石问题测试： 

package chapter04
object Test11_TraitMinxin2 {
  def main(args: Array[String]): Unit = {
    val person1 = new Person12
    println(person1.Info())
  }
}
trait Age12{
val age:Int
  def Info()="age "
}
//下边两个特质均继承自Age12
trait Young12 extends Age12{
  override val age: Int = 12
  override def Info(): String = super.Info()+"Young "
}
trait Old12 extends  Age12{
  override val age: Int = 13
  override def Info(): String = super.Info()+"Old12 "
}
//钻石效应
class Person12 extends Young12 with  Old12 {
  override def Info(): String = super.Info()+"Person12 "
}

测试结果：

上述结果说明，在产生钻石问题的时候会按照继承关系进行一个排序来进行调用

当我们如果只想调用某一个类的时候方法的时候，可以对继承的类进行指定

对Person12类进行了修改：

class Person12 extends Young12 with  Old12 {
  override def Info(): String = super[Young12].Info()+"Person12 "
}

执行结果：

特质和抽象类的区别：

1.优先使用特质。一个类扩展（继承）多个特质是很方便的，但却只能扩展一个抽象类。

2.如果你需要构造函数参数，使用抽象类。因为抽象类可以定义带参数的构造函数，

而特质不行（只有无参构造）。

   面向对象的扩展： 
 

   （1）类型检查和转换 
 

   在使用多态的时候，无法调用子类独有的方法，所以需要进行强制类型转换（在Scala中是使用方法进行强制类型转换） 
 

   代码样例： 
 

package chapter04
object Test_14_Rxtends {
  def main(args: Array[String]): Unit = {
//多态
    var son:father14 =new son14
    val son1: son14 = son.asInstanceOf[son14]
    son1.sayHi()
  }
}
class father14{
}
class son14 extends father14 {
def sayHi(): Unit ={
  println("hi son")
}
}