★ Scala ★——类和对象（伴生对象）大全细则

野性酷女 2023-01-07 05:55 206阅读 0赞

### 类与对象 ###

*   *  1. 类和对象
     *   *  1.1 什么是类?
         *  1.2 什么是对象?
         *  1.3 创建类和对象
         *  1.4 定义和访问成员变量
         *  1.5 使用下划线初始化成员变量
         *  1.6 定义和访问成员方法
         *  1.7 访问权限修饰符
         *  1.8 类的构造器
         *   *   *  1.8.1主构造器
                 *  1.8.2 辅助构造器
         *  1.9 单例对象(object)
         *   *   *  1.9.1 定义单例对象
         *  1.10 伴生对象
         *   *   *  1.10.1定义伴生对象
                 *  1.10.2 private\[this\]访问权限
                 *  10.1.3 apply方法（免new）
         *  1.11 案例: 定义工具类

源码链接：[https://pan.baidu.com/s/1psmnL2keRW\_N781Cn-kBzg][https_pan.baidu.com_s_1psmnL2keRW_N781Cn-kBzg]  
提取码：**ce34**

[★ Scala ★——方法def 与 函数 细则，99乘法表案例实现][Scala _def _ _ _99]

[★ Scala ★——类和对象（伴生对象）大全细则][Scala]

[★ Scala ★——继承、方法重写、抽象类、匿名类大全细则][Scala 1]

[★ Scala ★——Trait特质大全细则][Scala _Trait]

[★ Scala ★ —— 数据结构（列表、元组、数组）][Scala _ _]

[★ Scala ★ —— 数据结构（集、映射、迭代器）][Scala _ _ 1]

*  目标

1.  掌握类和对象的定义
2.  掌握访问修饰符和构造器的用法
3.  掌握main方法的实现形式
4.  掌握伴生对象的使用
5.  掌握定义工具类的案例

## 1. 类和对象 ##

Scala是一种函数式的面向对象语言, 它也是支持面向对象编程思想的，也有类和对象的概念。我们依然可以基于Scala语言来开发面向对象的应用程序。

面向对象是一种编程思想, 它是基于面向过程的, 强调的是以对象为基础完成各种操作。

*  面向对象的三大思想特点：

1.  更符合人们的思考习惯
2.  把复杂的事情简单化
3.  把程序员从执行者变成指挥者

### 1.1 什么是类? ###

类是属性和行为的集合, 是一个抽象的概念, 看不见, 也摸不着。

*  属性(也叫成员变量): 名词, 用来描述事物的外在特征的
 *  行为(也叫成员方法): 动词, 表示事物能够做什么
 *  例如: 学生有姓名和年龄(这些是属性), 学生要学习, 要吃饭(这些是行为)

### 1.2 什么是对象? ###

对象是类的具体体现, 实现。

面向对象的三大特征是什么? `封装, 继承, 多态。`

### 1.3 创建类和对象 ###

Scala中创建类和对象可以通过`class`和`new`关键字来实现。  
用class来创建类, 用new来创建对象。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70]

*  简写方式

1.  如果类是空的，没有任何成员，可以省略 \{\}
2.  如果构造器的参数为空，可以省略 ()

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 1]

### 1.4 定义和访问成员变量 ###

在类中使用 var/val 来定义成员变量；  
对象可以通过 对象名. 的方式来访问成员变量。

*  例如：

1.  定义一个Person类，包含一个姓名和年龄字段
2.  创建一个名为"张三"、年龄为23岁的对象
3.  打印对象的名字和年龄  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 2]

### 1.5 使用下划线初始化成员变量 ###

在定义`var`类型的成员变量时，可以使用 \_ 来初始化成员变量

*  String => null  
    Int => 0  
    Boolean => false  
    Double => 0.0  
    …

`val`类型的成员变量，必须要自己手动初始化  
`var name:String = _ // 姓名`  
`var age:Int = _ // 年龄`  
`// val age:Int = _ // 这样写会报错, 因为"下划线赋值"的方式只针对于var修饰的变量有效`

### 1.6 定义和访问成员方法 ###

类可以有自己的行为，scala中也可以通过定义成员方法来定义类的行为。

在scala的类中，也是使用 def 来定义成员方法的  
`def 方法名(参数1:数据类型, 参数2:数据类型): [return type] = { //方法体 }`

*  案列：

1.  创建一个Customer类
2.  创建一个该类的对象，并调用printHello方法

package Category
    
    object ClassDemo1 {
        
      def main(args: Array[String]): Unit = {
        
        // 创建Customer类型的对象.
         val c = new Customer
        // 给成员变量赋值
         c.name = "张三"
         c.sex = "男"
        //  打印成员变量值到控制台上
         println(c.name, c.sex)
        // 调用成员方法
         c.printHello("你好!")
      }
      // 1. 创建Customer类
      class Customer {
        
        // 2. 定义成员变量
        var name:String = _   // 姓名
        var sex = ""  // 性别
        // 3. 定义成员方法printHello
        def printHello(msg:String) = {
        
          println(msg)
        }
      }
    }

![在这里插入图片描述][20210115175327232.png]

### 1.7 访问权限修饰符 ###

和Java一样，scala也可以通过访问修饰符，来控制成员变量和成员方法是否可以被外界访问。

*  定义

1.  Java中的访问控制，同样适用于scala，可以在成员前面添加private/protected关键字来控制成员的可见性。
2.  在scala中， 没有public关键字 ，任何没有被标为private或protected的成员都是公共的。
3.  私有成员外界无法直接访问

### 1.8 类的构造器 ###

当创建对象的时候，会自动调用类的构造器。之前使用的都是默认构造器，接下来我们要学习如何自定义构造器。

*  分类:1. 主构造器，2. 辅助构造器

##### 1.8.1主构造器 #####

class 类名(var/val 参数名:类型 = 默认值, var/val 参数名:类型 = 默认值)
    {
         
    	//构造代码块 
    }

*  注意:

1.  主构造器的参数列表直接定义在类名后面，添加了val/var表示直接通过主构造器定义成员变量。
2.  构造器参数列表可以指定默认值
3.  创建实例，调用构造器可以指定字段进行初始化
4.  整个class中除了字段定义和方法定义的代码都是构造代码

*  案例：

package Category
    
    object ClassDemo2 {
        
      def main(args: Array[String]): Unit = {
        
        val p = new Person() // 默认调用
        println(s"${p.name}...${p.age}")
        val p1 = new Person(age = 33) // 手动修改变量值
        println(s"${p1.name}...${p1.age}")
      }
    
      // 创建person类, 主构造器参数列表为: 姓名和年龄.
      class Person(var name:String = "李斯", var age:Int = 31){
        
        println("显示调用主构造器")
      }
    }

![在这里插入图片描述][20210115193911864.png]

##### 1.8.2 辅助构造器 #####

在scala中，除了定义主构造器外，还可以根据需要来定义辅助构造器。例如：允许通过多种方式，来创建对象，这时候就可以定义其他更多的构造器。我们把除了主构造器之外的构造器称为**辅助构造器**。  
语法

*  定义辅助构造器与定义方法一样，也使用 def 关键字来定义；
 *  辅助构造器的默认名字都是 this , 且不能修改。

def this(参数名:类型, 参数名:类型) {
        
     // 第一行需要调用主构造器或者其他构造器 
     // 构造器代码 
    }

*  案例：
 *  定义一个Customer类，包含一个姓名和地址字段；
 *  定义Customer类的主构造器（初始化姓名和地址）；
 *  定义Customer类的辅助构造器，该辅助构造器接收一个数组参数，使用数组参数来初始化成员变量。

package Category
    
    object ClassDemo3 {
        
      def main(args: Array[String]): Unit = {
        
        // 调用主构造器，创建Customer对象
        val c = new Customer("周元", "苍玄天") // 默认主构造器
        println(s"${c.name}家的地址是：${c.address}")
    
        // 调用辅助构造器，创建Customer对象
        val a = new Customer(Array("夭夭","周元家")) // 调用辅助构造器
        println(s"${a.name}家的地址是：${a.address}")
      }
      
      class Customer(var name: String, var address:String){
        
        // 定义一个辅助构造器, 接收一个数组参数
        def this(arr:Array[String]){
        
          this(arr(0), arr(1)) //将数组的前两个元素分别传给主构造器的两个参数
        }
      }
    }

![在这里插入图片描述][20210115201418928.png]

### 1.9 单例对象(object) ###

scala中是没有static关键字的，要想定义类似于Java中的static变量、static方法，就要使用到scala中的单例对象了, 也就是object。

##### 1.9.1 定义单例对象 #####

单例对象表示全局仅有一个对象, 也叫 **孤立对象** ，定义单例对象和定义类很像，就是把class换成object。  
`object 单例对象名{ } // 定义一个单例对象`

注意:

1.  在object中定义的成员变量类似于Java中的静态变量, 在内存中都只有一个对象。
2.  在单例对象中, 可以直接使用 单例对象名. 的形式调用成员。
3.  在单例对象中定义的成员方法类似于Java中的静态方法。

package Category
    
    object ClassDemo4 {
        
      def main(args: Array[String]): Unit = {
        
        Dog.eat() // 调用单例对象的成员方法
      }
    
      // 1.定义单例对象
      object Dog{
        
        val leg_num = 4 // 单例变量
    
        // 2.单例方法 eat
        def eat() = println(s"狗的腿有${leg_num}条，狗是吃肉的")
      }
    }

![在这里插入图片描述][20210115202929339.png]

### 1.10 伴生对象 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 3]  
在scala中，要实现类似的效果，可以使用伴生对象来实现。

##### 1.10.1定义伴生对象 #####

一个class和object具有同样的名字。这个object称为**伴生对象**，这个class称为**伴生类**

*  伴生对象必须要和伴生类一样的名字；
 *  伴生对象和伴生类在同一个scala源文件中；
 *  伴生对象和伴生类可以互相访问**private**属性。

package Category
    
    object ClassDemo5 {
        
      def main(args: Array[String]): Unit = {
        
        val g = new Generals
        g.war()
      }
    
      object Generals {
        
        // 伴生对象，都是静态成员
        private val book = "智慧之书"
      }
    
      class Generals {
         // 伴生类，非静态成员
        def war() = println(s"法华拿着${Generals.book}去战斗")
      }
    }

![在这里插入图片描述][20210115205550793.png]

##### 1.10.2 private\[this\]访问权限 #####

如果某个成员的权限设置为private\[this\]，表示只能在当前类中访问。伴生对象也不可以访问。

*  定义一个Person类，包含一个name字段, 该字段用private\[this\]修饰。
 *  定义Person类的伴生对象，定义printPerson方法。
 *  测试伴生对象是否能访问private\[this\]权限的成员。

package Category
    
    object ClassDemo6 {
        
      def main(args: Array[String]): Unit = {
        
        val p = new Person("蓝廋")
        Person.p_Person(p)
      }
      
      class Person(private[this] var name: String) // 会报错
      object Person {
        
        def p_Person(p:Person) = println(p.name)
      }
    }

`注意: 上述代码，会编译报错。但移除掉[this]就可以了`

##### 10.1.3 apply方法（免new） #####

在Scala中, 支持创建对象的时候, `免new` 的动作, 这种写法非常简便，优雅。要想实现 免new , 我们就要通过伴生对象的apply方法来实现。

格式:
    object 伴生对象名 {
         
    	def apply(参数名:参数类型, 参数名:参数类型...) = new 类(...)
    }
    
    创建对象
    val 对象名 = 伴生对象名(参数1, 参数2...)

*  案例：
 *  定义一个Person类，它包含两个字段：姓名和年龄；
 *  在伴生对象中定义apply方法，实现创建Person对象的免new操作；
 *  在main方法中创建该类的对象，并打印姓名和年龄。

package Category
    
    object ClassDemo7 {
        
      def main(args: Array[String]): Unit = {
        
        val p = Person("霍着急", 26)
        println(s"${p.name}的年龄是：${p.age}岁")
      }
      
      class Person(var name: String = "", var age: Int = 0)
      object Person {
        
        def apply(name: String, age: Int): Person = new Person(name, age)
      }
    
    }

![在这里插入图片描述][20210115211812653.png]

### 1.11 案例: 定义工具类 ###

Scala中工具类的概念和Java中是一样的, 都是

1.  构造方法全部私有化, 目的是不让外界通过构造方法来创建工具类的对象；
2.  成员全部是静态化, 意味着外界可以通过"类名."的形式来访问工具类中的内容；
3.  在Scala中只有 object单例对象 满足上述的要求！

*  案例：
 *  编写一个DateUtils工具类专门用来格式化日期时间
 *  定义一个方法，用于将日期（Date）转换为年月日字符串，例如：2021-1-5
 *  定义一个方法, 用于将年月日字符串转换为日期(Date)

package Category
    
    import java.text.SimpleDateFormat
    import java.util.Date
    
    object ClassDemo8 {
        
      def main(args: Array[String]): Unit = {
        
        // 调用DateUtils#date2String()方法, 用来格式化日期.
        val s = DateUtils.date2String(new Date(), "yyyy-MM-dd")
        println("格式化日期: " + s)
    
        // 调用DateUtils#string2Date()方法, 用来解析日期字符串.
        val d = DateUtils.string2Date("2020年1月10日", "yyyy年MM月dd日")
        println("中国第一个警察节: " + d)
      }
    
      // 定义DateUtils工具类. //也就是Scala中的单例对象.
      object DateUtils {
        
        // 创建SimpleDateFormat类型的对象, 用来进行转换操作.
        var sdf: SimpleDateFormat = null
    
        // 定义方法date2String, 用来将Date日期对象转换成String类型的日期
        // 参数1: 日期对象, 参数2: 模板
        def date2String(date: Date, template: String): String = {
        
          sdf = new SimpleDateFormat(template)
          sdf.format(date)
        }
    
        // 定义方法string2Date, 用于将String类型的日期转换成Date日期对象
        def string2Date(dateString: String, template: String) = {
        
          sdf = new SimpleDateFormat(template)
          sdf.parse(dateString)
        }
      }
    }

![在这里插入图片描述][20210115213050455.png]

[https_pan.baidu.com_s_1psmnL2keRW_N781Cn-kBzg]: https://pan.baidu.com/s/1psmnL2keRW_N781Cn-kBzg
[Scala _def _ _ _99]: https://blog.csdn.net/weixin_44775255/article/details/112661448
[Scala]: https://blog.csdn.net/weixin_44775255/article/details/112680051
[Scala 1]: https://blog.csdn.net/weixin_44775255/article/details/113093432
[Scala _Trait]: https://blog.csdn.net/weixin_44775255/article/details/113373647
[Scala _ _]: https://blog.csdn.net/weixin_44775255/article/details/113788952
[Scala _ _ 1]: https://blog.csdn.net/weixin_44775255/article/details/113810814
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70]: /images/20221119/9be563d85bd94b6db378b456be9f262d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 1]: /images/20221119/2d01b9e4e2e74fafb16869ab049404ca.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 2]: /images/20221119/5a0569b1d877455087cf01abaf6dee40.png
[20210115175327232.png]: /images/20221119/2cfb21316d5a41a383bca968bb2dadd4.png
[20210115193911864.png]: /images/20221119/9c137df7096d4306bc269bc67875b291.png
[20210115201418928.png]: https://img-blog.csdnimg.cn/20210115201418928.png
[20210115202929339.png]: https://img-blog.csdnimg.cn/20210115202929339.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/2021011520343031.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ==,size_16,color_FFFFFF,t_70
[20210115205550793.png]: https://img-blog.csdnimg.cn/20210115205550793.png
[20210115211812653.png]: https://img-blog.csdnimg.cn/20210115211812653.png
[20210115213050455.png]: https://img-blog.csdnimg.cn/20210115213050455.png