精华内容
下载资源
问答
  • java子类重写父类方法
    2022-02-27 16:23:41

    一般规则:

    1. .若父类中被重写的方法使用了throws的方式处理了异常,那么子类中重写的方法也应该使用throws的方式处理异常,并且其异常类不能超过父类中的异常类

    举例:

    public  class OverrideTest {
    
        public static void main(String[] args) {
            OverrideTest test = new OverrideTest();
            test.display(new SubClass());
        }
    
        public void display(SuperClass s) {
            try {
                s.method();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    
        class SuperClass{
    
            public void method() throws IOException {
                
            }
        }
    
        class SubClass extends SuperClass{
            public void method() throws FileNotFoundException{
    
            }
        }
    1. 首先SuperClass和Subclass存在子父类关系。
    2. 在OverrideTest类中定义了display方法,并以SuperClass类的对象作为输入,方法里面调用了SuperClass类的method方法,并进行了try-catch处理。处理掉了IOException.
    3. 此时一个Override类的对象test调用display方法,利用多态性输入子类Subclass的对象,则display里调用的method方法实际是子类Subclass的方法,该方法抛出的异常是FileNotFoundException(<IOException)。但此时display中try-catch仍然有效。故而应当'<='

    由此也可以引出另一条规则:

    父类中被重写的方法中如果没有使用throws的方式处理异常,那么子类中重写了的方法也不能使用throws。

    若使用了,则在使用多态性时,可能会导致子类抛出的异常无人处理。               -----感谢尚硅谷ss

    更多相关内容
  • 主要介绍了Java编程关于子类重写父类方法问题的理解,分享了有关子类重写父类的实例,具有一定参考价值,需要的朋友可以了解下。
  • 在本篇文章里小编给大家整理了关于java子类调用父类方法中包含子类重写的实例方法以及相关知识点,需要的朋友们可以学习下。
  • java子类重写父类方法.doc
  • 方法重写是当程序中父类的某一个方法并不能满足子类的需求时,子类可以重新定义该方法的内容与功能来满足子类的需求的一种操作。 所谓方法的覆盖(重写)即父类中有一个方法子类中有一个和父类一模一样的方法...

    先讲一讲方法的重写(覆盖)

     在java中方法的重写是建立在java类的三大特性之一:继承性的基础之上的,没有继承性也就不能谈方法的重写。方法的重写是当程序中父类的某一个方法并不能满足子类的需求时,子类可以重新定义该方法的内容与功能来满足子类的需求的一种操作。

    所谓方法的覆盖(重写)即父类中有一个方法在子类中有一个和父类一模一样的方法(注意哈我这里又是父类又是

    子类的当然是需要继承的(extends))

    下面既有方法的重写也有方法的调用未被重写之前的方法(还有注意重写方法请不要在main方法中重写main方法是入口即调用这些方法的)

    想直接看解决的请跳过 方法重写知识的讲解

    可能大家看见super我不知道大家学到继承多态这的时候有没有学到super关键字这里就

    浅讲一下,所谓super就是可以调用父类中的构造方法以及普通方法

    语法格式也就是super.方法名变量名

    super()无参构造方法

    super(参数)即调用(引用)有参构造方法(构造器)

    这种图忘带执行结果了,别着急往下看

    不搞那些高级的 就单纯的输出文字给大家伙个思路

    abstract class father {
        //定义一个普通方法
        public void common(){
            System.out.println("这是父类的普通方法");
        }
    
    }
    
     class chile extends father {
        //重写这个普通方法
        public void common(){
            System.out.println("这是重写父类的普通方法的方法");
        }
        //调用父类的方法也就是common 可能你们会认为父类中的方法不是被重写了吗。
         //不错确实是重写了,当不代表就不能使用父类中的被重写之前的方法了
         //我们使用在子类创建一个普通方法,来使用super关键字来调用父类中的方法
         public void beforeWay(){
            super.common();
            
         }
         //现在来输出看看
         public static void main(String[] args) {
             //使用多态,也可以不使用 我比较习惯使用多态
             father c = new chile();
             c.common();
             chile c1 = new chile();
             c1.beforeWay();
         }
    
    }
    

    博客地址https://www.oldboy1026.club/javazlffffz%D0%B4lfldffjavazlz%D0%B4flffhhnbndyfldffff%CE%B4bz%D0%B4zqdffcasdrskydl/

    展开全文
  • 子类继承父类,重载了父类方法。面试中经常考到方法的调用,以及构造函数先后顺序。 例子 定义父类,申明方法say() public class TestParent { protected static String name = "parent"; TestParent(){ say(); ...

    背景

    子类继承父类,重写了父类方法。面试中经常考到方法的调用,以及构造函数先后顺序。

    例子

    定义父类,申明方法say()

    public class TestParent {
        protected static String name = "parent";
        TestParent(){
            say();
        }
        public void say(){
            System.out.println("Hello"+ name);
        }
    }
    
    

    定义子类,申明方法say()

    public class TestChild extends TestParent{
        private String name = "child";
        
        TestChild(){
            say();
        }
        public void say(){//重写say()
            //super.say();super关键字指定调用父类方法
            System.out.println("Hello"+ name);
        }
        public static void main(String[] args) {
            TestParent a = new TestChild();
        }
    }
    

    运行main方法时,当时想都没想认为是

    Helloparent
    Hellochild
    

    其实是错误的,在执行父类的构造方法时,调用的并不是父类的say()方法,而是子类重写的say(),此时子类非静态变量并未加载,所以输出是“null”。要想指定调用父类方法可用super.say()来指定,若想执行父类构造函数时输出name,可将子类变量设置为static/final,有了static/final关键字,便会先于构造函数执行。

    Hellonull
    Hellochild
    

    PS:父类子类加载顺序

    父类静态变量
    父类静态代码块
    子类静态变量
    子类静态代码块
    父类非静态变量
    父类非静态代码块
    父类构造函数
    子类非静态变量
    子类非静态代码块
    子类构造函数
    静态资源存放在方法区,线程共享,只会加载一次。

    展开全文
  • 具体有关重写父类方法的规则如下:重写规则之一:重写方法不能比被重写方法限制有更严格的访问级别。但是可以更广泛,比如父类方法是包访问权限,子类的重写方法是public访问权限。有个人曾经这样说:父类为...

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

    重写规则之一:

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

    但是可以更广泛,比如父类方法是包访问权限,子类的重写方法是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 子类重写父类方法的约束条件

    千次阅读 2018-03-27 16:48:03
    1. 父类的方法在子类中是可见的class parent { private void f() { }... //错误, 子类无法重写父类私有方法 private void f() { } }2. 子类方法的权限不小于父类方法class parent { public void f() { } pro...
  • (但是可以更广泛,比如父类方法是包访问权限,子类重写方法是public访问权限。)比如:Object类有个toString()方法,开始重写这个方法的时候我们总容易忘记public修饰符,编译器当然不会放过任何教训我们 的机会。...
  • 子类重写父类方法需满足以下条件: 1、方法名和参数列表:子类重写的方法和父类被重写的方法在方法名和参数列表方面相同; 2、返回值类型: 如果父类被重写的方法没有返回值类型或者返回值类型为基本数据类型,...
  • 重写和重载 重写是继承的时候,重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值...子类重写父类方法 子类重写了父类的方法,如果用父类的对象去调用,就会使用父类的实现 如果用子类的对象去调用...
  • 关于子类能否重写父类的静态方法,对像我这种初级的编程爱好者来说仍是值得讨论的一件事,下面我们通过具体实例,对此问题进行简单的探索。
  • java中,子类重写父类方法时,子类的返回值可以和父类相同,或者为父类的子类。 比如 abstract class Parent{ abstract Parent test(); } class Son extends Parent{ @Override Son test() { return new Son...
  • 具体有关重写父类方法的规则如下:重写规则之一:重写方法不能比被重写方法限制有更严格的访问级别。(但是可以更广泛,比如父类方法是包访问权限,子类的重写方法是public访问权限。)比如:Object类有个toString()...
  • java子类重写父类方法,跟子类自己重新定义一个方法有什么区别? 最好贴上代码讲解一下
  • 1、子类重写父类静态方法,变为非静态方法会报错。 public class Person { public static void method(){ System.out.println("Person"); } } public class Man extends Person { public void method(){...
  • 仅当返回值为类类型时,重写的方法才可以修改返回值类型,且必须是父类方法返回值的子类;要么就不修改,与父类返回值类型相同。那么,该如何理解呢?为什么要是父类返回值类型的子类?作者: 蝉蝉请尊重作者劳动...
  • Java - 子类重写父类方法

    千次阅读 2019-03-16 17:21:33
    如果子类可以继承父类的某个方法,子类就可以重写这个方法 . 比如实例: 测试类: public class Test3_17 { public static void main(String[] args) { // TODO Auto-generated method stub double english ...
  • 子类重写父类成员方法

    千次阅读 2021-03-14 01:15:16
    最近在学习到Java的继承和多态...比较直观的理由是,子类要能够重写父类方法的前提条件是继承,子类对父类的私有方法并不继承,也没有访问权限,自然也是不能重写的。接下来看一个例子:[java] view plaincopypub...
  • java中,子类是不能直接转成父类的。如果直接强转就会出现ClassCastException。 public class ChongXie extends A{ public static void hello(){ System.out.println("chongxie"); } public static void main...
  • 子类重写父类方法时,必须拥有不小于父类的权限。 例如如下示例: public class TestPriority { protected int method1(int a, int b){ return 0; } } class A extends TestPriority{ private int method...
  • 多态存在的三个必要条件:继承,重写父类引用指向子类对象 当使用多态方式调用方法时,首先检查父类中是否有该方法,如果没有,则error;如果有,调用子类的同名方法。 example: package demo; public class ...
  • 关于子类重写父类方法的问题

    千次阅读 2019-06-30 13:05:56
    关于访问修饰符对重写父类方法的影响结论代码样例子类 结论 子类重写父类的方法; 1.父类中私有方法不能被重写。因为父类私有方法子类根本无法继承。 2.父类中方法有final修饰的不能被重写 3.子类所重写的方法的访问...
  • 主要介绍了java子类继承父类实例-披萨的选择实现代码,具有一定借鉴价值,需要的朋友可以参考下。
  • 子类继承父类,重写了父类方法,那么调用时就会调用子类重写后的方法 例子 public class TestParent { protected static String name = "parent"; TestParent(){ say(); } public void say(){ System.out....
  • 在学装饰者模式的时候发现子类重写父类方法时调用父类同名方法: public abstract class Beverage { String description = "Unknown Beverage"; public String getDescription() { return description; } ...
  • Java继承重写父类方法

    千次阅读 2020-11-03 13:19:21
    Java继承重写父类方法 重写的前提:需要有继承关系,比如B类继承A类,则B类可以重写A类中的方法!(子类重写父类中的方法) 注意点: 子类所要重写的方法名必须与父类的方法名相同 方法的参数列表也必须一致 方法...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 199,309
精华内容 79,723
关键字:

java子类重写父类方法