scala类的定义

package com.ibfw

/**

* auther by bbaiggey

*/

import scala.beans.BeanProperty
import scala.collection.mutable.ArrayBuffer
/*
 * 类的定义
 * field的getter和setter
 * construction详解
 * 内部类介绍
 */
class HelloWorld{
  private var name = "leo"
  def sayHello() {
    println("Hello ,"+name)
    
  }
   def getName() = name
}


/** case1
 * 1、定义不带private的var 编译器或生产private的filed和public的getter和setter方法
 * 2、如果是private的field则生成的getter和setter也是private的
 * 3、如果定义val field 只会生成getter方法
 * 4、如果不希望生成的getter和setter 则将field声明为private[this]
 */
/*class Student{
  var name = "jack"//会生成private的name 和public的getter和setter的方法
}*/


//case2
//自定义getter和setter方法
/*class Student{
  private var myName = "jack"
  def name = "your name is "+myName
  def name_=(newName:String){//name_= 不能有空格
    println("you can not edit your name!!!")
  }
}*/
//case3 仅暴露field的getter方法
/**
 * 如果不希望field有setter方法值只需要field声明成val就可以了，但是不能修改它的值了
 * 但是如果希望能够仅仅暴露出一个getter方法,并且还能够通过某些方法修改field的值,那么
 * 需要综合使用private已经自己定义的getter方法
 * 此时,由于field是privte的所有setter和getter都是private的,对外界没有暴露,那么自己就要
 * 实现修改field值的方法:自己可以覆盖getter方法
 */
/*class Student{
  private var myName = "jack"
  def updateName(newName:String){
    if(newName=="jack")myName = newName
    else{
      println("not accept this new name")
    }
  }
  def name = "you name is  "+myName
}*/
/**
 * case4 private[this]的使用
 * 如果将field使用private来修饰,那么代表这个field是私有的,在类方法中,可以直接进行访问
 * 类的其他对象的private field
 *这种情况下 如果不希望field被其他对象访问到,那么就可以使用private[this]，意味着对象私有的field
 * 只有本对象内可以访问到 
 */
/*class Student{
  private var myAge = 0
  def age_=(newAge:Int) {
    if (newAge>0) myAge = newAge
    else {
      println("illegal age!!!")
    }
  }
  def age = myAge
  def older(s:Student){
    myAge>s.age
  }
}*/
/**
 * case5 java风格的getter和setter方法
 * 1、scala的getter和setter方法的命名与java是不同的，是field和field_=
 * 2、如果让scala自动生成java风格的getter和setter犯法，只要在field添加@BeanProperty注解即可
 * 3、测试会生产4个方法，name:String、name_=(newValue:String):Unit、getName():String、setName(newValue:String):Unit
 */
/*class Student{
  @BeanProperty var name:String=_
}


class Student1(@BeanProperty var name:String)*/
/*
 * case6 Constructor
 * Scala中 可以给类定义多个辅助构造器 类似于java的构造函数重载
 * 辅助Constructor之间可以互相调用，而且必须第一行调用主构造器
 * //辅助构造器的名字叫this
 */
/*class Student{
  private var name = ""
  private var age =0
  def this(name:String){
    this()//辅助构造器的名字叫this
    this.name = name
  }
  def this(name:String,age:Int){
    this(name)
    this.age = age
  }
}*/
/**
 * case 7
 * scala中，主构造器是与类名放在一起的，与java不同
 * 而且类中，没有定义在任何方法或者是代码块之中的代码就是主Constructor的代码，这点感觉没有java那么清晰
 * //如果主Constructor传入的参数什么修饰都没有，比如 name:String , 那么如果类内部的犯法使用到了，
  //则会声明为 private[this]name ,否则没有使用该filed 就只能被Constructor代码使用而已
 */
/*class Student(val name:String,val age:Int){
  println("your name is"+name+"your age is "+age)
}
//主构造器中还可以通过使用默认参数，来给参数默认的值
class StudentConstructor(val name:String="jack",val age:Int = 12){
  println("your name is "+name+"your age is "+age)
}*/
/**
 * case8
 * Scala中同样可以在类中定义类，但是与java不同的是，每个外部类的对象的内部类，都是不同的类
 */
/*class Class{
  class Student(val name:String){}
  val student = new ArrayBuffer[Student]
  def getStudent(name:String)={
    new Student(name)
  }
 
}*/




object Test_Class extends App{
  val c = new HelloWorld
//  c.name //private只会生成private的getter和setter方法
  c.sayHello()
  c.getName//要想访问 需要自己定义公开的方法 // 也可以不加括号，如果定义方法时不带括号，则调用方法时也不能带括号
//  case1
  /*val s = new Student
  println(s.name)
  s.name="Tom" //实际生成的getter和setter方法是 name 和name_=
  println(s.name)*/
//  case2
  /*val jack = new Student
  println(jack.name)
  jack.name="123"*/
//  case3
/*  val s = new Student
  println(s.name)
  s.updateName("leo")*/
//  case4
  /*val s = new Student
  val s1 = new Student
  s.age_=(10)
  s.older(s1)*/
//  case5
/*  val s = new Student
  s.setName("jack")
//  s.name="jack"
  s.getName()
//  s.name
*/
//  case6
/*  val s1 = new Student("jack")
  val s2 = new Student("jack",18)*/
//  case7
  /*val s = new StudentConstructor*/
//  case8
/*  val c1 = new Class
  val s1 = c1.getStudent("jack")
  c1.student+=s1
  val c2 = new Class
  val s2 = c2.getStudent("jack")//在java中 这个获取的两个student是同类型的 但是在scala中不是
//  c1.student+=s2
  println(s1==s2)*/


}