God of spark is Scala---面向对象编程(中级篇)

一. 包

1. Scala包的基本介绍

和Java一样，Scala中管理项目可以使用包，但Scala中的包的功能更加强大，使用也相对复杂些，下面我们学习Scala包的使用和注意事项。

2. Scala包的特点概述

• 基本语法

package 包名

• Scala包的三大作用(和Java一样)

1. 区分相同名字的类
2. 当类很多时,可以很好的管理类
3. 控制访问范围

• Scala中包名和源码所在的系统文件目录结构要可以不一致，但是编译后的字节码文件路径和包名会保持一致

3. Scala包注意事项和使用细节

1）scala进行package 打包时，可以有如下形式：

2）包也可以像嵌套类那样嵌套使用（包中有包）, 这个在前面的第三种打包方式已经讲过了，在使用第三种方式时的好处是：程序员可以在同一个文件中，将类(class / object)、trait 创建在不同的包中，这样就非常灵活了

3）作用域原则：可以直接向上访问。即: Scala中子包中直接访问父包中的内容, 大括号体现作用域。(提示：Java中子包使用父包的类，需要import)。在子包和父包 类重名时，默认采用就近原则，如果希望指定使用某个类，则带上包名即可

package com.atguigu{
  //这个类就是在com.atguigu包下
  class User{
  }
  //这个类对象就是在Monster$ , 也在com.atguigu包下
  object Monster {
  }
  class Dog {
  }
  package scala {
    //这个类就是在com.atguigu.scala包下
    class User{
    }
    //这个Test 类对象
    object Test {
      def main(args: Array[String]): Unit = {
          //子类可以直接访问父类的内容
          var dog = new Dog()
          println("dog=" + dog)
          //在子包和父包 类重名时，默认采用就近原则.
          var u = new User()
          println("u=" + u)
          //在子包和父包 类重名时，如果希望指定使用某个类，则带上包路径
          var u2 = new com.atguigu.User()
          println("u2=" + u2)
      }
    }
  }
}

4）父包要访问子包的内容时，需要import对应的类等

5）可以在同一个.scala文件中，声明多个并列的package(建议嵌套的pakage不要超过3层)

6）包名可以相对也可以绝对，比如，访问BeanProperty的绝对路径是：_root_.scala.beans.BeanProperty ，在一般情况下：我们使用相对路径来引入包，只有当包名冲突时，使用绝对路径来处理

package com.atguigu.scala2
class Manager( var name : String ) {
  //第一种形式
  //@BeanProperty var age: Int = _
  //第二种形式, 和第一种一样，都是相对路径引入
  //@scala.beans.BeanProperty var age: Int = _
  //第三种形式, 是绝对路径引入，可以解决包名冲突
  @_root_. scala.beans.BeanProperty var age: Int = _
}
object TestBean {
  def main(args: Array[String]): Unit = {
    val m = new Manager("jack")
    println("m=" + m)
  }}

4. 包对象

• 基本介绍：
  包可以包含类、对象和特质trait，但不能包含函数/方法或变量的定义。这是Java虚拟机的局限。为了弥补这一点不足，scala提供了包对象的概念来解决这个问题。
• 包对象的应用案例

package com.atguigu {  
  //每个包都可以有一个包对象。你需要在父包(com.atguigu)中定义它,且名称与子包一样。
  package object scala {
    var name = "jack"
    def sayOk(): Unit = {
      println("package object sayOk!")
    }
  }
  package scala {
    class Test {
      def test() : Unit ={
        //这里的name就是包对象scala中声明的name
        println(name)
        sayOk()//这个sayOk 就是包对象scala中声明的sayOk
      }
    }
    object TestObj {
      def main(args: Array[String]): Unit = {
        val t  = new Test()
        t.test()
        //因为TestObje和scala这个包对象在同一包，因此也可以使用
        println("name=" + name)
      }}}}

• 包对象的注意事项
  1）每个包都可以有一个包对象。你需要在父包中定义它
  2）包对象名称需要和包名一致，一般用来对包的功能补充

二. 包的可见性

1. Scala中包的可见性介绍:

在Java中，访问权限分为: public，private，protected和默认。在Scala中，你可以通过类似的修饰符达到同样的效果。但是使用上有区别。

object Testvisit {
  def main(args: Array[String]): Unit = {
    val  c = new Clerk()
    c.showInfo()
    Clerk.test(c)
  }}
class Clerk {
  var name : String = "jack"
  private var sal : Double = 9999.9
  def showInfo(): Unit = {
    println(" name " + name + " sal= " + sal)
  }}
object Clerk{
  def test(c : Clerk): Unit = {
    //这里体现出在伴生对象中，可以访问c.sal
    println("test() name=" + c.name + " sal= " + c.sal)
  }}

2. Scala中包的可见性和访问修饰符的使用

1）当属性访问权限为默认时，从底层看属性是private的，但是因为提供了xxx_$eq()[类似setter]/xxx()[类似getter] 方法，因此从使用效果看是任何地方都可以访问)
2）当方法访问权限为默认时，默认为public访问权限
3）private为私有权限，只在类的内部和伴生对象中可用
4）protected为受保护权限，scala中受保护权限比Java中更严格，只能子类访问，同包无法访问 (编译器)
5）在scala中没有public关键字,即不能用public显式的修饰属性和方法。
6）包访问权限（表示属性有了限制。同时包也有了限制），这点和Java不一样，体现出Scala包使用的灵活性。

三. 包的引入

1. Scala引入包基本介绍

Scala引入包也是使用import, 基本的原理和机制和Java一样，但是Scala中的import功能更加强大，也更灵活。

因为Scala语言源自于Java，所以java.lang包中的类会自动引入到当前环境中，而Scala中的scala包和Predef包的类也会自动引入到当前环境中，即其下面的类可以直接使用。

如果想要把其他包中的类引入到当前环境中，需要使用import语言。

2. Scala引入包的细节和注意事项

1）在Scala中，import语句可以出现在任何地方，并不仅限于文件顶部，import语句的作用一直延伸到包含该语句的块末尾。这种语法的好处是：在需要时在引入包，缩小import 包的作用范围，提高效率。

2）Java中如果想要导入包中所有的类，可以通过通配符*，Scala中采用下 _

3）如果不想要某个包中全部的类，而是其中的几个类，可以采用选取器(大括号)

4）如果引入的多个包中含有相同的类，那么可以将不需要的类进行重命名进行区分，这个就是重命名

5）如果某个冲突的类根本就不会用到，那么这个类可以直接隐藏掉

四. 面向对象编程的三大特征

1. 基本介绍

面向对象编程有三大特征：封装、继承和多态

2. 封装介绍

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

• 封装的实现步骤
  1）将属性进行私有化
  2）提供一个公共的set方法，用于对属性判断并赋值 def setXxx(参数名 : 类型) : Unit = { //加入数据验证的业务逻辑 属性 = 参数名 }
  3）提供一个公共的get方法，用于获取属性的值 def getXxx() [: 返回类型] = {
  return 属性
  }

• 快速入门案例
  

3. 继承介绍

• Scala继承的基本语法

class 子类名 extends 父类名  { 类体 }

• Scala继承快速入门
  编写一个Student 继承 Person的案例，体验一下Scala继承的特点
  

4. 多态介绍

• 基本介绍
  和java相似，参考java的即可