21.该抽象艺术了-类的抽象

抽象类。

    1.有关键字：abstract
    2.有抽象成员。只有属性名，没有具体的值  没有  等号
    3.不能被new
    4.作用：给其他的子类立一个标准！

抽象属性：只有属性名，没有具体的值！！！

举个例子

        找工作的条件
        具体：
            工资14500
            五险一金
        不具体：
            工资高   （抽象）
            老板好   （抽象）

abstract class DreamJob() {
  var money:Double
  var vacation:Int
  var boss:String
}
class PE extends DreamJob{
  var money: Double = 14500
  var vacation: Int = 4
  var boss: String = "无人"
}

def main(args: Array[String]): Unit = {
  val pe1 = new PE()
  println(pe1.money)
}                          结果：14500

现在，换一种说法

抽象类。

    1.有关键字 abstract
    2.有
        1.抽象成员。只有属性名。没有具体的值  没有  等号。
        2.具体成员。
    3.子类要实现所有的抽象成员！
    

abstract class DreamJob() {
  var money:Double
  var vacation:Int
  var boss:String
  var name:String = "理想工作"

  def addMoney():Unit
  def getMoney():Unit = {
    println(s"发工资:${money}元")
  }
}
class PE extends DreamJob{
  var money: Double = 14500
  var vacation: Int = 4
  var boss: String = "无人"
  def addMoney():Unit = {
    money *= 1.1
  }
}

def main(args: Array[String]): Unit = {
  val pe1 = new PE()
  println(pe1.money)
  println(pe1.vacation)
  println(pe1.boss)
  pe1.addMoney()
  pe1.getMoney()
}                 结果：14500.0
                        4
                        无人
                        发工资:15950.000000000002元

那么，当你不满意具体成员的话，想要重写，就可以用到override了

这是父类的具体成员

这是重写父类具体成员

以下是操作代码：

abstract class DreamJob() {
  var money:Double
  var vacation:Int
  var boss:String
  var name:String = "理想工作"

  def addMoney():Unit
  def getMoney():Unit = {
    println(s"发工资:${money}元")
  }
}
class PE extends DreamJob{
  var money: Double = 14500
  var vacation: Int = 4
  var boss: String = "无人"
  def addMoney():Unit = {
    money *= 1.1
  }

  override def getMoney(): Unit = {
    println(s"上银行卡：${money}元")
  }
}

def main(args: Array[String]): Unit = {
  val pe1 = new PE()
  println(pe1.money)
  println(pe1.vacation)
  println(pe1.boss)
  pe1.addMoney()
  pe1.getMoney()
}                  重写结果:
                        上银行卡：15950.000000000002元

最后，什么是内部类。

内部类：在类的内部，写另一个类

        就相当于一个类套着另一个类
        

  class C1 {
    class B1 {
      def say():Unit = {
        println("B1.....")
      }
    }
  }


def main(args: Array[String]): Unit = {
    val c1 = new C1()
    val b1 = new c1.B1()
    b1.say()
  }
}             结果：B1.....

 class C1 {
//    私有成员，不能在类的外部修改
    private var score:Int = 1

    class B1 {
      def addScore(s:Int):Unit = {
        println(s"B1...${score}")
      }
      def say():Unit = {
        println(s"B1...${score}")
      }
    }
  }


def main(args: Array[String]): Unit = {
    val c1 = new C1()
    val b1 = new c1.B1()
    b1.addScore(10)
    b1.say()
  }
}