抽象类代码

在了解抽象类代码之前，是需要提前了解抽象类代码的很多条件和意思，例如以下：

抽象类 abstract
1. 一个抽象类（加abstract 做修饰的），不能被new
2. 一个类不能被用来创建对象，那么这个类要传给什么用呢？ 做别人的父类！

这时我们可以敲击以下代码：

/*
抽象类 abstract
1. 一个抽象类（加abstract 做修饰的），不能被new
2. 一个类不能被用来创建对象，那么这个类要传给什么用呢？ 做别人的父类！
*/
object class11 {

  abstract class AICar {
    def autoDrive(): Unit = {
      println("具体方法：自动驾驶......")
    }
  }

  class SUV extends AICar {

  }

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

运行结果如图所示：

再例如一串代码：

/*
1. 一个抽象类(加了abstract修饰的)，不能被new。
一个类不能直接用来创建对象，那么这个类具体有什么用呢？ 做别人的父类！
2. 可以定义抽象方法，在子类中去实现
 */
object class07 {
  abstract class AICar{
    // 抽象方法：没有具体的函数代码。
    def autoEn():Unit

    // 具体方法
    def autoDrive ():Unit = {
      println("具体方法：自动驾驶......")
    }
  }

  // 在子类中，一定要去实现父类的所有抽象方法
  class SU7 extends AICar {
    // 使用override 去实现这个方法
    override def autoEn(): Unit = {
      println("采用小米独家的无线充电技术，停车就可以充电")
    }
  }

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

运行结果如图所示：

package level02

/*
* 内部类
* */
object class14 {
  // 外部类
  class Car() {
    var wheel: Int = 3

    def run(): Unit = {
      println("run.....")
    }

    // 内部类
    class Engin() {
      val power: Int = 12
    }
  }

  def main(args: Array[String]): Unit = {
    val c1 = new Car();
    var eng = new c1.Engin()
    println(eng.power)
  }
}

运行结果如图：

/*
内部类
1. 格式：在一个类的里面，再写一个类
2. 作用：组织逻辑更加严谨；避免命名的冲突
*/
object class15 {
  // 外部类
  class Car() {
    var wheel: Int = 3
    // 私有成员
    private var speed: Int = 0

    def run(): Unit = {
      println(s"速度为: ${speed}，run...")
    }

    // 内部类
    class Engin() {
      def acc(increment: Int): Unit = {
        speed += increment
      }
    }
    class AutoPark(){}
  }

  def main(args: Array[String]): Unit = {
    val c1 = new Car();
    // c1.speed // 私有成员不能访问
    c1.run()
    val en = new c1.Engin()
    en.acc(10)
    c1.run()
  }
}

运行结果如图所示：