Scala--第五天

一、面向对象

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

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

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

　　4.面向对象的好处：

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

　　　　　　　　　　2.维护性高，易于修改

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

　　　　　　　　　　4.符合客观世界规律

二、Scala 类与对象

　　1.类与对象地创建

 1   class Cmx() {
 2     //类成员属性
 3     var c: String = "cmx"
 4     // _ 下划线 代表各种各样的0（null，0，0.0，0.0f,false）
 5     var d: Int = _
 6 
 7     //成员方法
 8     def func1(name: String = "cmx") = {
 9       println(s"你的名字是${name}")
10     }
11   }

 1   def main(args: Array[String]): Unit = {
 2     var cmx = new Cmx()
 3     //调用成员属性
 4     println(cmx.c)
 5     //cmx
 6     //同上 ，验证_ 的0
 7     println(cmx.d)
 8     //0
 9     //调用成员方法
10     cmx.func1()
11     //你的名字是cmx
12   }
13 }

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

1   //无参，无成员
2   class Cmx
3 
4   def main(args: Array[String]): Unit = {
5     //实例化对象
6     var cmx = new Cmx
7 
8   }

　　修改对象的成员属性值

 1   class Cmx {
 2     var c = "cmx"
 3   }
 4 
 5   def main(args: Array[String]): Unit = {
 6     //实例化对象
 7     var cmx = new Cmx
 8     println(cmx.c)
 9     cmx.c = "cmx01"
10     println(cmx.c)
11 
12     //修改前：cmx
13     //修改后：cmx01
14   }

　　2.this 关键字

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

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

 1   class Cmx {
 2     var name = "cmx"
 3 
 4     def showname() = {
 5       println(this.name)
 6     }
 7   }
 8   def main(args: Array[String]): Unit = {
 9     var a = new Cmx
10     var b = new Cmx
11     a.name = "cmx01"
12     b.name = "cmx02"
13     a.showname()
14     b.showname()
15     //cmx01
16     //cmx02
17   }

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

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

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

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

 1   //注意在有参构造器中，0的意义不可以用_代替,注意这里需要加上var关键字，不然会对辅助构造器产生影响
 2   class Cmx(var name: String = "") {
 3     println(s"我是主构造器的附带功能${name}")
 4   }
 5 
 6   def main(args: Array[String]): Unit = {
 7     var a = new Cmx("cmx")
 8     //结果
 9     //我是主构造器的附带功能cmx
10   }

　　4.辅助构造器

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

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

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

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

　　　　格式：

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

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

　　　　　　　　... ...

　　　　　　}

 1   class Cmx(var name: String = "", var age: Int = 0) {
 2     def this(name: String) {
 3       this(name, 18)
 4     }
 5 
 6     //辅助构造器可以有多个
 7     def this(args: Array[String]) {
 8       this(args(0), args(1).toInt)
 9     }
10   }
11 
12   def main(args: Array[String]): Unit = {
13     var a = new Cmx("cmx")
14     println(a.name)
15     //cmx
16     var b = new Cmx(Array("cmx01", "21"))
17     println(b.name, b.age)
18     //(cmx01,21)
19   }

　　5.访问修饰符

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

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

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

1   class Cmx() {
2     private var name = "cmx"
3 
4     private def show() = {
5       println(name)
6     }
7   }

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

 1   class Card(private var password: String = "", private var balance: Double = 0.0) {
 2     //辅助构造器，给定余额，自动给其密码默认值
 3     def this(balance: Double) = {
 4       this("123456", balance)
 5     }
 6 
 7     //公开的方法获取密码
 8     def get_password(): String = {
 9       this.password
10     }
11 
12     //公开的方法获取余额
13     def get_balance(): Double = {
14       this.balance
15     }
16     //取钱的方法
17     def withdraw(password: String, money: Double): Unit = {
18       if (password == this.get_password() && this.balance >= money) {
19         this.balance = this.balance - money
20       }
21       else {
22         throw new Exception("取钱出现问题")
23       }
24     }
25 
26   }
27 
28   def main(args: Array[String]): Unit = {
29     var a = new Card(10000)
30     a.withdraw("123456", 5000)
31     println(a.get_balance())
32     //5000.0
33     a.withdraw("123456", 5000)
34     println(a.get_balance())
35     //0.0
36     a.withdraw("123456", 100)
37     println(a.get_balance())
38     //Exception in thread "main" java.lang.Exception: 取钱出现问题
39     //    at cmx_test.test1$Card.withdraw(test1.scala:29)
40     //    at cmx_test.test1$.main(test1.scala:41)
41     //    at cmx_test.test1.main(test1.scala)
42   }

　　7.单例对象

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

　　　　格式：object 对象名{

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

　　　　　　　　}

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

　　　　　　　2.可进行封装 private 私有

　　　　　　　3.没有构造器之说

　　　　用处：用作工具类的使用

 1   object Data {
 2     def format(date: Date): String = {
 3       val dateFormat = new SimpleDateFormat("yyyy-MM-dd")
 4       var ste = dateFormat.format(date)
 5       return ste
 6     }
 7   }
 8 
 9   def main(args: Array[String]): Unit = {
10     var d = new Date()
11     var res = Data.format(d)
12     println(res)
13     //2020-02-09

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

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

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

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

　　　　作用：

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

　　　　　　　　2.快速创建对象

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

 1   class Cmx(var name: String = "") {
 2 
 3   }
 4 
 5   //快速创建对象
 6   object Cmx {
 7     def apply(name: String = "") = {
 8       new Cmx(name)
 9     }
10   }
11 
12   def main(args: Array[String]): Unit = {
13     var a = Cmx("cmx")
14     println(a.name)
15     //cmx
16   }