Scala-09：面向对象02-三大特性

Scala-09：面向对象02-三大特性

一、类的封装

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

封装可以简单的看做是私有化属性和方法

先回顾一下Java 的封装，进行对比

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

Scala 中的 public 属性，底层实际为 private，并通过 get 方法（obj.field()）和 set 方法（obj.field_=(value)）对其进行操作。所以 Scala 并不推荐将属性设为 private，再为其设置public 的 get 和 set 方法的做法。 但由于很多 Java 框架都利用反射调用 getXXX 和 setXXX 方法，有时候为了和这些框架兼容，也会为 Scala 的属性设置 getXXX 和 setXXX 方法（通过@BeanProperty 注解实现）。

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

（1）Scala 中属性和方法的默认访问权限为 public，但 Scala 中无 public 关键字。

（2）private 为私有权限，只在类的内部和伴生对象中可用。

（3）protected 为受保护权限，Scala 中受保护权限比 Java 中更严格，同类、子类可以访问，同包无法访问。

（4）private[包名]增加包访问权限，包名下的其他类也可以使用

class Person { 
 
    private var name: String = "bobo" 
    protected var age: Int = 18 
    private[test] var sex: String = "男" 
 
    def say(): Unit = { 
        println(name) 
    } 
} 
 
 
object Person { 
 
    def main(args: Array[String]): Unit = { 
 
        val person = new Person 
 
        person.say() 
 
        println(person.name) 
 
        println(person.age) 
    } 
} 
 
 
class Teacher extends Person { 
 
    def test(): Unit = { 
        this.age 
        this.sex 
    } 
} 
 
class Animal { 
    def test: Unit = { 
        new Person().sex 
    } 
} 

二、继承和多态

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

1：子类继承父类的属性和方法

2：继承的调用顺序：父类构造器->子类构造器

class Person(nameParam: String) { 
 
    var name = nameParam 
    var age: Int = _ 
 
    def this(nameParam: String, ageParam: Int) { 
        this(nameParam) 
        this.age = ageParam 
        println("父类辅助构造器") 
    } 
 
    println("父类主构造器") 
} 
 
 
class  Emp(nameParam:  String,  ageParam:  Int)  extends 
Person(nameParam, ageParam) { 
 
    var empNo: Int = _ 
 
    def this(nameParam: String, ageParam: Int, empNoParam: Int) { 
        this(nameParam, ageParam) 
        this.empNo = empNoParam 
        println("子类的辅助构造器") 
    } 
    println("子类主构造器") 
} 
 
object Test { 
    def main(args: Array[String]): Unit = { 
        new Emp("z3", 11,1001) 
    } 
} 

3：动态绑定

Scala 中属性和方法都是动态绑定，而 Java 中只有方法为动态绑定。

4：类的多态

多态就是多种形态，子类继承父类之后，还可以重写父类中的方法和属性

class Person { 
    val name: String = "person" 
 
    def hello(): Unit = { 
        println("hello person") 
    } 
} 
 
class Teacher extends Person { 
 
    override val name: String = "teacher" 
 
    override def hello(): Unit = { 
        println("hello teacher") 
    } 
} 
 
object Test { 
    def main(args: Array[String]): Unit = { 
        val teacher: Teacher = new Teacher() 
        println(teacher.name) 
        teacher.hello() 
 
        val teacher1:Person = new Teacher 
        println(teacher1.name) 
        teacher1.hello() 
    } 
}