Scala--第五天

一、面向对象

　　1.面向对象编程：以对象为基本单位的程序开发，通过对象间的彼此协调，相互调用，完成代码的开发

　　2.面向函数编程：以函数位基本单位的程序开发，通过函数间的彼此协调，相互调用，完成代码的开发

　　3.对象的定义：一切客观存在的内容（万物皆对象）,看的见，看不见的都是对象

　　4.面向对象的好处：

　　　　　　　　　　1.准确地表达数据地含义

　　　　　　　　　　2.维护性高，易于修改

　　　　　　　　　　3.开闭原则：打开扩展，关闭修改

　　　　　　　　　　4.符合客观世界规律

二、Scala 类与对象

　　1.类与对象地创建

  class Cmx() {
    //类成员属性
    var c: String = "cmx"
    // _ 下划线 代表各种各样的0（null，0，0.0，0.0f,false）
    var d: Int = _

    //成员方法
    def func1(name: String = "cmx") = {
      println(s"你的名字是${name}")
    }
  }

  def main(args: Array[String]): Unit = {
    var cmx = new Cmx()
    //调用成员属性
    println(cmx.c)
    //cmx
    //同上 ，验证_ 的0
    println(cmx.d)
    //0
    //调用成员方法
    cmx.func1()
    //你的名字是cmx
  }
}

　　上面的 Cmx 类没有初始化参数，可以简化一下代码，使用无参构造器，请看下面示例：

  //无参，无成员
  class Cmx

  def main(args: Array[String]): Unit = {
    //实例化对象
    var cmx = new Cmx

  }

　　修改对象的成员属性值

  class Cmx {
    var c = "cmx"
  }

  def main(args: Array[String]): Unit = {
    //实例化对象
    var cmx = new Cmx
    println(cmx.c)
    cmx.c = "cmx01"
    println(cmx.c)

    //修改前：cmx
    //修改后：cmx01
  }

　　2.this 关键字

　　　用处：1. 代表当前对象，类似于python的self

　　　　　　2.代表构造器（构造函数，构造方法） ##构造器：指的是创建类的时候，位于类名后的括号中初始化的对象成员属性的格式

  class Cmx {
    var name = "cmx"

    def showname() = {
      println(this.name)
    }
  }
  def main(args: Array[String]): Unit = {
    var a = new Cmx
    var b = new Cmx
    a.name = "cmx01"
    b.name = "cmx02"
    a.showname()
    b.showname()
    //cmx01
    //cmx02
  }

　　3.主构造器（构造方法，有参构造器）

　　　　定义：构造器是用于创建对象

　　　　主构造器：1.创建对象的同时，为对象的成员属性赋值

　　　　　　　　　2.在对象创建的同时还可以执行一些其他的功能

  //注意在有参构造器中，0的意义不可以用_代替,注意这里需要加上var关键字，不然会对辅助构造器产生影响
  class Cmx(var name: String = "") {
    println(s"我是主构造器的附带功能${name}")
  }

  def main(args: Array[String]): Unit = {
    var a = new Cmx("cmx")
    //结果
    //我是主构造器的附带功能cmx
  }

　　4.辅助构造器

　　　　在Scala中除了可以定义主构造器外，还可以根据需要定义辅助构造器

　　　　注意：1.辅助构造器没有返回值类型

　　　　　　　2.构造器方法第一行必须调用主构造器或者其他构造器

　　　　　　　3.第二行开始可以根据你的需求写具体的代码

　　　　格式：

　　　　　　def this(参数名：参数类型){

　　　　　　　　this(实参)   #调用主构造器

　　　　　　　　... ...

　　　　　　}

  class Cmx(var name: String = "", var age: Int = 0) {
    def this(name: String) {
      this(name, 18)
    }

    //辅助构造器可以有多个
    def this(args: Array[String]) {
      this(args(0), args(1).toInt)
    }
  }

  def main(args: Array[String]): Unit = {
    var a = new Cmx("cmx")
    println(a.name)
    //cmx
    var b = new Cmx(Array("cmx01", "21"))
    println(b.name, b.age)
    //(cmx01,21)
  }

　　5.访问修饰符

　　　　1.public：等于不写，默认选择，意味着该成员可以在其他类中或对象被调用

　　　　2.private：私有的，只能在本类中或者本类的半生对象使用，其他类或对象不可使用

　　　　3.protected：受保护的，只能在本类中或本类的子类中使用

  class Cmx() {
    private var name = "cmx"

    private def show() = {
      println(name)
    }
  }

　　6.封装：属性的私有化，同时为每个属性提供 set get方法 进而保护属性安全，意为可以用公开的方法访问私有的属性

  class Card(private var password: String = "", private var balance: Double = 0.0) {
    //辅助构造器，给定余额，自动给其密码默认值
    def this(balance: Double) = {
      this("123456", balance)
    }

    //公开的方法获取密码
    def get_password(): String = {
      this.password
    }

    //公开的方法获取余额
    def get_balance(): Double = {
      this.balance
    }
    //取钱的方法
    def withdraw(password: String, money: Double): Unit = {
      if (password == this.get_password() && this.balance >= money) {
        this.balance = this.balance - money
      }
      else {
        throw new Exception("取钱出现问题")
      }
    }

  }

  def main(args: Array[String]): Unit = {
    var a = new Card(10000)
    a.withdraw("123456", 5000)
    println(a.get_balance())
    //5000.0
    a.withdraw("123456", 5000)
    println(a.get_balance())
    //0.0
    a.withdraw("123456", 100)
    println(a.get_balance())
    //Exception in thread "main" java.lang.Exception: 取钱出现问题
    //    at cmx_test.test1$Card.withdraw(test1.scala:29)
    //    at cmx_test.test1$.main(test1.scala:41)
    //    at cmx_test.test1.main(test1.scala)
  }

　　7.单例对象

　　　　定义：类似于Java的静态方法/变量；用类名.成员属性/方法 ，访问

　　　　格式：object 对象名{

　　　　　　　　成员，可以被访问修饰符修饰

　　　　　　　　}

　　　　注意：1.单例对象通过 类名.成员 访问成员

　　　　　　　2.可进行封装 private 私有

　　　　　　　3.没有构造器之说

　　　　用处：用作工具类的使用

  object Data {
    def format(date: Date): String = {
      val dateFormat = new SimpleDateFormat("yyyy-MM-dd")
      var ste = dateFormat.format(date)
      return ste
    }
  }

  def main(args: Array[String]): Unit = {
    var d = new Date()
    var res = Data.format(d)
    println(res)
    //2020-02-09

　　8.伴生对象：一个类和一个单例对象同名，我们就称这个单例对象是这个类的伴生对象

　　　　条件：1.伴生对象和类 同名

　　　　　　　2.伴生对象和类 需要在一个文件中

　　　　　　　3.伴生对象可以和伴生类彼此相互访问private修饰符 修饰的内容

　　　　作用：

　　　　　　　　1.伴生对象为伴生类提供工具方法（建议只在伴生类中 使用对应伴生对象的方法）

　　　　　　　　2.快速创建对象

　　　　注意：若private[this] 修饰的成员 ，该成员不可以被相互访问

  class Cmx(var name: String = "") {

  }

  //快速创建对象
  object Cmx {
    def apply(name: String = "") = {
      new Cmx(name)
    }
  }

  def main(args: Array[String]): Unit = {
    var a = Cmx("cmx")
    println(a.name)
    //cmx
  }