Scala 之 object 和class

转自：http://blog.csdn.net/jiangpeng59/article/details/48900009

后期我个人会再更加详细的来做讲解。

1.class

Scala的类的java 的类有点不一样，诸如： 声明一个未用priavate修饰的字段 var age，scala编译器会字段帮我们生产一个私有字段和2个公有方法get和set
；若使用了private修饰，则它的方法也将会是私有的。这就是所谓的统一访问原则。

[java]
view plain
copy

//类默认是public级别的  
class Person{  
  var age=18       //字段必须得初始化()  ，hkl：当字段是不初始化的时候就是抽象的字段。
  def Age=age //这个是方法，没有参数可以省略()  
  def incremen(){this.age+=1}  
}  
  
  
class Student{  
  var age=20     //底层编译器会自动为私有的age添加get和set的公有方法,可以理解为伪public类型  
  private[this] var gender="male" //private[this] 只有该类的this可以使用  
  private var name="clow" //声明了private,底层编译器会自动为私有的name添加get和set的私有方法  
  //但是可以自己定义属性方法  
  def getName=this.name  
  def setName(value:String){this.name=value}  
}  
  
//构造器的使用  
class Teacher {  
  var age: Int = _  
  var name: String = _  //可以预留  
  
  //重载的构造器和C#里面的public Teacher(){}类似  
  def this(age: Int, name: String){  
    this()       //必须得调用一次主构造器 
hkl:关于构造器更多的内容自己去了解。分为主构造器和辅助构造器
    this.age=age  
    this.name=name  
  }  
}  

类的构造器细节

[java]
view plain
copy

//1.主构造器在类名后,参数会被声明字段，hkl:说明白点就是参数会成为类的一个属性,若参数没有使用var或者val声明，则会被声明称私有字段  。
//2.实例化类的时候,类中的语句会被执行:println("person")  

class Person(name:String,var age:Int) {  
  println("person")  
  
  def show(): Unit = {  
    println("show.."+name)  
  }  
  
  var gender:String=_  
  
  //次构造器必须调用主构造器,参数不能使用var  
  def this(name:String,age:Int, gender:String){  
    this(name,age)  
    this.gender=gender  
  }  
}  

2.scala没有静态的修饰符，但object下的成员都是静态的 ,若有同名的class,这其作为它的伴生类。在object中一般可以为伴生类做一些初始化等操作,如我们常常使用的val array=Array(1,2,3)  (ps:其使用了apply方法)

hkl:这个object 地位是很关键的。后期会单独拿出来说。

[java]
view plain
copy

object Dog{  
  private var age=0  
  def Age={  
    age+=1  
    age    //省略return
  }  
}  
  
class Dog{  
  var age1=Dog.age //Dog.age是object Dog的私有字段。
}  

hkl:伴生类是可以访问伴生对象里的私有字段的。这一点很吊

3.Apply的使用

hkl:这是一个很重要的函数。

[java]
view plain
copy

class ApplyTest{  
  
  val name="clow";  
  def apply()  {  
    println("class ApplyTest--apply()...");  
  }  
  
}  
  
//object下的成员默认都是静态的  
object ApplyTest{  
  def apply() = {  
    println("object ApplyTest--apply()...");  
    
    new ApplyTest()  //hkl:这里给伴生类做了个初始化，new了一个对象
  }  
}  
  
  
object Basic4 {  
  
  def main(args: Array[String]) {  
    //类名()->调用了对应object下的apply方法  
    var a1=ApplyTest()  
    println(a1.name)  
    //对象名()->调用了对应class的apply方法  
    a1() //输出:class ApplyTest--apply()...  
  }  
}  

Apply怎么用它来实现单例模式

[java]
view plain
copy

class ApplyTest private{  //添加private隐藏构造器  
  def sayHello(){  
    println("hello jop")  
  }  
}  
  
object ApplyTest{  
  var instant:ApplyTest=null  
  def apply() ={  
    if(instant==null) instant=new ApplyTest  
    instant  
  
  }  
}  
  
object ApplyDemo {  
  def main(args:Array[String]){  
      val t=ApplyTest()  
      t.sayHello()  
  }  
}