Java之继承中的方法重写与属性覆盖

Java之继承中的方法重写与属性覆盖

1、Java继承中属性覆盖

变量,或者叫做类的属性,在继承的情况下,如果父类和子类存在同名的变量会出现变量(属性)的覆盖。

这个问题虽然简单,但是情况却比较复杂。因为我们不仅要考虑变量、静态变量和常量三种情况,还要考虑private、friendly(即不加访问修饰符)、protected和public四种访问权限下对属性的不同影响。

我们先从普通变量说起。先来看一段代码:

class ParentClass {   
    private String privateField = "父类变量--private";   

    /* friendly */String friendlyField = "父类变量--friendly";   

    protected String protectedField = "父类变量--protected";   

    public String publicField = "父类变量--public";   

    // private的变量无法直接访问,因此我们给他增加了一个访问方法   
    public String getPrivateFieldValue() {   
        return privateField;   
    }   
}   

public class SubClass extends ParentClass {   
    private String privateField = "子类变量--private";   

    * friendly */String friendlyField = "子类变量--friendly";   

    protected String protectedField = "子类变量--protected";   

    public String publicField = "子类变量--public";   

    // private的变量无法直接访问,因此我们给他增加了一个访问方法   
    public String getPrivateFieldValue() {   
        return privateField;   
    }   

public static void main(String[] args) {   
        // 为了便于查阅,我们统一按照private、friendly、protected、public的顺序   
        // 输出下列三种情况中变量的值   

        // ParentClass类型,ParentClass对象   
        ParentClass parentClass = new ParentClass();   
        System.out.println("ParentClass parentClass = new ParentClass();");   
        System.out.println(parentClass.getPrivateFieldValue());   
        System.out.println(parentClass.friendlyField);   
        System.out.println(parentClass.protectedField);   
        System.out.println(parentClass.publicField);   

        System.out.println();   

        // ParentClass类型,SubClass对象   
        ParentClass subClass = new SubClass();   
        System.out.println("ParentClass subClass = new SubClass();");   
        System.out.println(subClass.getPrivateFieldValue());   
        System.out.println(subClass.friendlyField);   
        System.out.println(subClass.protectedField);   
        System.out.println(subClass.publicField);   

        System.out.println();   

        // SubClass类型,SubClass对象   
        SubClass subClazz = new SubClass();   
        System.out.println("SubClass subClazz = new SubClass();");   
        System.out.println(subClazz.getPrivateFieldValue());   
        System.out.println(subClazz.friendlyField);   
        System.out.println(subClazz.protectedField);   
        System.out.println(subClazz.publicField);   
    }   
}  

从上面的结果中可以看出,private的变量与其它三种访问权限变量的不同,这是由于方法的重写(override)而引起的。关于重写知识下面会有,这里我们来看一下其它三种访问权限下变量的覆盖情况。

分析上面的输出结果就会发现,变量的值取决于我们定义的变量的类型,而不是创建的对象的类型。

在上面的例子中,同名的变量访问权限也是相同的,那么对于名称相同但是访问权限不同的变量,情况又会怎样呢?由于private变量的特殊性,在接下来的实验中我们都把它排除在外,不予考虑。

由于上面的例子已经说明了,当变量类型是父类(ParentClass)时,不管我们创建的对象是父类(ParentClass)的还是子类(SubClass)的,都不存在属性覆盖的问题,因此接下来我们也只考虑变量类型和创建对象都是子类(SubClass)的情况。

class ParentClass {   
    /* friendly */String field = "父类变量";   
}   

public class SubClass extends ParentClass {   
    protected String field = "子类变量";   

    public static void main(String[] args) {   
        SubClass subClass = new SubClass();   
        System.out.println(subClass.field);   
    }   
}  

运行结果: 

子类变量 

Java代码 
class ParentClass {   
    public String field = "父类变量";   
}   

public class SubClass extends ParentClass {   
    protected String field = "子类变量";   

    public static void main(String[] args) {   
        SubClass subClass = new SubClass();   
        System.out.println(subClass.field);   
    }   
}  

运行结果: 

子类变量 

上面两段不同的代码,输出结果确是相同的。事实上,我们可以将父类和子类属性前的访问修饰符在friendly、protected和public之间任意切换,得到的结果都是相同的。也就是说访问修饰符并不影响属性的覆盖,关于这一点大家可以自行编写测试代码验证。

对于静态变量和常量又会怎样呢?我们继续来看:

class ParentClass {   
    public static String staticField = "父类静态变量";   

    public final String finalField = "父类常量";   

    public static final String staticFinalField = "父类静态常量";   
}   

public class SubClass extends ParentClass {   
    public static String staticField = "子类静态变量";   

    public final String finalField = "子类常量";   

    public static final String staticFinalField = "子类静态常量";   

    public static void main(String[] args) {   
        SubClass subClass = new SubClass();   
        System.out.println(SubClass.staticField);   
        System.out.println(subClass.finalField);   
        System.out.println(SubClass.staticFinalField);   
    }   
}  

运行结果如下: 

子类静态变量 
子类常量 
子类静态常量 

虽然上面的结果中包含“子类静态变量”和“子类静态常量”,但这并不表示父类的“静态变量”和“静态常量”可以被子类覆盖,因为它们都是属于类,而不属于对象。

最后,我们来做个总结。通过以上测试,可以得出一下结论:

由于private变量受访问权限的限制,它不能被覆盖。 
属性的值取父类还是子类并不取决于我们创建对象的类型,而是取决于我们定义的变量的类型。 
friendly、protected和public修饰符并不影响属性的覆盖。 
静态变量和静态常量属于类,不属于对象,因此它们不能被覆盖。 
常量可以被覆盖。 
对于基本类型和对象,它们适用同样的覆盖规律。 

2、Java方法重写

重载(也叫过载)时只与方法特征有关,但重写(覆写)是会进一步检查两个方法的返回类型是否相同、访问修饰权限是否缩小(假设public->protected方向是缩小,反之叫扩大)和抛出的异常范围是否扩大。那么什么是方式特征呢?一个方法的特征(也可叫方法签名)仅包括方法的名字、参数的个数、类型、顺序(实质上就是参数列表),而不包括方法的返回类型、访问修饰权限与所抛出的异常。

public class A {   
    public void overwrite(int i) throws IOException {}   
}   

class B extends A {   
    // !! 编译通不过,不能缩小访问权限   
    //    void overwrite(int i) throws IOException {}   

    // !! 编译通不过,不能扩大异常范围   
    //    public void overwrite(int i) throws Exception {}   

    // 正常,编译没问题,可以不抛出异常   
    // public void overwrite(int i) {}   

    // 覆写父类方法   
    public void overwrite(int i) throws IOException {}   

    protected void overload(int i) {}   

    //重载上面的方法   
    int overload(long i) throws IOException {   
        return 0;   
    }   
}  

另外,要补充说明的是重载一般是指在同一个类中多个方法间,但也可重载父类的的方法,而重写只发生面父子与子类的方法间。

2、非私有非静态方法不能被任何静态方法覆写,如果子类中试着以静态方式(不管访问权限修饰符是什么)来覆写父类的方法,编译时会报错。

public class A {   
    void f() {}   
}   

class B extends A {   
    // !! 编译出错,下面错误都一样   
    //    static void f(){};   
    //    private static void f(){};   
    //    protected static void f(){};   
    //    public static void f(){};   
}  

3、非私有静态方法不能被任何非静态方法覆写,如果子类中试着以非静态方式(不管访问权限修饰符是什么)来覆写父类的方法,编译时会报错。

public class A {   
    public static void f() {}   
}   

class B extends A {   
    // !! 编译出错,下面错误都一样   
    //    public void f(){}   
    //    protected void f() {}   
    //    void f() {}   
    //    private void f() {}   
}  

4、子类与父类中有方法特征相同的静态方法时,覆写规则与非静态方法覆写规则一样,但一般我们不把静态方法的覆写叫覆写,虽然语法规则上与非静态方法相同。

public class A {  
    public static void overwrite(int i) throws IOException {  
        System.out.println("父类静态方法...");  
    }  
}  

class B extends A {  
    // !! 编译通不过,不能缩小访问权限  
    //    static void overwrite(int i) throws IOException {}  

    // !! 编译通不过,不能扩大异常范围  
    //    public static void overwrite(int i) throws Exception {}  

    // 正常,编译没问题,可以不抛出异常  
    // public static void overwrite(int i) {}  

    // 覆写父类静态方法  
    public static void overwrite(int i) throws IOException {  
        System.out.println("子类静态方法...");  
    }  

    public static void main(String[] args) throws IOException {  
        A a = new B();  
        //覆写静态在语法上是合法的,但没有多态效果  
        a.overwrite(0);//print: 父类静态方法...  
        A.overwrite(0);//print: 父类静态方法...  
        B.overwrite(0);//print: 子类静态方法...  
    }  
}  

上面重写了父类的静态方法,但却没有多态作用,也就是说,静态方法不存在重写这一说,只不过在语法规则上与非静态方法一样罢了。

5、私有方法对子类同名方法不产生任何影响,也就是说私有方法不能被重写,即使试着在子类覆写了父类的私有方法,不管访问权限修饰符是什么,在编译时也不会报错。原因就是私有方法对子类也是不可见的。

public class A {  
    private void f() {  
    }  

    // 加上static修饰符,其结果都一样  
    // private static void f() {}  
}  

class B extends A {  
    // 尝试每个方式,都会编译能过  
    // private void f() {}  
    // void f() {}  
    // protected void f() {}  
    // public void f() {}  

    // private static void f() {}  
    // static void f() {}  
    // protected static void f() {}  
    public static void f() {}  
}  
文章目录
  1. 1. Java之继承中的方法重写与属性覆盖
    1. 1.1. 1、Java继承中属性覆盖
    2. 1.2. 2、Java方法重写
|