Scala编程基础3：函数式编程思想之类与对象、重写、样例类

面向对象编程思想：是将对象传来传去的
1、将对象作为方法的参数进行传递
2、将对象作为方法的返回值类型进行返回
需要明确的是对象的类，抽象类或者接口的类型，可以使用多态进行传递或者返回

一、类与对象

/**
 * 面对对象的编写：类---->对象
 * 类中所拥有的方法：构造方法、成员方法、成员变量
 */


class Student1 {
  //class一个类中大括号本身的区域其实就是一个构造函数的区域
  //scala中和java一样，所有的class类都有一个共同的父类：Object
  println("好好学习，天天向上")

  /**
   * scala中的构造方法也是可以进行重载的
   * 如果是构造方法的话，方法的名字是固定的 this
   * 注意：在类中重载构造方法的时候，构造方法的第一句话必须是手动调用默认的构造方法  this();
   *
   */

  def this(x: String) = {
    this();
    println(f"${x}，hello")
  }
}


class Student2 {
  /**
   * 在scala的类中如何定义成员变量，如何传值?
   * 1、构造方法的主要目的是给成员变量传值
   * 2、定义成员变量的时候，一开始可以给一个下划线，表示一个占位符，将来会赋值
   * 3、成员变量前可以加一个_,以和其他变量区分（_id、_name）
   */
  //  var _id: String = _
  //  var _name: String = _
  private var _id: String = _
  private var _name: String = _

  def this(id: String, name: String) = {
    this()
    this._id = id
    this._name = name
  }

  def setId(id: String): Unit = this._id = id

  def getId(): String = this._id

  def setName(name: String): Unit = this._name = name

  def getName(): String = this._name

  /**
   * 重写父类中的方法
   * scala重写的方式与java有些许不同，scala中的重写提供了一个关键字：override
   */
  override def toString: String = s"学号:${_id},姓名:${_name}"

}

class Animal {
  var _id: String = _
  var _name: String = _

  def run(): Unit = {
    println("跑")
  }
}

class Dog extends Animal {

  override def run(): Unit = {
    println("跑的快")
  }

  def eat(): Unit = {
    println("吃猫粮")
  }
}


object ObjectDemo1 {
  def main(args: Array[String]): Unit = {
    //scala是java的封装,同样类默认会提供一个无参的构造方法
    //scala中如果是一个无参构造方法调用创造对象的话，（）可以省略
        val s1 = new Student1
        val s2 = new Student1("你好")

        val s3 = new Student2("1001", "小明")
        println(s3)
        s3.setId("1002")
        println(s3.getId())

    val dog = new Dog
        dog.run()
        dog.eat()

    //scala中也有继承和多态
    val dog1: Animal = new Dog()
    dog1.run()
  }
}

二、apply

       apply是object中一个特殊的函数，可以直接使用object名字代替函数名，进行调用传参，由调用apply函数得到的对象，称之为伴生对象

object Phone {
  //apply是object中一个特殊的函数，可以直接使用object名字代替函数名，进行调用传参
  def apply(kind: String, price: Int): Phone2 = new Phone2(kind, price)
}

class Phone2(kind: String, price: Int) {
  override def toString = s"品牌：${kind},价格：${price}"
}


object ObjectDemo2 {
  def main(args: Array[String]): Unit = {
    val p1 = new Phone2("华为p70": String, 8000: Int)
    println(p1)

    /**
     * 这里实际上调用的就是apply函数
     * 由调用apply函数得到的对象，称之为伴生对象
     */
    val p4: Phone2 = Phone("华为p70", 8000)
    println(p4)
  }
}

三、样例类

样例类和普通的类区别:

* scala会在编译的时候给样例类加上新的方法，属性，重写一些方法比如说toString
* 注意：样例类中的成员变量，默认是使用val修饰

object ObiectDemo3 {
  def main(args: Array[String]): Unit = {
    //通过User类创建对象
    val user = new User("1001", "张三")
    println(user)  //User(1001,张三,10)

    println(user.id)
    println(user.name)
    user.age = 20
    println(user.age)   //20


  }
}

/**
 * 样例类和普通的类区别:
 * scala会在编译的时候给样例类加上新的方法，属性，重写一些方法比如说toString
 * 注意：样例类中的成员变量，默认是使用val修饰
 */
case class User(var id:String,name:String, var age:Int = 10);