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   }

 

你可能感兴趣的:(Scala--第五天)