Scala面向对象编程之对象、Scala中object的作用、Scala中的伴生对象、Scala中的apply方法、Scala中的main方法 10

落日映苍穹つ 2022-01-31 23:41 450阅读 0赞

# 1. Scala中的object #

*  **object相当于class中的单个实例**，通常存放一些一些静态field或者method;
 *  在Scala中没有静态方法和静态字段，但是可以使用**object这个语法结构来达到同样的目的。**
 *  **Scala中object的作用：**
    
     *  存放工具方法和常量
     *  高效共享单个不可变的实例
     *  单例模式
 *  代码如下

import scala.collection.mutable.ArrayBuffer
    
    class Session{ }
    object SessionFactory{ 
    	//该部分相当于java的静态代码块，仅仅执行一次
    	val session = new Session
    	//在object中的方法相当于java中的静态方法
    	def getSession():Session = { 
    		session
    	}
    }
    object SingletonDemo{ 
    	def main(args:Array[String]){ 
    		//单例对象，不需要new,用【单例对象名称.方法】调用对象中的方法
    		val session1 = SessionFactory.getSession()
    		println(session1)
    		//单例对象，不需要new,用【单例对象名称.变量】调用对象中成员变量
    		val session2 = SessionFactory.session
    		println(session2)
    	}
    }

# 2. Scala中的伴生对象 #

*  如果有一个class文件，还有一个与class同名的object文件，那么就称这个object是class的伴生对象，class是object的伴生类；
 *  伴生类和伴生对象必须存放在同一个\*\*.sclala\*\*文件中；
 *  伴生类和伴生对象的最大特点是，可以互相访问；
 *  代码如下

//伴生类
    class Dog{ 
    	val id = 1
    	private var name = "itcast"
    	def printName():Unit = { 
    		//在Dog类中可以访问伴生对象Dog的私有属性
    		println(Dog.CONSTANT+name)
    	}
    }
    //伴生对象
    object Dog{ 
    	//伴生对象中的私有属性
    	private val CONSTANT = "汪汪汪："
    	def main(args:Array[String]){ 
    		val p = new Dog
    		//访问私有字段 name
    		p.name = "123"
    		p.printName()
    	}
    }
    //执行结果 汪汪汪：123

# 3. Scala中的apply方法 #

*  object中非常重要的一个特殊方法，就是apply方法
 *  apply方法通常是在伴生对象中实现的，其目的是，通过伴生类的构造函数功能，来实现伴生对象的构造函数功能；
 *  通常我们会在类的伴生对象中定义apply方法，当遇到\*\*类名(参数1，参数2，…参数n)\*\*时,apply方法会被调用；
 *  在创建伴生对象或者伴生类的对象时，通常不会使用new class的方式，而是直接使用**class()**，隐式的调用半生队形的apply方法，这样会让对象创建的更加简洁；
 *  比方说Array的伴生类对象，就实现了apply()方法，apply()方法内部其实是调用了Array的构造函数，**val array = new Array\[T\](xs.length)**
 *  代码如下

/** * Array类的伴生对象，就实现了可接受变长参数的apply方法 * Array伴生对象中的apply方法，源码如下 */
    // 指定 T 泛型的数据类型，并使用变长参数 xs 接收传参，返回 Array[T] 数组
    // 通过 new 关键字创建 xs.length 长的 Array 数组
    // 其实就是调用Array伴生类的 constructor进行 Array对象的初始化
    // def apply[T: ClassTag](xs: T*): Array[T] = { 
    // val array = new Array[T](xs.length)
    // var i = 0
    // for (x <- xs.iterator) { array(i) = x; i += 1 }
    // array
    // }
    object ApplyDemo{ 
    	def main(args:Array[String]){ 
    		//调用了Array伴生对象的apply方法
    		//def apply(x: Int, xs: Int*): Array[Int]
        	//arr1中只有一个元素5
    		val arr1 = Array(5)
    		//new了一个长度为5的array，数组里面包含5个null
    		var arr2 = new Array(5)
    		println(arr1.toBuffer)
    	}
    }

# 4. Scala中的main方法 #

*  同Java一样，如果要运行一个程序，必须要编写一个包含main方法的类；
 *  在Scala中，也必须要有一个main方法作为入口；
 *  Scala中的main方法定义为**def main(args:Array\[String\])**，而且必须定义在**object**中；
 *  除了自己实现main方法职位，还可以基础App Trait，然后，将需要写在main方法中的运行代码，直接作为object的constructor代码即可，而且还可以使用args接收传入的参数；
 *  代码如下

//1.在object中定义main方法
    object Main_Demo1 { 
      def main(args: Array[String]) { 
        if(args.length > 0){ 
          println("Hello, " + args(0))
        }else{ 
          println("Hello World!")
        }
      }
    }
    //2.使用继承App Trait ,将需要写在 main 方法中运行的代码
    // 直接作为 object 的 constructor 代码即可，
    // 而且还可以使用 args 接收传入的参数。
    
    object Main_Demo2 extends App{ 
        if(args.length > 0){ 
          println("Hello, " + args(0))
        }else{ 
          println("Hello World!")
        }