详解 Scala 面向对象相关知识

一、包

1. 作用

• 区分相同名字的类
• 当类很多时，可以很好的管理类
• 控制访问范围

2. 声明语法

// 第一种：与 Java 一致，以 . 作为层级划分
package package_name

// 第二种：以 {} 作为层级划分
/*
	1. 一个源文件中可以声明多个 package
	2. 子包中的类可以直接访问父包中的内容，而无需导包
*/
package package_level1 {
   
   
    package package_level2 {
   
   
    	...
	}
}

3. 命名规则

• 只能包含数字、字母、下划线，但不能用数字开头，也不要使用关键字
• 一般按照 com.公司名.项目名.业务模块名 划分层级

package com {
   
   
    import com.tencent.Inner //父包访问子包需要导包
    object Outer {
   
   
        val out: String = "out"
        def main(args: Array[String]): Unit = {
   
   
        	println(Inner.in)
    	}
    }
    
    package tencent {
   
   
        object Inner {
   
   
            val in: String = "in"
            def main(args: Array[String]): Unit = {
   
   
            	println(Outer.out) //子包访问父包无需导包
            }
        }
    }
}

package com {
   
   
	package alibaba {
   
   
        
    }
}

4. 包对象

• 概念：在 Scala 中可以为每个包定义一个与包同名的包对象，定义在包对象中的成员，可以作为其对应包下所有 class 和 object 的共享变量，可以被直接访问

• 案例：

  /**
  	Java 风格包，包名为 com.abc.demo
  	包对象的源文件名：package.scala
  	com.abc.demo 下的 class 和 object 都能访问包对象的变量和方法
  */
  package object demo {
       
       
      val commonVal: String = "家里蹲"
      def commonFunc(): Unit = {
       
       
          println(s"他们正在${
         
         commonVal}")
      }
  }
  
  /**
  	嵌套风格包，包层级为 com abc demo
  	包对象可与包定义在同一文件中，但是要保证包对象与包声明在同一作用域中
  */
  package com {
       
       
      package abc {
       
       
          package demo {
       
       
              object TestDemo {
       
       
                  def main(args: Array[String]): Unit = {
       
       
                      println(school)
                  }
              }
          }
          
          // 包对象与包声明要在同一作用域
          package object demo {
       
       
              val school: String = "AgriculturalUniversity"
          }
      }
  }
  
  // 包对象定义在与包不同的作用域，包对象变量访问不到
  /*
  package object demo {
      val school: String = "AgriculturalUniversity"
  }
  */
  
  

5. 导包

• 默认导入的包：

  • import java.lang._
  • import scala._
  • import scala.Predef._

• 导包语法：

  // 1. 在源文件文件首行导入包，与 Java 一致
  import com.abc.Fruit
  package com.abc.demo
  object Test {
       
       
      ...
  }
  
  // 2. 局部导入：在使用时导入，仅在当前作用域可以使用
  package com.abc.demo
  object Test {
       
       
      def main(args: Array[String]): Unit = {
       
       
          import com.abc.Fruit
          ...
      }
      
      def f1(): Unit = {
       
       
          // Fruit 类访问不到
      }
  }
  
  // 3. 通配符导入
  import java.util._
  
  // 4. 给类起名
  import java.util.{
       
       ArrayList=>JL}
  
  // 5. 导入相同包的多个类
  import java.util.{
       
       HashSet, ArrayList}
  
  // 6. 屏蔽类
  import java.util.{
       
       ArrayList =>_,_}
  
  
  // 7. 导入包的绝对路径
  new _root_.java.util.HashMap
  
  

• 案例说明：

  案例	说明
  import com.abc.Fruit	引入 com.abc 包下 Fruit（class 和 object）
  import com.abc._	引入 com.abc 下的所有成员
  import com.abc.Fruit._	引入 Fruit(object) 的所有成员
  import com.abc.{Fruit,Vegetable}	引入 com.abc 下的 Fruit 和 Vegetable
  import com.abc.{Fruit=>Shuiguo}	引入 com.abc 包下的 Fruit 并更名为 Shuiguo
  import com.abc.{Fruit=>Shuiguo,_}	引入 com.abc 包下的所有成员，并将 Fruit 更名为 Shuiguo
  import com.abc.{Fruit=>_,_}	引入 com.abc 包下屏蔽 Fruit 类
  new _root_.java.util.HashMap	引入的 Java 的绝对路径

二、类和对象

1. 概念

• 类：对象的抽象或模板
• 对象：表示具体的事物

2. 语法

object Test {
   
   
    def main(args: Array[String]): Unit = {
   
   
        val student = new Student()
        // student.name // 报错，私有属性不能访问
        
        println(student.age)
        println(student.gender)
        student.age = 18
        println(student.age)
        
        println(student.getStuId)
        student.setStuId("002")
		println(student.getStuId)
    }
}

/*
	声明类语法：
	[修饰符] class class_name {
		属性
		方法
	}
*/
class Student {
   
    // 默认为 public，不能显示的用 public 修饰
    private val name: String = "李雷" // 属性默认为 public
    var age: Int = _ // _ 表示属性默认值，Int 为 0，String 为 null, Boolean 为 false
    var gender: String = _ // _ 只能给 var 型变量赋默认值
    
    @BeanProperty
    var stuId: String = "001" // @BeanProperty 可以自动生成规范的 setter/getter 方法
}

// 一个 scala 源文件可以声明多个类
class teacher {
   
   
    ...
}

三、封装

1. 概念

封装是把抽象出的数据和对数据的操作封装在一起，数据被保护在内部，程序的其它部分只有通过被授权的操作（成员方法），才能对数据进行操作

2. 对比 Java

• Java 封装：
  • 将属性进行私有化
  • 提供一个公共的 set 方法，用于对属性赋值
  • 提供一个公共的 get 方法，用于获取属性的值
• Scala 封装：
  • Scala 中的 public 属性，底层实际为 private，并通过 get 方法（obj.field()）和 set 方法（obj.field_=(value)）对其进行操作，即底层已经实现封装操作
  • 通过 @BeanProperty 注解实现显式的 getter 和 setter 方法可以兼容 Java 框架

3. 访问权限

• Scala 中属性和方法的默认访问权限为 public，但 Scala 中无 public 关键字
• private 为私有权限，只在类的内部和伴生对象中可访问
• protected 为受保护权限，Scala 中受保护权限比 Java 中更严格，同类、子类可以访问，同包无法访问(与 Java 不同)
• private[包名] 增加包访问权限，包名下的其他类也可以访问

package com.abc.scala.test 

object Person {
   
   
    def main(args: Array[String]): Unit = {
   
   
        val person = new Person()
        person.say()
        println(person.name)
        println(person.age)
    }
}

class Person {
   
   
    private var name: String = "bobo"
    protected var age: Int = 18
    var address: String = "幸福里"
    private[test] var sex: String = "男"
    
    def say(): Unit = {
   
   
    	println(s"$name $age $address $sex")
    }
}

class Worker extends Person {
   
   
    def test(): Unit = {
   
   
        // this.name // error
        this.age 
        this.sex
    }
    
    override def say(): Unit = {
   
    // 重写父类方法
        println(s"$age $address $sex")
    }
}

class Animal {
   
   
    def test: Unit = {
   
   
        // new Person().age // error
    	new Person().sex
    }
}

pac