Scala之高阶面向对象编程

本文主要是介绍Scala之高阶面向对象编程，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

Scala之高阶面向对象编程

---

---

写在前面

• 操作系统：Windows10
• JDK版本：jdk1.8
• Maven版本：Maven-3.5.4
• Scala版本：Scala-2.12.11
• IDE工具：IntelliJ IDEA 2019.2.3

继承

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

class Person {}class User extends Person {}

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

封装

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

• 将属性进行私有化

• 提供一个公共的set方法，用于对属性赋值

• 提供一个公共的get方法，用于获取属性的值

抽象

• 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 = "whybigdata"
}

单例对象

• 所谓的单例对象，就是在程序运行过程中，指定类的对象只能创建一个，而不能创建多个。这样的对象可以由特殊的设计方式获得，也可以由语言本身设计得到，比如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方法，自动完成调用

特质

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

基本语法

trait 特质名称

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

trait Operator {}trait DB{}class MySQL extends Operator with DB{}

动态混入（方便扩展程序功能）

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

初始化叠加

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

功能叠加

object ScalaTrait {def main(args: Array[String]): Unit = {val mysql: MySQL = new MySQLmysql.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 {}

扩展

• 类型检查和转换

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 = Stringvar v : S = "xyz"}
} 

全文结束！

这篇关于Scala之高阶面向对象编程的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---