scala面向对象基础

scala面向对象

• 1、类的定义

  • class 类名{
      //变量
      val …
      var …
      //定义方法
      def 方法名(参数) : 返回类型 = {函数体}
    }

• 2、getter和setter

  • 对于类中有var声明的变量(var name:String)，scala编译器会直接自动生成其getter和setter方法；val(val name:String)声明的变量，只声明getter方法；无声明的参数为局部变量(name:String)，无getter无setter，只能在类内部访问。
  • 例
    class Counter(var name1:String,val name2:String,name3:String){
      private name4:String = _ //也无getter和setter
      //自定义个getter和setter
      def name3 = name3 //getter
      def name3_=(newName:String){newName}
    }

• 3、构造器

  • 主构造器 class Counter(var name:String)
  • 辅构造器 class Counter(var name:String){
     //辅助构造器有关键词this实现，作用是用于实现实例时可以使用不同的参数
      def this(name:String,age:Int){
        this(name) //必须得先调用之前的某个构造器
        this.age = age
    }
      def this(){
        this(“add”) //调用主构造器
        或者 this(“aaa”,12) //调用之前的辅构造器

  }
  }

  • 说明
    • 所有构造器的参数个数和参数类型必须不一致，因为这样在实例化的时候才能唯一识别到某个构造器
    • 辅构造器在第一行都必须直接或间接(调用其他辅构造器)调用主构造器
    • 辅构造器的调用过程：假设实例化 val c = new Counter()，则辅构造器this()被调用，this()被调用的过程中会先执行this(“add”)（之后又会去调用主构造器），生成一个具有name属性的实例，因此this()没有新增属性，所以到此就结束了。如果是 val c = new Counter(“mike”,12)，则辅构造器this(name:String,age:Int)会被调用（之后又会去调用主构造器），在这个过程 中会先执行this(name)，生成一个具有name属性的实例，然后再将给该实例添加age属性。

• 4、单例对象（包括伴生对象和孤立对象）

  • 类似静态对象，无需实例化即可去调用其内部不的方法
    object person{def hahaha(){println(“hahahahahha”)}}
    person.hahaha()即可调用
  • 伴生对象
    class A{} 伴生类
    object A{} 伴生对象
    伴生类和伴生对象可互相调用内部成员
  • 孤立对象
    只有 object A{}

• 5、apply方法

  • 实例化后，给该实例传入apply方法的参数，apply方法会被自动调用
    class person{
    def apply(s:String){ println(“hahahahhahaha”)
    }
    val p = new person
    p(“123”) 则apply方法会被调用

    如果apply方法是在object中，object中的方法无需实例化也可被调用，调用更加简便。
    class person{
    def apply(s:String){ println(“hahahahhahaha”)
    }
    person(“123”) apply方法即被调用

    val arr = new Array[Int](5) 此为正常调用
    val arr = Array(1,2,3) 此为调用Array的apply方法

  • 工厂
    class Car(name:String){def info() {println(“aaaaaa”)}
    object Car { def apply(name:String) = new Car(name) }
    val mycar = Car(“TESLA”) //直接调用伴生对象的apply，无需new

• 6、update方法

  • 用于修改对象的某个值
  • 当对带有括号并包括一到若干参数的对象进行赋值时，编译器将调用对象的update方法，并将括号里的参数和等号右边的值一起作为update方法的输入参数来执行调用
  • val arr = Array(1,2,3)
    arr(0) = 123 //调用了update方法 arr.update(0,123)，这也是Array的索引用的是() ，这是函数式编程的特点。

• 7、upapply方法

  • apply的反向操作，给定一个对象，返回对象的属性值
    def unapply(c:Car):Option[(String,Int)]={Some((c.brand,c.price))}

• 8、abstract抽象类

  • 抽象：字段没有给初始值、方法没给定义
    abstract class Car{
    val name:String //没有给初始值
    def printInfo() / 没有给函数定义
    }
  • 抽象类的作用：用于程序的设计阶段

• 9、extends继承（只能继承一个类）

  • 重写父类方法或字段(var)用 override修饰(父类为抽象时可以不加)

• 10、case class

  • 自动生成apply方法、unapply方法

• 11、Option类

• 12、trait特质

  • 给类提供组件?
  • scala只能继承一个超类，可混入多个特质
  • trait Flyable {
        var maxFlyHeight:Int
        def fly()
        def breathe() {println(“huhuhuhuhu”)
    }
    trait HasLegs{
        val legs:Int
        def move() {println(“moveeeeee”)}
    }
    class Animal(val category:String){
        def info(){println("This is a " + category)}
    }
    class Bird(category:String,flyHeight:Int) extends Animal(category) with Flyable with HasLegs{
        var maxFlyHeight = flyHeight
        val legs = 2 //重载特质的抽象字段
        def fly(){ println(“I can fly”)} //重载特质的抽象方法
    }