Scala的抽象类

内容：

1.理解抽象类

2.定义抽象类

3.继承抽象类

4.抽象类重写

理解抽象类

类本身就是对对象的抽象,抽象类就是对类的抽象，就是一种更加模糊的类。

--定义：抽象类是一个包含一个或多个抽象方法的类。抽象方法是不带任何实现的方法。抽象类也可以包含具体的方法和属性。

-- 目的：抽象类的主要目的是为子类提供公共的接口和部分实现，并确保子类实现抽象方法。

定义抽象类

定义一个Scala的抽象类：

package level02

/*
*  抽象类  abstract
*  1，一个抽象类(加了abstract修饰的)，不能被new
*  2，一个类不能直接来创建对象，那么这个类具体有什么用呢？做别人的父类
 */
object class011 {
  abstract class AICar {
    def autoDrive():Unit = {
      println("具体方法，自动驾驶...")
    }
  }
  class SU7 extends AICar{

  }

  def main(args: Array[String]): Unit = {
    // val car1 = new AICar()
    val su = new SU7()
    su.autoDrive()
  }
}

继承抽象类

子类继承了抽象类，它就必须去实现所有抽象属性和抽象方法

代码如下：

package level02

/*
*  抽象类  abstract
*  1，一个抽象类(加了abstract修饰的)，不能被new
*  2，一个类不能直接来创建对象，那么这个类具体有什么用呢？做别人的父类
*  3,可以定义抽象方法，在子类中去实现
 */
object class011 {
  abstract class AICar {
    // 抽象方法：没有具体的函数代码
    def autoEn():Unit
    //具体方法
    def autoDrive():Unit = {
      println("具体方法，自动驾驶...")
    }
  }
  // 在子类中，一定要实现父类所有的抽象方法
  class SU7 extends AICar{
  // 使用override去实践这个方法
    override def autoEn():Unit = {
      println(s"采用小米独家的无线充电技术，停车就可以充电")
    }
  }

  def main(args: Array[String]): Unit = {
    // val car1 = new AICar()
    val su = new SU7()
    su.autoDrive()
  }
}

抽象类重写

如果子类中对抽象类中的方法定义不满意，仍可以使用override去覆盖的。

代码如下：

package level02
/*
*  抽象类  abstract
*  1，一个抽象类(加了abstract修饰的)，不能被new
*  2，一个类不能直接来创建对象，那么这个类具体有什么用呢？做别人的父类
*  3,可以定义抽象方法，在子类中去实现
*
*  4,一个抽象类中可以有：
*     1，具体属性  val name:Sting = "小米"
*     2，具体方法
*     3，抽象属性  val name:Sting 没有具体的属性，只有属性名和类型，必须写在抽象类中
*     4，抽象方法  def autoRun():Unit
 */
object class012 {
  
  abstract class AICar() {
    val name:String

    def autoRun():Unit
  }
  class xiaomi extends AICar{
    val name:String = "xiaomi"
    def autoRun():Unit = {
      println("小米汽车，自动驾驶...")
    }
  }

  def main(args: Array[String]): Unit = {
    var car1 = new xiaomi()
    car1.autoRun()
  }
}

修改代码重写要点：

（1）抽象类中的方法可以有抽象的和非抽象的，同样属性也可以有抽象的和非抽象的。

（2）抽象方法可以实现，而非抽象方法可以继承或重写。

（3）属性中对于抽象成员是必须要实现的，而非抽象成员可以继承或重写。

代码如下：

package level02

/*
*  抽象类  abstract
*  1，一个抽象类(加了abstract修饰的)，不能被new
*  2，一个类不能直接来创建对象，那么这个类具体有什么用呢？做别人的父类
*  3,可以定义抽象方法，在子类中去实现
*
*  4,一个抽象类中可以有：
*     1，具体属性  val name:Sting = "小米"
*     2，具体方法  def autoRun():Unit = {}
*     3，抽象属性  val name:Sting 没有具体的属性，只有属性名和类型，必须写在抽象类中
*     4，抽象方法  def autoRun():Unit
*           在子类中，要有具体的实现。
 */
object class013 {

  abstract class AICar() {
    //1,具体属性
    var name:String = "car"
    val color:String = "black"
    //2,具体方法
    def run():Unit = {
      println("run...")
    }
    //3,抽象属性，没有属性值
    var price:Double
    //4,抽象方法，没有方法体
    def autoRun():Unit
  }

  class XIAOMI extends AICar {
    //重写
    // 1,具体属性
    name = "小米"
    override val color = "流光紫" // 对于val属性，要添加override

    // 2,具体方法
    override def run(): Unit = {
      println("小米 run...")
    }

    //实现
    // 3,实现 抽象属性
    var price = 28.8

    // 4,实现 抽象方法
    def autoRun(): Unit = {
      println("小米自动驾驶...")
    }
  }
    def main(args: Array[String]): Unit = {
      var c1 = new XIAOMI()
      c1.autoRun()
      c1.run()
      println(c1.name)
      println(c1.color)

  }
}