Scala的面向对象
Scala的面向对象
1、类
一、概述
1）scala中的类和java中基本相似。java
2）scala中的类一样经过class来进行声明。网络
3）scala中的类一样能够具备成员变量和成员方法。ide
4）scala中的类一样能够经过new关键字来建立出对象。函数
5）Scala中的类的成员默认的访问权限是public。也能够加private或protected。工具
6）当成员变量或成员方法是私有属性时，外部将不能直接访问，这个同java同样。this
1．建立类
示例：spa
class Person() {
//建立一个类，并定义类里的两个成员变量name和age。以及一个成员方法 eat()
//须要注意的是：scala中变量(var)声明时须要指定初始值，
private var name = “”
private var age = 0
def eat(){
println("eat")
}
}
2．类的构造
1>主构造器
和java不一样，scala中的类不须要明确声明一个构造器，而是直接将构造参数经过构造参数列表声明为类的一部分。.net
而直接写在类的体中的既不是类的成员变量也不是成员函数的部分，会自动收集为构造函数的体。scala
scala声明主构造的形式是在类右侧声明，若是不声明，Scala也提供了默认构造器。注意：当显示声明主构造器以后，默认的空构造器失效。code
示例：
//scala中的类不须要明确声明一个构造器，而是直接将构造参数经过构造参数列表声明为类的一部分
class Person(v1: String, v2: Int) {
//建立一个类，并定义类里的两个成员变量name和age。以及一个成员方法 eat()
//须要注意的是：scala中变量(var)声明时须要指定初始值，
private var name = v1
private var age = v2
//而直接写在类的体中的既不是类的成员变量也不是成员函数的部分，会自动收集为构造函数的体。
//当调用构造方法时，会打印 …… 和***
println("…………")
println("***")
}
2>辅助构造器
有些时候，一个类里须要多个构造器。scala里除主构造器以外的构造器被称为辅助构造器。
1）Scala的辅助构造器定义开始于def this()。
2）Scala里每一个辅助构造器的第一个动做都是调用同类的构造器。
示例：
class Person(v1: String, v2: Int) {
private var name = v1
private var age = v2
//Scala的辅助构造器定义开始于 def this()
//Scala里每一个辅助构造器的第一个动做都是调用同类的构造器
def this(v1: String) = {
this(v1, 0)
}
def this(v2: Int) {
this("", v2)
}
def this() {
this("", 0)
}
}
一个完整的示例：
class Person(v1: String, v2: Int) {
private var name = v1
private var age = v2
println("…………")
println("***")
def this(v1: String) = {
this(v1, 0)
}
def this(v2: Int) {
this("", v2)
}
def this() {
this("", 0)
}
def getName() = {
this.name
}
def setName(name: String) = {
this.name = name
}
def getAge() = {
this.age
}
def setAge(age: Int) = {
this.age = age
}
def say() {
println("say word")
}
}
二、单例对象(object)
1）scala中的类(class)不能定义静态成员（或静态方法），而代之以定义单例对象来替代。
2）单例对象须要经过object关键字来声明。
3）一个单例对象能够单独存在，也能够绑定到一个类上。
4）单例对象当中的全部方法，均可以不须要建立对象而直接经过object单例对象的名字直接来调用，用起来感受就像一个静态方法同样。
5）当一个单例对象和某个类写在同一个源文件中且共享同一个名字时，他们就产生了一个绑定的关系。此时单例对象称为该类的伴生对象。类称为该对象的伴生类。
6）类和他的伴生对象能够互相访问其私有成员。
7）以伴生的方式为类增长静态成员成为了可能。
8）单例对象不能new，所以也没有构造参数。
9）能够把单例对象看成是java中可能会用到的静态方法工具类。
10）做为程序的入口main方法必须是静态的，因此main方法必须处在一个单例对象中，而不能写在一个类中。
11）单例对象在第一次被访问时才会被初始化。
示例：
class Person(v1: String, v2: Int) {
//此私有变量，伴生类能够访问
private var name = v1
private var age = v2
}
//Person的单利对象，也即伴生类Person
object Person {
def shownamespace() {
val p = new Person
//能够访问类的私有变量
println(p.name)
}
def eat() {
println("eat")
}
}
三、抽象类
scala中一样支持抽象类的使用，抽象类的内部能够包含抽象方法和非抽象方法。抽象类不容许被实例化，抽象类主要是用来被继承的。
Scala的抽象类同java，经过abstract关键字来定义。抽象方法的特色：没有｛｝方法体。
示例：
abstract class Teacher {
//抽象方法，返回值为Unit
def makeNote()
//抽象方法，返回值为String
def teach():String
def compute():Int
//实体方法
def say(){}
}
四、特质trait
1）能够类比java中的接口，可是又和接口很是不同，特质至关于java中的接口，java中称为类实现了接口，scala中称为混入了特质。
2）和java中的接口不一样的是，scala中的特质能够包含具备方法体的方法。
和抽象类不一样的地方在于，scala的类只能单继承，可是能够多混入，利用这种方式能够实现相似c语言中多继承的特性。
3）在类中能够经过extends或with关键字来让类混入特质，若是类没有明确继承父类，extends关键字没有被占用就可使用extends。
4）可是如已经使用了extends显示的继承了父类，再向混入特质就要用with关键字了。
一个类的声明中只能有一个extends，可是能够有多个with。
示例：
trait Dance {
def Balei()
def floor()
//trait相似于java的接口，但能够作具体方法的实现
def eat(){}
}
trait Driver {
def shache():String
def piaoyi()
}
//scala中，只能继承一个父类，可是能够混入多个特质（trait)
//须要实现特质中未实现的方法
//此外，须要注意的是，若是未继承任何类或抽象类，在混入特质时，
//好比有且仅有一个特质须要用extends来混入，而其余特质用with混入
class ZhangTeacher extends Dance with Driver {
def Balei(): Unit = {
???
}
def floor(): Unit = {
???
}
def piaoyi(): Unit = {
???
}
def shache(): String = {
???
}
}
五、样例类case class
1）只要在声明类时，在class关键字前加上case关键字，这个类就成为了样例类。样例类必需要显式的声明一个主构造器。
2）当样例类声明一个主构造器后，会默认隐式的声明一个空构造器。
3）样例类默认实现序列化接口。
序列化的两个做用：①数据持久化；②网络数据传输。
4）样例类默认自动覆盖toString、equals、hashCode方法。
5）样例类不须要new能够直接生成对象。
示例：
//须要声明一个主构造器，主构造器能够是一个空构造器
case class Item(v1:Int,v2:String) {
var id=v1
var title=v2
}
//样例类不须要new，而且隐式的含有空构造器
val v1=Item(1,"phone")
//> v1 : Item = Item(1,phone)
val v2=Item
//> v2 : Item.type = Item
六、option
在Scala中用来表示一个结果，它可能有值，也可能没有值，它有两个子Option。一个是Some，一个是None。
示例：
def f1(a:Int,b:Int)={
if(b!=0){
Some(a/b)
}else{
None
}
}
//表示若是有正确结果，返回正确结果，没有则返回指定的默认值
f1(4,0).getOrElse("error")
七、包的引用
相似于java中经过import关键字引入包/类，scala也能够实现这种方式引入，可是更强大一些。
1）scala中的import能够出如今代码任何地方。
2）scala中的import时能够指的是对象和包。
3）scala中的import能够重命名或隐藏一些被引用的成员。
4）scala默认会自动引入以下三个包下的全部内容。
java.lang：java中的通用类。
scala._：scala提供的通用类 主要是基本类型除了String。
Predef._：提供了单例对象 以及一些经常使用方法 print println。
示例：
import cn.tedu._
import cn.tedu.{Apple,Orange}
2、面向对象
一、重写和重载
1）重写是指覆盖父类中的方法来在子类中作其余事项。
格式：
override def 父类方法名 参数列表 返回值 方法体
2）重载是指在同一个类中提供方法名相同可是参数不一样的方法和java中基本一致。
示例：
二、final
能够用在成员变量、成员方法、类自己上，做用和java中相同。
三、多态
示例：
object Demo13{
def main(args: Array[String]): Unit = {
val t1:Teacher=new TeacherChen("chen",32)
val t2:Teacher=new TeacherLiu("liu",32)
}
}
四、泛型
基本和java中相同，不一样的是，泛型是用方括号引发来的。
val arr = Array[String]();
上一篇：Scala中的集合类型