属性和方法的重写

抽象属性和方法的重写

package chapter02;

public class java1 {
    public static void main(String[] args){
        //成员方法在执行过程中，实行动态绑定机制，即和当前调用对象实际内存进行绑定
        //属性没有动态绑定机制，在哪里声明在哪里使用

        AAA aaa=new AAA();
        System.out.println(aaa.getResult());//20

        AAA bbb=new BBB();
        System.out.println(bbb.getResult());//30
    }
}

class AAA{
    //java中属性不可以重写
    public int i=10;
    public int getResult(){
        return getI()+10;
    }

    public int getI(){
        return i;
    }
}

class BBB extends AAA{
    public int i=20;
    public int getI(){
        return i;
    }

}

package chapter02



object test09 {

  def main(args:Array[String]):Unit={

    val student01:Student01 = new Student01()
    student01.test()
    student01.test02() //children.......
    println(student01.sex)//male
    println(student01.email)//456.com

    val student02:Person01 = new Student01()
    student02.test02() //children.......
    println(student02.sex)
    println(student02.email)

  }

}

//声明类
//父类，继承
//类可以声明为抽象
abstract class Person01{

  var name:String=_

  //抽象属性：只有声明，没有初始化
  //抽象属性在编译为class文件时，不产生属性，但是产生抽象getter方法
  var sex:String

  //非抽象属性,重写必须为val
  val email:String="123.com"

  //抽象方法：只有声明，没有实现
  def test()

  //非抽象方法：有申明，有实现
  def test02():Unit={
    println("parent......")
  }
}


class Student01 extends Person01{

  //重写抽象属性：补全属性
  var sex:String="male"

  //重写非抽象属性：override
  override  val email:String="456.com"


  //重写抽象方法;补全方法
  def test:Unit={
    println("xxxxxx")
  }

  //重写非抽象方法：override
  override def test02(): Unit = {
    println("children.......")
  }

}