一：类
简单类和无参方法
class Counter{
var value = 14
def increment(aa:Int) = { value = aa }
def crement() = { value }
}
val counter = new Counter()
println(counter.crement) //这种类型就是java bean的操作方法
counter.increment(19)
println(counter.crement)
带getter和setter的属性
class Counter{ //scala为每一个方法都提供了get和set方法 value_= （set方法）
var value = 0
}
//如果不希望自动生成，你可以使用 peivate[this]
//val类型只有getter方法生成
//如果字段是私有的，方法也是私有的
只带getter的属性
上一个章节已将说了，getter属性只需要将变量变成 val类型的就行了
class Counter{ //scala为每一个方法都提供了get和set方法 value_= （set方法）
val value = 0
}
对象私有字段
class Counter{
private var value = 0 //如此定义的时候就可以将这个变量只在这个类内部访问
def increment(newValue:Int)={
value = newValue
}
def crement() = {
value
}
def isLess(counter:Counter){ //value变量只能对象内部访问，如果不想让别的同一个独享访问，可以将变量设置为private [this]
if(counter.value > value) println(">>>") else println("<<<")
}
}
Bean属性
为了结合java使用所介绍的一个便签，个人感觉没有什么作用，最起码在工作这么长的时间内没有使用到。在此不做介绍。
//import scala.reflect.BeanProperty 文章中使用，但是已经被废弃了，可以使用下面的这个，同样的效果
import scala.beans.BeanProperty
辅助构造器
class Counter{
var value = 0
def this(aa:Int){ //不用写成Counter，直接写this
this() //先调用主构造方法，否则会报错，没有写主构造会默认给你加一个空的主构造方法
value = aa
}
def this(aa:Int,bb:Int){
this()
value = if(aa > bb) aa else bb
}
}
主构造器
class Counter(initValue:Int){//这种写法就是主构造方法，
var value = 10
println(value) //下面的代码每次new对象的时候都会一直执行
}
class Counter(var value:Int=10){ //给参数赋默认值，这种写法还定义了变量 value，如果前面什么都没有默认是 private [this] 类型的
println(value)
}
//如果想让主构造方法只能被辅助构造方法，那就在前面加上一个private。
嵌套类
import scala.collection.mutable.ArrayBuffer
class NetWork{
class Member(val name:String){
val contacts = name
}
private val memberArray = new ArrayBuffer[Member]
def join(name:String) = {
val member = new Member(name)
memberArray += member
member
}
}
object FastLearnScala {
def main(args: Array[String]): Unit = {
val chatter = new NetWork
val fred = chatter.join("fred")
val wilma = chatter.join("wilma")
}
}
就不按照书上的例子了，个人感觉书上的例子没有什么作用
二：对象
单例对象
object Accounts{
private var lastNumber = 0
def newUniqeNumber = { lastNumber += 1 ;lastNumber}
}
//可以通过这种方法使用单例模式，Accounts其实也是一个类。它的构造方法也是在首次调用newUniqeNumber的时候调用的。
伴生对象
class Account{
private var aa = "aa"
private def mm(){
print("class method mm to object"); Account.bb
println(aa)
}
}
object Account{
private var bb = "bb"
private def nn(){
val account = new Account()
print("object method nn to class"); account.aa
println(bb)
}
}
//伴生类和伴生对象必须要同名，在同一个源文件中
//伴生对象和伴生类可以相互访问其中的私有变量
object FastLearnScala { //这种写法是会报错的
def main(args: Array[String]): Unit = {
val account = new Account()
account.aa
Account.bb
}
}
扩展类或特质的对象
abstract class Undo(name:String){
def undo(){
println("abcd")
}
}
object FastLearnScala extends Undo("aa"){
override def undo(){
println("efgh")
}
def main(args: Array[String]): Unit = {
undo()
}
}
//abstract方法比较适合有参数需要构造的场景，至于不需要参数的建议使用trait，一个类是可以多继承trait的，使用很方便
apply方法
val array = Array(1,2,3,4)
println(array.apply(3))
val map = Map("a"->1,"b"->2,"c"->3)
println(map.apply("a"))
scala对象中提供了很多apply方法，建议构造自己的类的时候也def 一个apply方法，可以使用的更好
（其实是和scala其他类保持一致方便其他人使用）
应用程序对象
object FastLearnScala extends App
//其实就是在main的object中可以继承App类，写一些自己的逻辑。在此不多介绍
枚举
object Enu extends Enumeration{//scala中需要继承Enumeration，其他用法和java一样
val FIRST,SECOND,THIRD = ("RED","YELLOW","BLUE")
}
println(Enu.FIRST)