Scala类与对象

一、类

1、简单类与属性

类的定义可以通过class关键字实现，在Scala中，类并不声明为Public，一个Scala源文件可以包含多个类。所有这些类都具有公有可见性。调用无参方法时，可以加（），也可以不加 
JavaBeans规范定义了Java的属性是像getXXX（）和setXXX（）的方法。许多Java工具都依赖这个命名习惯。为了Java的互操作性。将Scala字段加@BeanProperty时，这样的方法会自动生成。

package com.soft863
import scala.beans.BeanProperty

class Dog {

  private var leg: Int = 4

  @BeanProperty var name: String = ""
  @BeanProperty  var age: Int = 3

  def shout(content: String): Unit = {
    println(content)
  }

  def shout1(content: String) {
    println(content)

  }

  def main(args: Array[String]): Unit = {
    //    var dog = new Dog
    var dog = new Dog()
    dog.shout("汪汪汪")
    dog.setName("博美")
    dog.setAge(5)
    println(dog.leg)
    println(dog.getName())
    println(dog.getAge())
  }

}

2、构造器

构造器分为主构造器和从构造器

2.1、主构造器

1. 与Java构造不同之处在与，Scala不需要定义与类名相同的方法作为构造器。
2. 主构造器的参数列表直接写在类名（Class）后面，构造器的内容定义在类的里面。
所以，一个Scala类中，除了变量，方法以外的代码都是主构造器的内容。

package com.soft863

object Person {
  def main(args: Array[String]): Unit = {
    var person = new Person("superjean",18)
  }
  
}

class Person(name:String ,age:Int) {

  println("名字："+name)
  println("年龄"+age)

  def eat(thing:String): Unit ={
    println("吃"+thing)
  }
}

2.2、从构造器

1. 以def this开始
2. 从构造器相当于java的重载构造器
3. 从构造器里的第一行必须调用主构造器或其他从构造器
4. 只能调用在自己之前定义的其他从构造器，而不能调用后面定义的，以防止死循环调用

package com.soft863

class Person1 (name:String,age:Int){
  println(name)
  println(age)
  var id = 1

  def this(name:String,age:Int,id:Int){
    this(name,age)
    this.id = id
    println("学号"+id)
  }
}

object Person1{

  def add(a:Int,b:Int):Int=a+b
  def main(args: Array[String]): Unit = {
    new Person1("wcj",18,2)
    var res = add(1,2)
    println(res)
  }
}

 二、对象

1、单例对象

在Scala中没有静态方法和静态字段，但是可以使用object这个语法结构来达到同样的目的

object Operation {
    def add(a: Int, b: Int): Int = a + b
}

直接在通过类名调用：

def main(args: Array[String]): Unit = {
    Operation.add(1, 2)
}

 2、伴生对象

Java中的类可以既有实例方法又有静态方法，Scala中可以通过伴生对象进行实现。
类和它的伴生对象可以相互访问私有特性，他们必须存在同一个源文件中。必须同名

package com.soft863

class Cat {

  var hair:Int = Cat.growHair()
  var name = "加菲猫"

  def changeName(name:String):Unit={
    this.name = name
  }

  def describe(): Unit ={
    println("hair:"+hair+",name:"+name)
  }
}

object Cat{
  var hair = 0
  def growHair():Int= {
    hair+=1
    hair
  }

  def main(args: Array[String]): Unit = {
    var cat1 = new Cat
    var cat2 = new Cat

    cat1.changeName("黑猫")
    cat2.changeName("白猫")
    cat1.describe()
    cat2.describe()
  }
}

3、 Apply方法

1) apply方法一般都声明在伴生类对象中，可以用来实例化伴生类的对象
当遇到类名(参数1,...参数n)时apply方法会被调用，apply的作用主要是创建类的对象时，不需要通过new这个关键字：
也可以用来实现单例模式，我们只需要对上述列子稍加改进：

package com.soft863

class Man(name: String, sex: String) {
  def descibe(): Unit = {
    println(name + sex)
  }
}

object Man {
  def apply(name: String): Man = {
    new Man(name, "男")
  }

/*  //单例模式写法
 var instance :Man = null

  def apply(name: String): Man = {
    if(instance ==null){
      new Man(name, "男")
    }
    instance
  }*/
  
  def main(args: Array[String]): Unit = {
    var man1 = Man("superjean")
    var man2 = Man("wcj")
    //    man1.descibe
    man1.descibe()
    man2.descibe()
  }
}

4、 应用程序对象

每一个Scala应用程序都需要从一个对象的main方法开始执行，这个方法的类型为Array[String]=>Unit：

object Hello {
  def main(args: Array[String]) {
    println("Hello, World!")
  }
}

或者扩展一个App特质：

package com.soft863

object Hello  extends App{
  println("hello World")

  if (args.length > 0)
    println("Hello, " + args(0))
  else
    println("Hello, World!")
  
}

三、继承

在Scala中扩展类的方式和Java一样都是使用extends关键字，
同样的，scala也不支持多继承

1、重写方法

在Scala中重写一个非抽象的方法必须使用override修饰符

package com.soft863
class Animal{
  def run(): Unit ={
    println("我是动物，我会跑")
  }
}

class Wolf extends Animal {

  override def run(): Unit = {
    super.run()
    println("我是狼，我跑的很快")
  }

}
object Wolf{
  def main(args: Array[String]): Unit = {
    var wolf = new Wolf
    wolf.run()
  }
}

2、抽象类

和java一样，抽象类通过abstract修饰，功能也和java一样
方法不用标记abstract，只要省掉方法体即可

package com.soft863

abstract class Plant {
  def bloom(name: String): String
}

class Rose extends Plant {
  var color = "红色"

  override def bloom(name: String): String = {
    name + "绽放出" + color + "的花朵"
  }
}

object Rose extends App {
  val rose = new Rose
  var res = rose.bloom("玫瑰")
  println(res)
}