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)//此处调用无参构造时，()可加也可不加
  }
}

/**
 *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
  }
}

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[类名]，这样的只有指定类才能访问
}

import scala.reflect.BeanProperty
class superMan{
  @BeanProperty var name : String  = _
}
/*
 *将会生成如下四个方法：
 * name :String
 * name_=(newValue:String):Unit
 * getName():String
 * setName(newValue:String):Unit
 */

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)
}

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){}//这样只能通过辅助构造器来创建对象

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一样
  }
}