从零学scala（三）类、对象

简单类和无参方法

        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)