Java子类重写父类的方法


Java子类重写父类的方法

一、方法名一致

1
2
3
4
5
6
7
//这是父类
public class SuperClass {

    public void test(){
        System.out.println("我是父类的方法");
    }
}

1
2
3
4
5
6
7
8
//这是子类
public class SubClass extends SuperClass{

    //重写了父类的方法
    public void test(){
        System.out.println("我是子类的方法");
    }
}
1
2
3
4
5
6
7
8
//这是测试类
public class TestMain {

    public static void main(String[] args) {
        SubClass subClass = new SubClass();
        subClass.test();
    }
}

输出结果：

我是子类的方法

总结：子类要重写父类的方法，子类方法名必须与父类一致

二、子类的访问权限要大于或等于父类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//这是父类
public class SuperClass {

    void test1(){
        System.out.println("我是父类的方法1");
    }

    void test2(){
        System.out.println("我是父类的方法2");
    }

    protected void test3(){
        System.out.println("我是父类的方法3");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//这是子类
public class SubClass extends SuperClass{

    //重写了父类的方法1(访问权限一致，都是缺省)
    void test1(){
        System.out.println("我是子类的方法1");
    }

    //重写了父类的方法2(访问权限大于父类的 protected > 缺省)
    protected void test2(){
        System.out.println("我是子类的方法2");
    }

    //重写了父类的方法3(访问权限大于父类的 public > protected)
    public void test3(){
        System.out.println("我是子类的方法3");
    }
}
1
2
3
4
5
6
7
8
9
10
//这是测试类
public class TestMain {

    public static void main(String[] args) {
        SubClass subClass = new SubClass();
        subClass.test1();
        subClass.test2();
        subClass.test3();
    }
}

输出结果：

我是子类的方法1
我是子类的方法2
我是子类的方法3

总结：子类要重写父类的方法，子类方法的权限修饰符访问权限必须大于或者等于父类方法的权限修饰符访问范围

三、参数个数、类型、顺序必须一致

1
2
3
4
5
6
7
8
//这是父类
public class SuperClass {

    public void test(int i,String s){
        System.out.println("我是父类的方法"+i);
        System.out.println("我是父类的方法"+s);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
//这是子类
public class SubClass extends SuperClass{

    //没有重写父类的方法
    public void test(){
        System.out.println("我是子类的方法");
    }

    //没有重写父类的方法
    public void test(int i){
        System.out.println("我是子类的方法");
    }

    //没有重写父类的方法
    public void test(String s){
        System.out.println("我是子类的方法");
    }

    //没有重写父类的方法
    public void test(String s,int i){
        System.out.println("我是子类的方法");
    }

    //重写了父类的方法
    public void test(int i,String s){
        System.out.println("我是子类的方法");
    }
}
1
2
3
4
5
6
7
8
//这是测试类
public class TestMain {

    public static void main(String[] args) {
        SubClass subClass = new SubClass();
        subClass.test(0,"s");
    }
}

输出结果：

我是子类的方法

总结：子类要重写父类的方法，子类方法的参数个数、参数类型、参数顺序必须与父类方法的一致

四、返回值一致或者是父类的子类（实现类）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//这是父类
public class SuperClass {

    public Map test1(){
        Map map = new HashMap();
        System.out.println("我是父类的方法1");
        return map;
    }

    public List test2(){
        List list = new ArrayList();
        System.out.println("我是父类的方法2");
        return list;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//这是子类
public class SubClass extends SuperClass{

    //重写了父类的方法(返回值一致)
    public Map test1(){
        Map map = new HashMap();
        System.out.println("我是子类的方法1");
        return map;
    }

    //重写了父类的方法(返回值是父类的实现类)
    public ArrayList test2(){
        ArrayList arrayList = new ArrayList();
        System.out.println("我是子类的方法2");
        return arrayList;
    }
}

1
2
3
4
5
6
7
8
9
//这是测试类
public class TestMain {

    public static void main(String[] args) {
        SubClass subClass = new SubClass();
        subClass.test1();
        subClass.test2();
    }
}

输出结果：

我是子类的方法1
我是子类的方法2

总结：子类要重写父类的方法，子类方法的返回值必须与父类的一致，或者子类方法的返回值是父类方法返回值的子类或者实现类，如果返回值不满足，则编译错误

注意：
1、父类中 final 修饰的方法不可以被子类重写
2、父类中 private 修饰的方法，子类访问不到，故也不可以重写
3、如果父类是static方法而子类是实例方法，或者相反都会报错。如果父类和子类都是static方法，那么子类隐藏父类的方法，而不是重写父类方法。