继承修饰符的问题

=========修饰符回顾==========

　　java类的成员变量通常有以下几种访问修饰符：

　　public、private、protected或者缺省，

　　例如在package first 中如果有一个类FirstClass有四个变量：

　　public int pp；

　　private int xiaopp；

　　protected int dd；

　　int xiaodd；

　　如果在package first 中有另一个类SecondClass继承了FirstClass：

　　那么他将继承FirstClass中的三个变量，分别是：

　　public int pp；

　　protected int dd；

　　int xiaodd；

　　如果在另一个package second中有一个类ThirdClass 继承了FirstClass，

　　那么他将继承FirstClass中的两个变量：

　　public int pp；

　　protected int dd；

　　从上面的例子我们可以看出访问修饰符被继承的关系：

　　public 可以被任何子类继承；

　　protected 虽然他会阻止包外的类访问，但他不会阻止包外的类继承；

　　缺省访问修饰符 不但只能被相同包内的类访问，而且还只能被相同包的子类继承；

　　private 访问局限在同一个类内，并且不可以被继承。

===================

 

本文仅讨论子类能否重写父类的方法，一旦重写成功，子类调用的时候是会覆盖父类的方法的。

子类重写父类方法的时候有两个考虑：

1.父类的方法不能降级，同级的话就要覆盖，例如public方法不能在子类中被声明为protected或者private（子类重载除外），否则会有

Cannot reduce the visibility of the inherited method from Father的编译错误。

2.父类的方法可以任意升级，但升级只有两种方式，要么覆盖，要么重载，覆盖就是方法体完全一样，重载则是参数必须改变，方法名称不变。

import java.lang.reflect.Method;

class Father{
    int a;
    protected int b = 5;
    protected void funcpro(){
        //父类的保护方法，子类能够访问，但子类自身没有
        System.out.println("father funcpro");
    }
    public void funcpub(){
        //父类公有方法，子类直接继承
    }
    private void funcpri(){
        //父类私有方法，子类不可见
    }
}
public class TestOveride extends Father {

    /**
     * @param args
     */
    //父类保护方法的重写
//  public void funcpro(){
//      //子类自己可以这样定义，将会覆盖父类protected方法
//      System.out.println("子类的func方法");
//  }

//  protected void funcpro(){
//  //ok
//}

//  public short funcpro(){
//      //illegal    父类的protected和public方法在子类中是可见的，试想一下，如果编译器认为这个方法体正确，
        //那么子类调用funcpro的时候究竟调用哪个呢？这样没有能构成重载
//  }

//  private void funcpro(){
//      //illegal
//  }

    private void funcpro(int a){
        //这是方法重载，不会报错
        System.out.println("sun funcpro");
    }

    //父类公有方法的重写

//  private void funcpub(){
//      //illegal：Cannot reduce the visibility of the inherited method from Father
//  }

//  protected void funcpub(){
//      //illegal  Cannot reduce the visibility of the inherited method from Father
//  }

//  public void funcpub(){
//      //ok
//  }

//  public int funcpub(){
//      //illegal 和父类的返回值不匹配
//  }

//  public int funcpub(int i){
//      //ok 子类构成重载
//      return 1;
//  }

    //父类私有方法的重写

//  public void funcpri(){
//      //ok
//  }

//  protected void funcpri(){
//      //ok
//  }

//  private void funcpri(){
//      //ok
//  }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        TestOveride testOveride = new TestOveride();
        Class class1 = testOveride.getClass();
        try {
            Method[] methods = class1.getMethods();
            System.out.println("子类中的所有方法：");  //可以看到，并没有父类的funcpro方法
            for(Method m:methods){
                System.out.println(m);
            }
            System.out.println("子类调用父类的protected 方法：");
            testOveride.funcpro();
            System.out.println("子类调用自己的func方法：");
            testOveride.funcpro(1);
            System.out.println("子类调用父类的字段");
            System.out.println(testOveride.b);
        }catch(Exception e){
            e.printStackTrace();
        }

    }

}