Scala--第六天

一、Scala程序的运行方式

　　1.main方法：只可以在单例对象或伴生对象中定义

object test1 {
  
  def main(args: Array[String]): Unit = {
    println("我是main主入口")
  }
  //我是main主入口
  
}

　　2.App Trait(特质)：继承自App类

object test1 extends App {
  println("我是特质运行方式")
  //我是特质运行方式
  
}

二、继承 extends

　　1.在Scala中继承是单根体系，所有类型都只有一个父类

  class Person {}

  class User {
    var name = "cmx"
  }

  def main(args: Array[String]): Unit = {
    var a = new User()
    println(a.name)
  }

　　2.继承后m,父类中的成员属性和方法，子类都可以继承下来

  class Person {
    var name = "cmx"

    def func = println("我是一个方法")
  }

  class User extends Person {

  }

  def main(args: Array[String]): Unit = {
    var user = new User
    println(user.name)
    user.func
    //cmx
    //我是一个方法
  }

　　3.private，protected 访问修饰词依据有效

　　　　private：只可以在本类中使用，子类中用不了

　　　　protected：只可以在本类中或子类中使用，外部用不了

　　4.重写/覆盖：子类可以重写父类的属性和方法（当然子类可以自己定义新的属性与方法，这里不做演示）

  class Person {
    //注意重写的属性 定义时关键字要用val
    val name = "cmx"

    def func = println("我是一个方法")
  }

  class User extends Person {
    override val name = "cmx01"

    override def func = println("我是子类的func方法")
  }

  def main(args: Array[String]): Unit = {
    var user = new User
    println(user.name)
    user.func
    //cmx01
    //我是子类的func方法
  }

　　5.类和单例对象均可以继承一个类

  class Person {
    var name = "cmx"

    def func = println("我是一个方法")
  }

  object User extends Person {

  }

  def main(args: Array[String]): Unit = {
    println(User.name)
    User.func
    //cmx
    //我是一个方法
  }

 　　6.super 关键字：子类可以通过super 访问父类公开的和 protected 修饰的成员方法，但是在Scala中不可以访问成员属性

　　　　作用：表达概念更清晰

　　　　　　　如果在覆盖情况下，通过super关键字 明确使用父类的方法

  class Cmx {
    var name = "cmx"
    protected var age = 11

    def func = {
      println("我是父类的方法")
    }
  }

  class Cmx01 extends Cmx {
    override def func = {
      println("我是子类覆盖父类的方法")
    }

    def get_func = {
      func
      super.func
    }
  }

  def main(args: Array[String]): Unit = {
    var a = new Cmx01
    a.get_func
    //我是子类覆盖父类的方法
    //我是父类的方法
  }

三、多态性

　　特点：1.用父类型的变量接收子类行的对象

　　　　　2.多态在调用过程中，只可以调用父类定义的方法

　　　　　3.在运行时，若子类重写（覆盖）了父类的方法，会执行子类的方法

　　注意：定义多态的对象时不能使用类型推导

  class Cmx {
    def func = {
      println("我是父类的方法1")
    }

    def func1 = {
      println("我是父类的方法2")
    }
  }

  class Cmx01 extends Cmx {
    override def func = {
      println("我是子类覆盖父类的方法1")
    }

    def func2 = {
      println("我是子类自定义的方法1")
    }

  }

  def main(args: Array[String]): Unit = {
    var a: Cmx = new Cmx01
    //多态变量 使用父类方法，却被子类覆盖，最后调用子类
    a.func
    //结果
    //我是子类覆盖父类的方法1

    //多态变量，调用父类的方法
    a.func1
    //结果
    //我是父类的方法2

    //当多态变量欲调用子类自定义的方法时 ，报错
    a.func2
    //Error:(45, 7) value func2 is not a member of cmx_test.test1.Cmx
    //    a.func2
  }

　　多态性的好处：解耦合；增加通用性

  class Animal {
    def eat: Unit = {
      println("动物吃东西")
    }
  }

  class Dog extends Animal {
    override def eat: Unit = {
      println("狗吃骨头")
    }
  }

  class Cat extends Animal {
    override def eat: Unit = {
      println("猫吃猫粮")
    }
  }

  def get_eat(animal: Animal): Unit = {
    animal.eat
  }

  def main(args: Array[String]): Unit = {
    //解耦合
    //    var a: Animal = new Dog
    //    a.eat
    //狗吃骨头

    //增加通用性
    get_eat(new Dog)
    get_eat(new Cat)
    //狗吃骨头
    //猫吃猫粮
  }

　　类型转换：在多态类型中，把父类型转换成子类型

  class Animal {
    def eat: Unit = {
      println("动物吃东西")
    }
  }

  class Dog extends Animal {
    override def eat: Unit = {
      println("狗吃骨头")
    }

    def jiao: Unit = {
      println("会叫")
    }
  }

  def main(args: Array[String]): Unit = {
    var a: Animal = new Dog
    if (a.isInstanceOf[Dog]) {
      var b = a.asInstanceOf[Dog]
      b.jiao
    }23   }

　　isInstanceOf 不能准确的判断出 一个类型 是具体的子类 还是 父类

  class Animal {
    def eat: Unit = {
      println("动物吃东西")
    }
  }

  class Dog extends Animal {
    override def eat: Unit = {
      println("狗吃骨头")
    }

    def jiao: Unit = {
      println("会叫")
    }
  }

  def main(args: Array[String]): Unit = {
    var a: Animal = new Dog
    println(a.isInstanceOf[Dog])
    println(a.isInstanceOf[Animal])
    //true
    //true

    //使用以下方法比较严谨
    println(a.getClass==classOf[Dog])
    //true
    //判断a的实际类型
    println(a.getClass)
    //class cmx_test.test1$Dog
    //判断类型的实际类型
    println(classOf[Animal])
    //class cmx_test.test1$Dog

四、抽象类

　　定义：在定义类时，引入abstract 关键字的类叫做抽象类

　　特点：1.不可实例化对象

　　　　　2.抽象类中可以定义普通方法和属性，也可以定义抽象方法和属性

　　　　　3.有抽象方法，属性的类时抽象类，但抽象类可以没有抽象方法和抽象属性

　　　　　4.抽象类通过子类继承实现自己的价值，但是其中的抽象方法和抽象属性必须全部重写，不然该类依然是个抽象类，不可以实例化

　　开发的价值：若一个类，仅仅是一个抽象的概念，那么我们就可以把它定义为抽象类，并通过子类来进行使用

  abstract class Shape {
    //抽象属性定义
    //val name: String
    var name: String

    //抽象方法定义
    def area: Double
  }

  class Cycle(var rate: Double) extends Shape {
    //重写的抽象属性（这里和普通的重写不同，使用var/val关键字均可）
    //override val name = "cmx"
    override var name = "cmx"

    //重写的抽象方法
    override def area: Double = {
      rate * rate * Math.PI
    }
  }

  class Rect(var length: Double, var  Double) extends Shape {
    //override val name = "cmx01"
    override var name = "cmx01"

    override def area: Double = {
      length * width
    }
  }
  
  //利用多态性：用父类行接受子类的对象
  def test(s: Shape): Double = {
    s.area

  }

  def main(args: Array[String]): Unit = {
    println(test(new Cycle(10.0)))
    println(test(new Rect(10.0, 14.0)))
    //314.1592653589793
    //140.0
  }