Scala中的抽象类🎇抽象类 ✨定义：抽象类是一个包含一个或多个抽象方法的类。抽象方法是不带任何实现的方法。抽象类也

🎇抽象类

✨定义：

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

✨目的：

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

🎇定义抽象类

定义抽象属性：var|val 属性名:类型一个属性没有初始化，没有值
定义抽象方法：def 方法名():String 只声明没有实现方法。

✨示例代码：

object day26 {
  /*
    抽象类 abstract
    1.一个抽象类（加了abstract修饰的），不能被new
      一个抽象类，不能被创建对象，这个类具体的作用==（做别人的父类）
    2.可以定义抽象方法，在子类中去实现
   */
   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.autoEn()
  }
}

✨运行结果：

采用小米独家的无线充电技术，停车就可以充电

🎇继承抽象类

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

package TestAbstract

abstract class AICar(){
  def autoRun():Unit
  var name:String
}

class XiaoMi extends AICar(){
  def autoRun(): Unit = {
    println(s"New Car  $name auto dirve")
  }
  var name: String = "小米"
}

object Main {
  def main(args: Array[String]): Unit = {
    var nc = new XiaoMi()
    nc.autoRun()
  }
}

🎇抽象类重写

抽象类中的方法可以有抽象的和非抽象的，同样属性也可以有抽象的和非抽象的。
抽象方法可以实现，而非抽象方法可以继承或重写。
属性中对于抽象成员是必须要实现的，而非抽象成员可以继承或重写。

✨示例代码：

object day27 {
  /*
    抽象类 abstract
    1.一个抽象类（加了abstract修饰的），不能被new
      一个抽象类，不能被创建对象，这个类具体的作用==（做别人的父类）
    2.可以定义抽象方法，在子类中去实现
    3.一个抽象类中可以用：
       1.具体属性 val name:String="小米"
       2.具体方法 def autoRun():Unit={}

       3.抽象属性。val name:String没有具体值的属性，只有属性名和类型，它必须写在抽象类中
       4.抽象方法 def autoRun():Unit
                在子类中，要有具体的实现
   */
  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.具体属性 val name:String="小米"
2.具体方法 def autoRun():Unit={}
3.抽象属性。val name:String没有具体值的属性，只有属性名和类型，它必须写在抽象类中
4.抽象方法 def autoRun():Unit，在子类中，要有具体的实现

object day28 {
 /* 3.一个抽象类中可以用：
      1.具体属性 val name:String="小米"
      2.具体方法 def autoRun():Unit={}

      3.抽象属性。val name:String没有具体值的属性，只有属性名和类型，它必须写在抽象类中
      4.抽象方法 def autoRun():Unit
                 在子类中，要有具体的实现
  */
   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="小米"//对于var的属性，直接覆盖
    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)
  }
}