Scala(三)：类

类：Class
    1.简单类和无参方法
    2.带getter和setter属性
    3.只带getter属性
    4.对象私有字段
    5.Bean属性
    6.辅助构造器
    7.主构造器
    8.嵌套类

1.简单类和无参方法
 Scala中的简单类和Java中很相似

class ClassOps{
  private var value = 0 //你必须初始化字段

  def  increment(){value += 1} //方法默认是公有的

  def current() = value

}
/*
   *在Scala中类并不声明为public，，Scala源文件包括多个类，所以这些类都具有公共可见性
   * 使用该类需要做的就是构造对象并按照通常的方式调用方法
   */

object Class {
  def main(args: Array[String]): Unit = {
    val myCounter = new ClassOps
    myCounter.increment()
    println(myCounter.current)//此处调用无参构造时，()可加也可不加

  }
}

2.带getter和setter属性

/**
 *public class Person{
 *     public Int age  //Java中并不推荐这样使用
 *     private String name
 *     public String getName(){return name;}
 *     public void setName(String name){this.name=name}
 *}
 * 像这样一对getter/setter通常叫做属性(property)
 * Scala中对每个字段都给生成getter/setter方法，不过我们可以控制这个过程
 *    如果字段私有，则getter/setter也是私有的
 *    如果字段被val修饰，那么只有getter生成
 *    如果你不需要getter/setter，那么可以将字段声明为private[this]
 */
//Scala中每个字段都提供getter和setter方法
class Person{
 // var age = 0
  /*
   *Scala生成面向JVM的类，其中有一个私有字段age字段和相应的getter/setter方法，
   *在Scala中此处，getter和setter分别为age和age_=
   */
  //重写getter和setter
  private var privateAge = 0 //变成私有并改名
  def age = privateAge       //getter

  def age_(newValue : Int ){ //setter方法
    if(newValue > privateAge) privateAge = newValue
  }
}
object Person{
  def main(args: Array[String]): Unit = {
    val p = new Person
    println(p.age)

    p.age_(40)
    println(p.age)   //打印结果：40
    p.age_(30)
    println(p.age)   //打印结果：40
  }
}

3.对象私有字段

 在Scala中，方法可以访问该类的所有对象的私有字段

class atm{
  private var momey = 0
  def drawMoney(){momey += 1}
  def spendMoney(other : atm) = momey < other.momey
  //之所以访问other.money是合法的是因为other也是atm对象
  //Scala允许我们定义更加严格的访问限制，通过private[this]
  private[this] var foods = null //在这对象.value行不通
  //类私有字段，Scala会生成私有getter/setter，但是对象私有的字段不会生成
  //private[类名]，这样的只有指定类才能访问

}

4.Bean属性

  当你将Scala字段标注为@BeanProperty时，会自动生成四个方法

import scala.reflect.BeanProperty
class superMan{

  @BeanProperty var name : String  = _

}
/*
 *将会生成如下四个方法：
 * name :String
 * name_=(newValue:String):Unit
 * getName():String
 * setName(newValue:String):Unit
 */

5.辅助构造器

 Scala中有主构造器和辅助构造器
 辅助构造器和Java中的构造器很相似，只有两处不同
  1.辅助构造器名称是this，Java中构造器名和类名相同
  2.每一个辅助构造器必须以一个先前已定义的其他辅助构造器或主构造器的调用开始

class SuperWoman{
    private var name = ""
    private var age = 0

    def this(name:String ) {
      this()    //调用主构造器
      this.name=name
    }
    def this(name :String ,age :Int){
      this(name)         //调用前一个辅助构造器
      this.age=age
    }
     //一个类中没有显式的定义主构造器，那么会默认的定义一个无参的主构造器

}

object superWoman {
          //三种方式构建对象
  val s1 = new SuperWoman
  val s2 = new SuperWoman("John")
  val s3 = new SuperWoman("John",30)
}

6.主构造器

在Scala中，每个类都有主构造器，主构造器并不以this方法定义，而是与类定义交织在一起
主构造器的参数被编译成字段，其值被初始化成构造时传入的参数
在Scala中，类也接受参数，和方法一样

class SuperBoy(val name:String,val age:Int){
  //(...)中的内容就是主构造器的参数
  println("this is construct")

  override def toString = s"SuperBoy($name, $age)"
}
//构造参数也可以是普通的方法参数，不带val或者var，这样的参数如何处理取决于它们在类中如何被使用
//如果不带val或者var的参数至少被一个方法使用，它将被升级为字段
class SuperGirl(name:String,age:Int){
  def description=name + "is" + age + "years old"
}
//上述代码声明并初始化了不可变字段name和age，而这两个字段都是对象私有的，类似于private[this]
//当你把主构造器的参数看做是类参数时，不带val或var的参数就变得易于理解了，这样的参数的作用域覆盖整个类，因此你可以在方法中使用，同时
//你这样做了，编译器自动帮你将它保存成字段
//如果你想把主构造器变为私有，如下
class OldMan private(val name:String,val age:Int){}//这样只能通过辅助构造器来创建对象

7.嵌套类

 函数中定义函数，类中定义类

import scala.collection.mutable.ArrayBuffer
class NetWork{
   class Member(val name:String){
     val contacts = new ArrayBuffer[Member]()
   }
  private val Members=new ArrayBuffer[Member]()

  def join(name:String)={
        val m =new Member(name)
        Members += m
        m
  }
}
object NetWork{
  def main(args: Array[String]): Unit = {
    //如有如下两个网络
    val chatter = new NetWork
    val myFace= new NetWork
    //在两个网络中添加成员
    val fred=chatter.join("fred")
    val wilma=chatter.join("wilma")
    fred.contacts += wilma
    val barney = myFace.join("barney")
    //fred.contacts += barney 不允许这样做
    /*
     *如果你不希望是这个效果，两种方式解决
     *   1.可以将Member类移动到NetWork的伴生对象中
     *   2.使用类型投影：NetWork#Member
     *    eg :
     *        class NetWork{
     *           class Member(val name:String){
     *             val contacts = new ArrayBuffer[NetWork#Member]()
     *            }
     *           }
     */
      //在内嵌类中，可以通过外部类.this的方式来访问内部类的this引用，和Java一样
  }
}

提示：有不妥的地方希望大家能够批评指正，一起学习，一起进步