精华内容
下载资源
问答
  • java子类重写父类的要点
    2021-02-13 01:43:12

    子类不能重写父类的静态方法,私有方法。即使你看到子类中存在貌似是重写的父类的静态方法或者私有方法,编译是没有问题的,但那其实是你重新又定义的方法,不是重写。具体有关重写父类方法的规则如下:

    重写规则之一:重写方法不能比被重写方法限制有更严格的访问级别。

    (但是可以更广泛,比如父类方法是包访问权限,子类的重写方法是public访问权限。)比如:Object类有个toString()方法,开始重写这个方法的时候我们总容易忘记public修饰符,编译器当然不会放过任何教训我们的机会。出错的原因就是:没有加任何访问修饰符的方法具有包访问权限,包访问权限比public当然要严格了,所以编译器会报错的。

    重写规则之二: 参数列表必须与被重写方法的相同。

    重写有个孪生的弟弟叫重载,也就是后面要出场的。如果子类方法的参数与父类对应的方法不同,那么就是你认错人了,那是重载,不是重写。

    重写规则之三:返回类型必须与被重写方法的返回类型相同。

    父类方法A:void eat(){} 子类方法B:int eat(){}两者虽然参数相同,可是返回类型不同,所以不是重写。

    父类方法A:int eat(){} 子类方法B:long eat(){}返回类型虽然兼容父类,但是不同就是不同,所以不是重写。

    重写规则之四:重写方法不能抛出新的异常或者比被重写方法声明的检查异常更广的检查异常。但是可以抛出更少,更有限或者不抛出异常。

    注意:这种限制只是针对检查异常,至于运行时异常RuntimeException及其子类不再这个限制之中。

    重写规则之五: 不能重写被标识为final的方法。

    重写规则之六:如果一个方法不能被继承,则不能重写它。如private方法

    比较典型的就是父类的private方法。下例会产生一个有趣的现象。

    更多相关内容
  • 在本篇文章里小编给大家整理了关于java子类调用父类的方法中包含子类重写的实例方法以及相关知识点,需要的朋友们可以学习下。
  • 主要介绍了Java编程关于子类重写父类方法问题的理解,分享了有关子类重写父类的实例,具有一定参考价值,需要的朋友可以了解下。
  • 关于子类能否重写父类的静态方法,对像我这种初级的编程爱好者来说仍是值得讨论的一件事,下面我们通过具体实例,对此问题进行简单的探索。
  • 子类不能重写父类的静态方法,私有方法。即使你看到子类中存在貌似是重写的父类的静态方法或者私有方法,编译是没有问题的,但那其实是你重新又定义...有个人曾经这样说:父类为protected的,子类重写时一定要用pub...

    子类不能重写父类的静态方法,私有方法。即使你看到子类中存在貌似是重写的父类的静态方法或者私有方法,编译是没有问题的,但那其实是你重新又定义的方法,不是重写。具体有关重写父类方法的规则如下:

    重写规则之一:

    重写方法不能比被重写方法限制有更严格的访问级别。

    但是可以更广泛,比如父类方法是包访问权限,子类的重写方法是public访问权限。有个人曾经这样说:父类为protected的,子类重写时一定要用public;我觉得这个观点不能是绝对的,只要满足子类的访问权限不比父类低就行了。

    比如:Object类有个toString()方法,开始重写这个方法的时候我们总容易忘记public修饰符,编译器当然不会放过任何教训我们的机会。出错的原因就是:没有加任何访问修饰符的方法具有包访问权限,包访问权限比public当然要严格了,所以编译器会报错的。

    重写规则之二:

    参数列表必须与被重写方法的相同。

    重写有个孪生的弟弟叫重载,也就是后面要出场的。如果子类方法的参数与父类对应的方法不同,那么就是你认错人了,那是重载,不是重写。

    重写规则之三:

    返回类型必须与被重写方法的返回类型相同。

    父类方法A:void eat(){} 子类方法B:int eat(){}两者虽然参数相同,可是返回类型不同,所以不是重写。

    父类方法A:int eat(){} 子类方法B:long eat(){}返回类型虽然兼容父类,但是不同就是不同,所以不是重写。

    重写规则之四:

    重写方法不能抛出新的异常或者比被重写方法声明的检查异常更广的检查异常。但是可以抛出更少,更有限或者不抛出异常。

    注意:这种限制只是针对检查异常,至于运行时异常RuntimeException及其子类不再这个限制之中。

    重写规则之五:

    不能重写被标识为final的方法。

    重写规则之六:

    如果一个方法不能被继承,则不能重写它。如private方法

    比较典型的就是父类的private方法。下例会产生一个有趣的现象。

    public classTest {public static voidmain (String[] args) {//Animal h = new Horse();

    Horse h = newHorse();

    h.eat();

    }

    }classAnimal {private voideat(){

    System.out.println ("Animal is eating.");

    }

    }class Horse extendsAnimal{public voideat(){

    System.out.println ("Horse is eating.");

    }

    }

    这段代码是能通过编译的。表面上看来违反了第六条规则,但实际上那是一点巧合。Animal类的eat()方法不能被继承,因此Horse类中的eat()方法是一个全新的方法,不是重写也不是重载,只是一个只属于Horse类的全新的方法!这点让很多人迷惑了,但是也不是那么难以理解。

    main()方法如果是这样:

    Animal h = newHorse();//Horse h = new Horse();

    h.eat();

    编译器会报错,为什么呢?Horse类的eat()方法是public的啊!应该可以调用啊!请牢记,多态只看父类引用的方法,而不看子类对象的方法!

    重写规则之七:

    子类不能用 静态方法重写父类的非静态方法

    编绎无法通过this static method cannot hide the instance mehtodfrom

    classA {protected int method1(int a, intb) {return 0;

    }

    }public class Test1 extendsA {private int method1(int a, longb) {return 0;

    }//this static method cannot hide the instance mehtod from A

    static public int method1(int a, intb) {return 0;

    }

    }

    重写规则之八:

    子类不能用非静态方法重写父类的静态方法

    编绎报错:thisinstance method cannot override the static mehtod fromA

    classA {protected static int method1(int a, intb) {return 0;

    }

    }public class Test1 extendsA {private int method1(int a, longb) {return 0;

    }//this static method cannot hide the instance mehtod from A//this instance method cannot override the static mehtod from A

    public int method1(int a, intb) {return 0;

    }

    }

    参考:

    展开全文
  • Java子类重写父类的方法

    千次阅读 多人点赞 2020-05-20 21:35:49
    Java子类重写父类的方法 一、方法名一致 //这是父类 public class SuperClass { public void test(){ System.out.println("我是父类的方法"); } } //这是子类 public class SubClass extends SuperClass{ //...

    Java子类重写父类的方法

    一、方法名一致

    //这是父类
    public class SuperClass {
    
        public void test(){
            System.out.println("我是父类的方法");
        }
    }
    
    //这是子类
    public class SubClass extends SuperClass{
    
        //重写了父类的方法
        public void test(){
            System.out.println("我是子类的方法");
        }
    }
    
    //这是测试类
    public class TestMain {
    
        public static void main(String[] args) {
            SubClass subClass = new SubClass();
            subClass.test();
        }
    }
    

    输出结果:

    我是子类的方法

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

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

    //这是父类
    public class SuperClass {
    
        void test1(){
            System.out.println("我是父类的方法1");
        }
    
        void test2(){
            System.out.println("我是父类的方法2");
        }
    
        protected void test3(){
            System.out.println("我是父类的方法3");
        }
    }
    
    //这是子类
    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");
        }
    }
    
    //这是测试类
    public class TestMain {
    
        public static void main(String[] args) {
            SubClass subClass = new SubClass();
            subClass.test1();
            subClass.test2();
            subClass.test3();
        }
    }
    

    输出结果:

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

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

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

    //这是父类
    public class SuperClass {
    
        public void test(int i,String s){
            System.out.println("我是父类的方法"+i);
            System.out.println("我是父类的方法"+s);
        }
    }
    
    //这是子类
    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("我是子类的方法");
        }
    }
    
    //这是测试类
    public class TestMain {
    
        public static void main(String[] args) {
            SubClass subClass = new SubClass();
            subClass.test(0,"s");
        }
    }
    

    输出结果:

    我是子类的方法

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

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

    //这是父类
    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;
        }
    }
    
    //这是子类
    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;
        }
    }
    
    //这是测试类
    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方法,那么子类隐藏父类的方法,而不是重写父类方法。

    展开全文
  • java中,子类重写父类方法时,子类的返回值可以和父类相同,或者为父类的子类。 比如 abstract class Parent{ abstract Parent test(); } class Son extends Parent{ @Override Son test() { return new Son...

    在java中,子类重写父类方法时,子类的返回值可以和父类相同,或者为父类的子类。

    比如

    abstract class Parent{
       abstract  Parent test();
    }
    
    class Son extends Parent{
        @Override
        Son test() {
            return new Son();
        }
    }
    

    而如果父类返回值包括泛型类型,那么子类重写时,如果返回值的泛型类型是父类泛型的子类,此时会报错

      	abstract class Parent{
           abstract List<Parent> test();
        }
    
         class Son extends Parent{
            @Override
            //Son是Parent子类,但此时报错
            List<Son> test() {
                return new ArrayList<>();
            }
        }
    

    IDEA报错信息如下
    在这里插入图片描述

    除非写成

      	abstract class Parent{
           abstract List<Parent> test();
        }
    
         class Son extends Parent{
            @Override
            //List的子类
            LinkedList<Parent> test() {
                return new ArrayList<>();
            }
        }
    

    如果确实需要返回实际的子类,解决方式是可以在父类定义泛型参数,子类重写时传入实际泛型类型

      	abstract class Parent<R>{
           abstract List<R> test();
        }
    
         class Son extends Parent<Son>{
            @Override
            List<Son> test() {
                return new ArrayList<>();
            }
        }
        
        class Son2 extends Parent<Son2>{
            @Override
            List<Son2> test() {
                return new ArrayList<>();
            }
        }
    
    展开全文
  • 子类继承父类,重载了父类方法。面试中经常考到方法的调用,以及构造函数先后顺序。 例子 定义父类,申明方法say() public class TestParent { protected static String name = "parent"; TestParent(){ say(); ...
  • 重写和重载 重写是继承的时候,重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值...子类重写父类的方法 子类重写了父类的方法,如果用父类的对象去调用,就会使用父类的实现 如果用子类的对象去调用...
  • 1、子类重写父类静态方法,变为非静态方法会报错。 public class Person { public static void method(){ System.out.println("Person"); } } public class Man extends Person { public void method(){...
  • java子类重写父类的方法.doc
  •  在java中方法的重写是建立在java类的三大特性之一:继承性的基础之上的,没有继承性也就不能谈方法的重写。方法的重写是当程序中父类的某一个方法并不能满足子类的需求时,子类可以重新定义该方法的内容与功能来...
  • 父类中被重写的方法使用了throws的方式处理了异常,那么子类重写的方法也应该使用throws的方式处理异常,并且其异常不能超过父类中的异常 举例: public class OverrideTest { public static void main...
  • (但是可以更广泛,比如父类方法是包访问权限,子类重写方法是public访问权限。)比如:Object有个toString()方法,开始重写这个方法的时候我们总容易忘记public修饰符,编译器当然不会放过任何教训我们 的机会。...
  • Java 子类重写父类方法的约束条件

    千次阅读 2018-03-27 16:48:03
    1. 父类的方法在子类中是可见的class parent { private void f() { }... //错误, 子类无法重写父类私有方法 private void f() { } }2. 子类方法的权限不小于父类方法class parent { public void f() { } pro...
  • java子类重写父类方法,跟子类自己重新定义一个方法有什么区别? 最好贴上代码讲解一下
  • Java - 子类重写父类的方法

    千次阅读 2019-03-16 17:21:33
    如果子类可以继承父类的某个方法,子类就可以重写这个方法 . 比如实例: 测试: public class Test3_17 { public static void main(String[] args) { // TODO Auto-generated method stub double english ...
  • 子类重写父类方法时,必须拥有不小于父类的权限。 例如如下示例: public class TestPriority { protected int method1(int a, int b){ return 0; } } class A extends TestPriority{ private int method...
  • 用学生的输出为例子,子类继承父类,然后在子类中新定义一个属性并可以给父类属性赋值,以及重写tostring和重写equals方法。 demo测试 package Student; public class demo { public static void main(String[] ...
  • 主要介绍了java子类继承父类实例-披萨的选择实现代码,具有一定借鉴价值,需要的朋友可以参考下。
  • 多态的体现。...(该方法未被子类重写) 2.2 该实例如果调用父类中的方法,若该方法被子类重写,则一定调用的是在子类重写后的该方法。 2.3 该实例不可以调用父类中没有的方法。(该方法子类特有)
  • 关于子类重写父类方法的问题

    千次阅读 2019-06-30 13:05:56
    子类重写父类的方法; 1.父类中私有方法不能被重写。因为父类私有方法子类根本无法继承。 2.父类中方法有final修饰的不能被重写 3.子类所重写的方法的访问修饰符必须高于或者等于父类的访问修饰符。 4.如果父类的...
  • 参考资料:https://blog.csdn.net/zjkc050818/article/details/75300796
  • ctrl+o
  • 子类重写父类构造器以及其他方法

    千次阅读 2018-05-18 22:04:51
    若父类重写了自身的构造器,并且还实现了自己的方法,那么,当子类继承父类后,重写自身的构造器和重写父类的其他方法时,搭配super()或者super.method()时候,会出现什么现象呢? 先看构造器 public class ...
  • 子类重写父类成员方法

    千次阅读 2021-03-14 01:15:16
    最近在学习到Java的继承和多态...比较直观的理由是,子类要能够重写父类的方法的前提条件是继承,子类对父类的私有方法并不继承,也没有访问权限,自然也是不能重写的。接下来看一个例子:[java] view plaincopypub...
  • Java重写父类的方法

    千次阅读 2020-08-08 12:24:08
    大部分时候子类是以父类为基础的,但是有时候子类需要重写父类的方法。比如说我们定义了一个Person来表示人类。里面定义了一个方法为上洗手间,ManPeople 继承了这个,Man上洗手间的方式和Woman上洗手间的地方...
  • Java子类继承父类详解

    千次阅读 2021-02-12 11:46:34
    别和我说你真的懂了继承,先来看下面的代码,回答出我的问题再说代码很简单,如下:父类:public class T {public void run(){System.out.println("T can run");}public static void main(String args[]){T t = new ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 188,594
精华内容 75,437
关键字:

java 子类重写父类内部类

java 订阅