JAVA中的继承和覆盖

java里面的继承是子类继承父类的一些方法和属性（除private属性和方法之外）；对于父类的私有属性和方法子类是没有继承的。可是要想子类也能訪问到父类的私有属性，必须给私有属性以外界訪问的方法接口。

package com.PengRong;

public class Demo {
 public static void main(String[]  args)
 {
  /*
  Pupil stu1 = new Pupil();
  stu1.pay(500f);
  stu1.ShowName();
  System.out.println("小学生交的学费" + stu1.getFee());
  Student AK1 = new Student();
  AK1.pay(888.0f);
  System.out.println("中学生交的学费" + AK1.getFee());
  */
  //多态的实现方式
  Stu stu1 =new Pupil();
  stu1.pay(500f);
  stu1.ShowName();
  System.out.println("小学生交的学费" + stu1.getFee());
  stu1 = new Student();
  stu1.pay(200f);
  System.out.println(stu1.showname());
  System.out.println(stu1.getTestV());
 }
}
//学生类   父类
class Stu
{
 //定义成员属性
 public String name;
 public int age;
 public float fee;
 private int TestV = 90;
 public String showname()
 {
  return this.name;
 }
 //成员方法
 public void ShowName()
 {
  System.out.println("学生名字" + this.name);
 }

 public float getFee() {
  return fee;
 }

 public void setFee(float fee) {
  this.fee = fee;
 }

 public void pay(float fee)
 {
  System.out.println("默认付费方法");
  this.fee =0.5f*fee;
 }
 public int getTestV() {
  return TestV;
 }
 public void setTestV(int testV) {
  TestV = testV;
 }

}
//小学生类  子类
class Pupil extends Stu
{
 public void pay(float fee)
 {
  System.out.println("小学生付费方法");
  this.fee =fee;
 }
}

//中学生类
class Student   extends Stu
{
 public void pay(float fee)
 {
  System.out.println("中学生付费方法");
  this.fee =0.8f * fee;
 }
 public String showname()
 {
  return this.name;
 }
}

比方有一个父类Stu 包括一个属性 private int TestV;

子类Student继承父类Stu。

那么在main方法里面写入下代码

Stu stu1 = new Student();
System.out.println(stu1.TestV);

这是错误的。报错是说TestV这个属性不可见，尽管stu父类引用指向一个子类的对象可行。可是这个父类引用不是指向一个父类Stu的对象实体，这个父类引用指向的对象实体类型是Student。所以这个stu1引用不能引用父类的私有属性，为了訪问父类的私有属性怎么办呢？一个解决的方法就是在父类里面提供訪问私有属性的方法。并且这种方法不能是私有的。

Java平台运行的规则是：“在编译阶段，能够调用那些方法和訪问那些属性，这是由引用类型决定的，在程序运行的时候，详细运行那个方法，訪问那个属性是对象的类型决定的。”

覆盖的本质含义就是让子类中的方法屏蔽父类的方法

覆盖语法注意两点就是了

1、子类覆盖父类的方法，那么子类方法在方法返回类型，方法名，參数列表应该一致；

2、子类方法不能缩小父类方法的訪问权限

还是上面那个类。父类Stu有一个pay方法；同一时候子类覆盖了这种方法，在子类实现代码里面重写了这个pay方法。

Stu stu1 =new Pupil();
stu1.pay(500f);

stu1 = new Student();
stu1.pay(200f);

通过调用这段代码能够发现通过父类引用调用pay方法，他不是运行父类的方法而是运行了在子类覆盖的那个pay方法。

对于在子类覆盖了父类一个方法的运行流程是例如以下的

1、比方在编译器编译例程时候。编译器处理到stu1.pay(500f); 时候，发现stul是Stu的一个引用，而Stu里面恰好有一个pay方法，所以编译通过。

2、程序运行时候，程序运行到stu1.pay(500f);时候。发现stu1指向的的对象是Student类的对象，所以他先去Student类中依据pay方法的方法签名寻找pay方法，假设找到了那么就运行这种方法。没有找到就去父类寻找，一直到找到为止。