本次介绍Scala编程的类和对象
- 类的定义
- 构造器
- Object
- 伴生对象
- apply方法
- main方法
Scala中的类
类的定义
/**
* 在Scala中，类并不用声明为public类型的。
* Scala源文件中可以包含多个类，所有这些类都具有共有可见性。
*/
class Person {
//用val修饰的变量是可读属性，有getter但没有setter（相当与Java中用final修饰的变量）
val id="9527"
//用var修饰的变量都既有getter，又有setter
var age:Int=18
//类私有字段，只能在类的内部使用或者伴生对象中访问
private var name : String = "唐伯虎"
//类私有字段，访问权限更加严格的，该字段在当前类中被访问
//在伴生对象里面也不可以访问
private[this] var pet = "小强"
}
//伴生对象（这个名字和类名相同，叫伴生对象）
object Person{
def main(args: Array[String]): Unit = {
val p=new Person
//如果是下面的修改，发现下面有红线，说明val类型的不支持重新赋值，但是可以获取到值
//p.id = "123"
println(p.id)
//打印age
println(p.age)
//打印name,伴生对象中可以在访问private变量
println(p.name)
//由于pet字段用private[this]修饰，伴生对象中访问不到pet变量
//p.pet(访问不到)
}
}
构造器
Scala中的每个类都有主构造器，主构造器的参数直接放置类名后面，与类交织在一起。
注意：主构造器会执行类定义中的所有语句。
class Student(val name : String,val age: Int) {
//主构造器会执行类中所有语句
println("执行主构造器")
private var gender = "play"
//每个辅助构造器必须以其他的辅助构造器或者主构造器的调用开始
def this(name :String,age: Int , gender: String){
this(name,age)
println("辅助构造器")
this.gender = gender
}
}
object Student{
def main(args: Array[String]): Unit = {
//调用主构造器
val stu1 = new Student("zhangsan",18)
//调用辅助构造器
val stu2 = new Student("lisi",30,"female")
}
}
Scala中的类
object
object 相当于 class 的单个实例，通常在里面放一些静态的 field 或者 method；
在Scala中没有静态方法和静态字段，但是可以使用object这个语法结构来达到同样的目的。
object作用：
1.存放工具方法和常量
2.高效共享单个不可变的实例
3.单例模式
举例说明：
object MySessionFactory{
//该部分相当于Java中的静态块
val session = new MySession
//在object中的方法相当于Java中的静态方法
def getSession: MySession ={
session
}
}
object singletonDemo{
def main(args: Array[String]): Unit = {
val session1 = MySessionFactory.getSession
val session2 = MySessionFactory.getSession
//打印结果为ture,说明是单例模式
println(session1 == session2)
}
}
Scala中的伴生对象
- 如果有一个class文件，还有一个与class同名的object文件，那么就称这个object是class的伴生对象，class是object的伴生类；
- 伴生类和伴生对象必须存放在一个.scala文件中；
- 伴生类和伴生对象的最大特点是，可以相互访问；
- 举例说明：
class Dog {
val id =1
private var name = "wangcai"
def printName(): Unit ={
//在Dog类中可以访问半生对象dog的私有属性
println(Dog.Constant + name)
}
}
object Dog{
//半生对象中的私有属性
private val Constant = "wangwangwang"
def main(args: Array[String]): Unit = {
val dog = new Dog
//发明和文明私有的字段name
dog.name = "123"
dog.printName() //执行结果是wangwangwang123
}
}
Scala中的apply方法
- object 中非常重要的一个特殊方法，就是apply方法；
- apply方法通常是在伴生对象中实现的，其目的是，通过伴生类的构造函数功能，来实现伴生对象的构造函数功能；
- 通常我们会在类的伴生对象中定义apply方法，当遇到类名(参数1,…参数n)时apply方法会被调用；
- 在创建伴生对象或伴生类的对象时，通常不会使用new class/class() 的方式，而是直接使用 class()，隐式的调用伴生对象的 apply 方法，这样会让对象创建的更加简洁；
举例说明：
//arr1中只有一个元素5
scala> val arr1 = Array(5)
arr1: Array[Int] = Array(5)
scala> arr1(0)
res0: Int = 5
scala> arr1(1)
java.lang.ArrayIndexOutOfBoundsException: 1
... 32 elided
//创建了一个长度为5的array,数组里面包含5个null
scala> val arr2 = new Array(5)
arr2: Array[Nothing] = Array(null, null, null, null, null)
//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
}
Scala中的main方法
- 同Java一样，如果要运行一个程序，必须要编写一个包含 main 方法的类；
- 在 Scala 中，也必须要有一个 main 方法，作为入口；
- Scala 中的 main 方法定义为 def main(args: Array[String])，而且必须定义在 object 中；
- 除了自己实现 main 方法之外，还可以继承 App Trait，然后，将需要写在 main 方法中运行的代码，直接作为 object 的 constructor 代码即可，而且还可以使用 args 接收传入的参数；
案例说明：
package com.scala.myClass
object Main_Demo1 {
def main(args: Array[String]): Unit = {
if (args.length >0) {
println("hello:"+args(0))
}else{
println("hello world!")
}
}
}
//使用结成app Train，将需要写在main方法中运行的代码
//直接作为object的constructor代码即可
//而且还可以用args接收传入的参数
object Main_Demo2 extends App{
if (args.length >0) {
println("hello:"+args(0))
}else{
println("hello world!")
}
}
本篇结束