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方法，如果找到了那么就执行这个方法，没有找到就去父类寻找，一直到找到为止。

版权声明：本文为博主原创文章，未经博主允许不得转载。