Scala 面向对象编程

Scala是一门完全面向对象的语言，摒弃了Java中很多不是面向对象的语法。虽然如此，但其面向对象思想和Java的面向对象思想还是一致的

一、 基础面向对象编程

1. 包

1.1 基本语法

Scala中基本的package包语法和Java完全一致

package com.atguigu.bigdata.scala

1.2 扩展语法

Java中package包的语法比较单一，Scala对此进行扩展

• Scala中的包和类的物理路径没有关系
• package关键字可以嵌套声明使用

package com
package atguigu {
    package bigdata {
        package scala {
            object ScalaPackage {
                def test(): Unit = {
                    println("test...")
                }
            }
        }
    }
}

• 同一个源码文件中子包可以直接访问父包中的内容，而无需import

package com
package atguigu {
    package bigdata {
        class Test {
        }
        package scala {
            object ScalaPackage {
                def test(): Unit = {
                    new Test()
                }
            }
        }
    }
}

• Scala中package也可以看作对象，并声明属性和函数

package com
package object atguigu {
    val name : String = "zhangsan"
    def test(): Unit = {
        println( name )
    }
}
package atguigu {
    package bigdata {
        package scala {
            object ScalaPackage {
                def test(): Unit = {
                }
            }
        }
    }
}

2. 导入

2.1 基本语法

Scala中基本的import导入语法和Java完全一致

import java.util.List
import java.util._ // Scala中使用下划线代替Java中的星号

2.2 扩展语法

Java中import导入的语法比较单一，Scala对此进行扩展

• Scala中的import语法可以在任意位置使用

object ScalaImport{
    def main(args: Array[String]): Unit = {
        import java.util.ArrayList
        new  ArrayList()   
}
}

• Scala中可以导包，而不是导类

object ScalaImport{
    def main(args: Array[String]): Unit = {
        import java.util
        new util.ArrayList()
    }
}

• Scala中可以在同一行中导入相同包中的多个类，简化代码

import java.util.{List, ArrayList}

• Scala中可以屏蔽某个包中的类

import java.util._
import java.sql.{ Date=>_, Array=>_, _ }

• Scala中可以给类起别名，简化使用

import java.util.{ArrayList=>AList}

object ScalaImport{
    def main(args: Array[String]): Unit = {
        new AList()
    }
}

• Scala中可以使用类的绝对路径而不是相对路径

import _root_.java.util.ArrayList

• 默认情况下，Scala中会导入如下包和对象

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

3. 类

面向对象编程中类可以看成一个模板，而对象可以看成是根据模板所创建的具体事物

3.1 基本语法

// 声明类：访问权限 class 类名 { 类主体内容 } 
class User {
    // 类的主体内容
}
// 对象：new 类名(参数列表)
new User()

3.2 扩展语法

Scala中一个源文件中可以声明多个公共类

4. 属性

4.1 基本语法

class User {
    var name : String = _ // 类属性其实就是类变量
    var age : Int = _ // 下划线表示类的属性默认初始化
}

4.2 扩展语法

Scala中的属性其实在编译后也会生成方法

class User {
    var name : String = _
val age : Int = 30
private val email : String = _
@BeanProperty var address : String = _
}

5. 访问权限

Scala中的访问权限和Java中的访问权限类似，但是又有区别：

private : 私有访问权限
private[包名]: 包访问权限
protected : 受保护权限，不能同包
            : 公共访问权限

6. 方法

Scala中的类的方法其实就是函数，所以声明方式完全一样，但是必须通过使用对象进行调用

object ScalaMethod{
    def main(args: Array[String]): Unit = {
        val user = new User
        user.login("zhangsan", "000000")
    }
}
class User {
    def login( name:String, password:String ): Boolean = {
        false
    }
}

7. 对象

Scala中的对象和Java是类似的

val | var 对象名 [：类型]  = new 类型()
var user : User = new User()

8. 构造方法

和Java一样，Scala中构造对象也需要调用类的构造方法来创建。并且一个类中可以有任意多个不相同的构造方法。这些构造方法可以分为2大类：主构造函数和辅助构造函数。

class User() { // 主构造函数
    var username : String = _ 
    def this( name:String ) { // 辅助构造函数，使用this关键字声明
        this() // 辅助构造函数应该直接或间接调用主构造函数
        username = name
	}
	def this( name:String, password:String ) {
	    this(name) // 构造器调用其他另外的构造器，要求被调用构造器必须提前声明
	}
}

二、高阶面向对象编程

1. 继承

和Java一样，Scala中的继承也是单继承，且使用extends关键字。

class Person {
}
class User extends Person {
}

构造对象时需要考虑构造方法的执行顺序

2. 封装

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

• 将属性进行私有化
• 提供一个公共的set方法，用于对属性赋值
• 提供一个公共的get方法，用于获取属性的值

3. 抽象

• Scala将一个不完整的类称之为抽象类。

abstract class Person {
}

• Scala中如果一个方法只有声明而没有实现，那么是抽象方法，因为它不完整。

abstract class Person {
    def test():Unit
}

• Scala中如果一个属性只有声明没有初始化，那么是抽象属性，因为它不完整。

abstract class Person {
    var name:String
}

• 子类如果继承抽象类，必须实现抽象方法或补全抽象属性，否则也必须声明为抽象的，因为依然不完整。

abstract class Person {
    var name:String
}
class User extends Person {
    var name : String = "zhangsan"
}

4. 单例对象

• 所谓的单例对象，就是在程序运行过程中，指定类的对象只能创建一个，而不能创建多个。这样的对象可以由特殊的设计方式获得，也可以由语言本身设计得到，比如object伴生对象
• Scala语言是完全面向对象的语言，所以并没有静态的操作（即在Scala中没有静态的概念）。但是为了能够和Java语言交互（因为Java中有静态概念），就产生了一种特殊的对象来模拟类对象，该对象为单例对象。若单例对象名与类名一致，则称该单例对象这个类的伴生对象，这个类的所有“静态”内容都可以放置在它的伴生对象中声明，然后通过伴生对象名称直接调用
• 如果类名和伴生对象名称保持一致，那么这个类称之为伴生类。Scala编译器可以通过伴生对象的apply方法创建伴生类对象。apply方法可以重载，并传递参数，且可由Scala编译器自动识别。所以在使用时，其实是可以省略的。

class User { // 伴生类
}
object User { // 伴生对象
    def apply() = new User() // 构造伴生类对象
}
...
val user1 = new User()// 通过构造方法创建对象
Val user2 = User.apply() // 通过伴生对象的apply方法构造伴生类对象 
val user3 = User() // scala编译器省略apply方法，自动完成调用

5. 特质

Scala将多个类的相同特征从类中剥离出来，形成一个独立的语法结构，称之为“特质”（特征）。这种方式在Java中称之为接口，但是Scala中没有接口的概念。所以scala中没有interface关键字，而是采用特殊的关键字trait来声明特质, 如果一个类符合某一个特征（特质），那么就可以将这个特征（特质）“混入”到类中。这种混入的操作可以在声明类时使用，也可以在创建类对象时动态使用。

5.1 基本语法

trait 特质名称
class 类名 extends 父类（特质1） with 特质2 with特质3

trait Operator {

}
trait DB{

}
class MySQL extends Operator with DB{

}

5.2 动态混入

object ScalaTrait{
    def main(args: Array[String]): Unit = {
        val mysql = new MySQL with Operator
        mysql.insert()
    }
}
trait Operator {
    def insert(): Unit = {
        println("insert data...")
    }
}
class MySQL {

}

5.3 初始化叠加

object ScalaTrait{
    def main(args: Array[String]): Unit = {
        val mysql = new MySQL
    }
}
trait Operator {
    println("operator...")
}
trait DB {
    println("db...")
}
class MySQL extends DB with Operator{
    println("mysql...")
}

5.4 功能叠加

object ScalaTrait {
    def main(args: Array[String]): Unit = {
        val mysql: MySQL = new MySQL
        mysql.operData()
    }
}

trait Operate{
    def operData():Unit={
        println("操作数据。。")
    }
}
trait DB extends Operate{
    override def operData(): Unit = {
        print("向数据库中。。")
        super.operData()
    }
}
trait Log extends Operate{

    override def operData(): Unit = {
        super.operData()
    }
}
class MySQL extends DB with Log {

}

6. 扩展

• 类型检查和转换

class Person{
}
object Person {
    def main(args: Array[String]): Unit = {

        val person = new Person

        //（1）判断对象是否为某个类型的实例
        val bool: Boolean = person.isInstanceOf[Person]

        if ( bool ) {
            //（2）将对象转换为某个类型的实例
            val p1: Person = person.asInstanceOf[Person]
            println(p1)
        }

        //（3）获取类的信息
        val pClass: Class[Person] = classOf[Person]
        println(pClass)
    }

• 枚举类和应用类

object Test {
    def main(args: Array[String]): Unit = {
        println(Color.RED)
    }
}

// 枚举类
object Color extends Enumeration {
    val RED = Value(1, "red")
    val YELLOW = Value(2, "yellow")
    val BLUE = Value(3, "blue")
}

// 应用类
object AppTest extends App {
    println("application");
}

• Type定义新类型
  使用type关键字可以定义新的数据数据类型名称，本质上就是类型的一个别名

object Test {
    def main(args: Array[String]): Unit = {
        type S = String
        var v : S = "abc"
    }
}