Scala之面向对象（2）
目录
单例对象（伴生对象）：
创建对象常用的两种方法：
（1）使用构造器构造（new）
（2）使用静态方法
伴生对象的定义：
apply方法：
apply方法的调用：
单例模式：
单例模式分为两种：
1.懒汉式
2.饿汉式：（推荐）
特质（Trait）:
基本语法：
说明
特质叠加：
特质和抽象类的区别：
单例对象（伴生对象）：
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）:
基本语法：
说明
class Person11 extends Young11 with old11 with java.io.Serializable{}
（6）动态混入：可灵活的扩展类的功能
特质叠加：
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 "
}执行结果：
特质和抽象类的区别：
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")
}
}