从零学scala（三）类、对象

一：类

1.简单类和无参方法

    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)

2.带getter和setter的属性

    class Counter{     //scala为每一个方法都提供了get和set方法   value_= （set方法）
            var value = 0
    }

    //如果不希望自动生成，你可以使用 peivate[this]
    //val类型只有getter方法生成
    //如果字段是私有的，方法也是私有的

3.只带getter的属性

    上一个章节已将说了，getter属性只需要将变量变成 val类型的就行了 

    class Counter{     //scala为每一个方法都提供了get和set方法   value_= （set方法）
            val value = 0
    }

4.对象私有字段

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

5.Bean属性

为了结合java使用所介绍的一个便签，个人感觉没有什么作用，最起码在工作这么长的时间内没有使用到。在此不做介绍。

//import scala.reflect.BeanProperty 文章中使用，但是已经被废弃了，可以使用下面的这个，同样的效果

import scala.beans.BeanProperty

6.辅助构造器

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

7.主构造器

    class Counter(initValue:Int){//这种写法就是主构造方法，
            var value = 10

            println(value)    //下面的代码每次new对象的时候都会一直执行
    }

    class Counter(var value:Int=10){ //给参数赋默认值，这种写法还定义了变量 value，如果前面什么都没有默认是 private [this] 类型的
            println(value)
    }

    //如果想让主构造方法只能被辅助构造方法，那就在前面加上一个private。

8.嵌套类

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

            }
    }

就不按照书上的例子了，个人感觉书上的例子没有什么作用

二：对象

1.单例对象

    object Accounts{
            private var lastNumber = 0
            def newUniqeNumber = { lastNumber += 1 ;lastNumber}
    }

　　//可以通过这种方法使用单例模式，Accounts其实也是一个类。它的构造方法也是在首次调用newUniqeNumber的时候调用的。

2.伴生对象

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

3.扩展类或特质的对象

    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的，使用很方便

4.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其他类保持一致方便其他人使用）

5.应用程序对象

     object FastLearnScala extends App  

    //其实就是在main的object中可以继承App类，写一些自己的逻辑。在此不多介绍

6.枚举

    object Enu extends Enumeration{//scala中需要继承Enumeration，其他用法和java一样
            val FIRST,SECOND,THIRD = ("RED","YELLOW","BLUE")
    }

    println(Enu.FIRST)