四面向对象 - 2. 封装、继承和多态 - 《Scala》

1.1 封装

在Java中：属性私有化，只能通过被授权的方法才能对数据进行操作

Scala中的public属性，底层实际为private，并通过get方法 ( obj.field ) 和 set方法（ obj.field=value ）对其进行操作——在Scala中并不推荐将属性设为private，再给它设置public的set和get方法的做法 ```scala object Test07_Demo { def main(args: Array[String]): Unit = {
```
var person = new Person()
person.setName("zs")
person.printDec()
```
} }

class Person{ private var name:String = _

def setName(name:String): Unit ={ this.name = name }

def printDec(): Unit ={ println(s”name = $name , age = $age”) } }

<a name="LATnj"></a>
### 
<a name="qrqU5"></a>
###  1. 访问权限 
- [x]  默认为public，同包下
- [x]  protected，除了自身就只有子类可以访问
- [x]  private，只能在类的内部或者伴生对象中可用
- [x]  private[包名]增加包访问权限，包名下的其他类也能使用
<a name="Kj1e7"></a>
###  2.创建对象 
```scala
            val | var 对象名 [：类型] = new 类型()

     1. val :  引用对象地址不能再改变
     1. var:   可以修改引用对象的地址
     1. 自动推导变量类型不能多态，所以多态需要显示声明

3.构造器

主构造器：只能有一个辅助构造器：可以有多个（重载）

class Person2(var name:String,var age:Int){ //主构造器  public Person2（ String name，int age ）{.....}
      println("构造方法被调用")
}
class Person3{                             //相当于是空参的构造器 public Person3（）{ }
  var name:String = _ 
  var age:Int = _
  def this(age:Int){                        //辅助构造器
    this()                                                                             // 必须调用主构造器(注意：主构造器是唯一的，只有一个)
    this.age = age
  }
  def this(name:String){                    //辅助构造器
    this()
    this.name = name
  }
  def this(name:String,age:Int){            //辅助构造器
    this(name)                                                                     //可以直接调用上面声明的辅助构造器，因为上面的辅助构造器也有调用主构造器
    this.age = age
  }
}
object Test02_Demo {
  def main(args: Array[String]): Unit = {
    var p = new Person2("zs",18)
    var p2 = new Person3("zs")
    println(p2.name)
  }
}

构造器参数：未修饰（局部变量：构造方法中的一个变量）、var（成员变量）、val（成员常量）
未修饰

class Person3(name:String, age:Int){  //有参构造器                         
  var name:String = name
  var age:Int = age 
}

var

class Person3(var name:String,var age:Int){                      //有参构造器 并且 声明成员变量                            
  var habbit:String = _
  def this(name:String, age:Int,habbit:String){       //辅助构造器
    this(name,age)                                                                             // 必须调用主构造器(注意：主构造器是唯一的，只有一个)
    this.habbit = habbit
  }
}

1.1 继承

子类继承父类的属性和方法，单继承

子类需要在主构造器中调用父类的主构造器

class Person(var name:String){
            println("父类主构造器")
}
class Student(var name:String) extends Person(name){
     println("子类主构造器")
}

指定调用父类方法( super[父类名] )

trait Father1{
  def xixi(){
  }
}
trait Father2{
  def xixi(){
  }
}
class sun extends Father1 with Father2{
   def xixi(){
     super[Father2].xixi()
   }
}

1.2 多态

编译看左边 (编译检查) ，运行看右边（动态绑定） Scala中的属性和方法都是动态绑定

类型检查：var isTrue : Boolean = obj.isInstanceOf[T]

向下转型：var obj : T = obj.asInstanceOf[T]

object Test04_Demo {
  def main(args: Array[String]): Unit = {
    var s:Student1 = new Student1()
    var t:Teacher1 = new Teacher1()
    var sp:Person9 = new Student1()
    var p:Person9 = new Person9()
    println("student is person4="+ s.isInstanceOf[Person9])  //true
    println("teacher is person4="+ t.isInstanceOf[Person9])  //true
    println("person4 is student="+ sp.isInstanceOf[Student1])//true
    println("person4 is student="+ p.isInstanceOf[Student1]) //fasle
    if(sp.isInstanceOf[Student1]){
      var ss = sp.asInstanceOf[Student1]
      println(ss.name)
    }
  }
}
class Person9{
  def say(): Unit ={
    println("hello")
  }
}
class Student1 extends Person9{
  var name:String = "zs"
  override def say(): Unit = {
    println("hello,student")
  }
}
class Teacher1 extends Person9{
  override def say(): Unit = {
    println("hello,teacher")
  }
}