精华内容
下载资源
问答
  • Java子类重写父类方法注意问题收集(转)
    2021-02-27 11:10:06

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

    重写规则之一:

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

    但是可以更广泛,比如父类方法是包访问权限,子类的重写方法是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编程关于子类重写父类方法问题的理解,分享了有关子类重写父类的实例,具有一定参考价值,需要的朋友可以了解下。
  • 子类重写父类方法

    2021-06-03 13:17:41
    应用:重写以后,当创建子类对象以后,通过子类对象调用子父类中的同名同参数的方法时,实际执行的是子类重写父类方法 * * * 3.重写的规定: * 方法的声明:权限修饰符 返回值类型 方法名(形参列表) throws 异常的...
    package com.sgg.chongxiechongzai;
    
    public class Person {
    	
    	String name;
    	int age;
    	
    	
    	public Person() {
    		super();
    	}
    	public Person(String name, int age) {
    		super();
    		this.name = name;
    		this.age = age;
    	}
    	
    	public void eat() {
    		System.out.println("吃饭");
    	}
    	public void walk(int distance) {
    		System.out.println("走路,走的距离是:"+distance+"公里");
    		show();
    		eat();
    	}
    	
    	private void show() {
    		System.out.println("我是一个人");
    	}
    	public Object info() {
    		return null;
    	}
    	public double info1() {
    		return 1.0;
    	}
    	
    }
    
    
    package com.sgg.chongxiechong;
    
    public class Student extends Person{
    
    	String major;
    
    	public Student() {
    		super();
    	}
    
    	public Student(String major) {
    		super();
    		this.major = major;
    	}
    	
    	public void study() {
    		System.out.println("学习,专业是: " + major);
    	}
    	
    	public void eat() {
    		System.out.println("学生正在吃有营养的饭");
    	}
    	private void show() {
    		System.out.println("我是一个学生");
    	}
    	public String info() {
    		return null;
    	}
    	/*
    	 * public int info1() { return 1; }
    	 */
    	public void walk(int distance) {
    		System.out.println("重写的方法");
    	}
    }
    
    
    package com.sgg.chongxiechong;
    /*
     * 方法的重写(override / overwrite)
     * 1.重写:子类继承父类以后,可以对父类中同名同参数的方法,进行覆盖操作
     * 
     * 2.应用:重写以后,当创建子类对象以后,通过子类对象调用子父类中的同名同参数的方法时,实际执行的是子类重写父类的方法
     * 
     * 
     * 3.重写的规定:
     * 				方法的声明:权限修饰符 返回值类型 方法名(形参列表) throws 异常的类型 {
     * 								//方法体
     * 						
     * 							}
     * 				约定俗成:子类中的叫重写的方法,父类中的叫被重写的方法
     * 			① 子类重写的方法的方法名和形参列表与父类被重写的方法名和形参列表相同
     * 			② 子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符
     * 				> 特殊情况:子类不能重写父类中声明为private权限的方法
     * 			③ 返回值类型:
     * 				> 父类被重写的方法的返回值类型是void,则子类重写的方法的返回值类型只能是void
     * 				> 父类被重写的方法的返回值类型是 A 类型,则子类重写的方法的返回值类型可以是 A 类或 A 类的子类
     * 				> 父类被重写的方法的返回值类型是基本数据类型(比如: double),则子类重写的方法的返回值类型必须是相同的基本数据类型(必须也是double)
     * 			④ 子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型(具体放到异常处理时讲)
     * *******************************************************************************************************
     * 			子类和父类中的同名同参数的方法要么都声明为非static的(考虑重写),要么都声明为static(随着类的加载而加载)的(不是重写)。
     * 
     * 面试题:区分方法的重载与重写
     */
    public class PersonTest {
    
    	public static void main(String[] args) {
    
    		Student s = new Student("计算机科学与技术");
    		s.eat();
    		s.walk(10);
    		
    		s.study();
    
    
    	}
    
    }
    
    
    展开全文
  • c++子类重写父类方法

    2022-03-20 22:16:58
    class Base { public: Base() : name_("base") { } void slap() { echo(); } virtual void echo() { std::cout << name_ << std::endl; } private: ...class Derived : public B
    class Base {
    public:
        Base() : name_("base")
        {
        }
    
        void slap()
        {
            echo();
        }
    
        virtual void echo()
        {
            std::cout << name_ << std::endl;
        }
    
    private:
        std::string name_;
    };
    
    class Derived : public Base {
    public:
        Derived() : name_("derived")
        {
        }
    
        virtual void echo()
        {
            std::cout << name_ << std::endl;
        }
    
    private:
        std::string name_;
    };
    
    int main()
    {
    	//方式一
        Derived object;
        object.slap();
        //方式二:
        Base *bb=new Derived;
        bb->echo();
        delete bb;
    
    
    }
    

    输出:

    derived
    
    展开全文
  • 定义一个Base类的子类Sub,在Sub中重写calculate()方法,将计算逻辑由乘法改为除法(X/Y)。注意,当分母为0时输出“Error”。 示例1 输入: 6 2 输出: 3 12 示例2 输入: 1 0 输出: Error 0 思路 继承...

    题目

    • 定义一个父类Base中的方法calculate(),该方法用于计算两个数的乘积(X*Y)。定义一个Base类的子类Sub,在Sub中重写calculate()方法,将计算逻辑由乘法改为除法(X/Y)。注意,当分母为0时输出“Error”。

    • 示例1
      输入:
      6 2
      输出:
      3 12

    • 示例2
      输入:
      1 0
      输出: Error 0

    思路

    继承(extends),然后重写一下方法。

    代码实现

    package 你的包名;
    import java.util.Scanner;
    class Base {
        private int x;
        private int y;
         public Base(int x,int y) {
            this.x = x;
            this.y = y;
        }
        public  int calculate(int x, int y){
            int t;
            t=x*y;
            return t;
        }
    }
    
    class Sub extends Base{
        public Sub(int x, int y) {
            super(x, y);
        }
    
        @Override
        public  int calculate(int x, int y){
            int t;
            if(y!=0) {
                t = x / y;
                return t;
            }else{
                return 0;
            }
        }
    }
    
    public class main {
        public static void main(String[] args) {
            int t1,t2;
            Scanner scanner = new Scanner(System.in);
            while (scanner.hasNextInt()){
                int x = scanner.nextInt();
                int y = scanner.nextInt();
                Sub sub = new Sub(x,y);
                Base base = new Base(x,y);
                t1=sub.calculate(x,y);
                t2=base.calculate(x,y);
                if(y==0){
                    System.out.println("Error 0");
                }else {
                    System.out.println(t1 + " " + t2);
                }
            }
        }
    }
    
    
    展开全文
  • 在本篇文章里小编给大家整理了关于java子类调用父类方法中包含子类重写的实例方法以及相关知识点,需要的朋友们可以学习下。
  • 子类重写父类方法时,必须拥有不小于父类的权限。 例如如下示例: public class TestPriority { protected int method1(int a, int b){ return 0; } } class A extends TestPriority{ private int method...
  • 父类中被重写方法使用了throws的方式处理了异常,那么子类重写方法也应该使用throws的方式处理异常,并且其异常类不能超过父类中的异常类 举例: public class OverrideTest { public static void main...
  • 关于子类重写父类方法的问题

    千次阅读 2019-06-30 13:05:56
    关于访问修饰符对重写父类方法的影响结论代码样例子类 结论 子类重写父类的方法; 1.父类中私有方法不能被重写。因为父类私有方法子类根本无法继承。 2.父类中方法有final修饰的不能被重写 3.子类所重写的方法的访问...
  • 方法重写是当程序中父类的某一个方法并不能满足子类的需求时,子类可以重新定义该方法的内容与功能来满足子类的需求的一种操作。 所谓方法的覆盖(重写)即父类中有一个方法子类中有一个和父类一模一样的方法...
  • 子类隐藏父类方法(通过new操作符) namespace ConsoleApp1 { class Program { static void Main(string[] args) { Student stu = new Student(); stu.Report(); CsStudent csStudent = new CsStudent(); ...
  • 子类继承父类,重载了父类方法。面试中经常考到方法的调用,以及构造函数先后顺序。 例子 定义父类,申明方法say() public class TestParent { protected static String name = "parent"; TestParent(){ say(); ...
  • 子类重写父类方法后的调用规则

    千次阅读 2020-07-28 21:23:52
    1.子类重写父类方法后,如果实际是子类的对象实例, 则会调用子类的方法. 2.子类继承父类, 构造子类的时候,会先构造父类(先执行父类构造函数)后构造子类 参考: 1.例题:子类重写父类方法后的调用规则 ...
  • 子类继承父类,重写了父类方法,那么调用时就会调用子类重写后的方法 例子 public class TestParent { protected static String name = "parent"; TestParent(){ say(); } public void say(){ System.out....
  • 子类重写父类方法,调用时会调用子类重写之后的方法 当然,这一切的前提都是 实例化子类对象 2,下面代码的输出是什么? // null      public class Base {  private String baseName = "base...
  • 子类重写父类方法时,会把父类覆盖掉。为了在保留父类方法的基础上,子类在对该方法进行添加,我们有以下两种方法解决。 法1:调用未绑定的父类方法 父类名.init(self) 例如:父类Fish 子类Shark Fish.init(self)...
  • //在继承中防止父类方法被子类重写可以使用final class Xun { public final function index() { echo '我永远喜欢菠萝赛东'; } } class Yang extends Xun { // public function index() // { // ...
  • <?php class father{ //定义father类 public function method(){ //定义方法 echo '<br />father method'; } } class son extends father{ ...
  • 关于子类能否重写父类的静态方法,对像我这种初级的编程爱好者来说仍是值得讨论的一件事,下面我们通过具体实例,对此问题进行简单的探索。
  • 常,因此在运行时期也就出现失败 总结:这个示例也就演示了一个道理,在java中,子类重写父类方法时,子类如果选择抛出异常,那么抛出的异常类型不能大于父类的异常类型 西城风雨楼 原创文章 6获赞 22访问量 1万+ ...
  • 子类重写父类方法应该注意的问题

    千次阅读 2018-10-11 11:34:02
    子类重写父类方法应该注意的问题 代码如下: public class Demo15 { public int getLength() { return 4; } } class Sub extends Demo15 { public int getLength() { return 5; } public ...
  • Java 子类重写父类方法的约束条件

    千次阅读 2018-03-27 16:48:03
    1. 父类的方法在子类中是可见的class parent { private void f() { }... //错误, 子类无法重写父类私有方法 private void f() { } }2. 子类方法的权限不小于父类方法class parent { public void f() { } pro...
  • 这可能是您的父类:class Polygon():def __init__(self):raise NotImplementedErrordef perimeter(self):raise NotImplementedErrordef area(self):raise NotImplementedError尽管只有在运行时才会发现问题,但当...
  • 多态存在的三个必要条件:继承,重写父类引用指向子类对象 当使用多态方式调用方法时,首先检查父类中是否有该方法,如果没有,则error;如果有,调用子类的同名方法。 example: package demo; public class ...
  • (但是可以更广泛,比如父类方法是包访问权限,子类重写方法是public访问权限。)比如:Object类有个toString()方法,开始重写这个方法的时候我们总容易忘记public修饰符,编译器当然不会放过任何教训我们 的机会。...
  • * 继承中,在子类重写父类方法的时候,对异常的处理 * 结论: * 父类的方法,如果抛出异常,子类重写后 * 可以不抛出异常 * 也可以抛出异常,但是,如果子类要抛,抛出的异常不能大于父类的异常 (原因:多态调用) * ...
  • 子类重写父类方法条件

    千次阅读 2017-03-22 11:56:35
    条件1.父类中的方法在子类中必须可见,即子类继承了父类中的该方法(可以显式的使用super关键字来访问父类中的被... 如果父类和子类都是static方法,那么子类隐藏父类的方法,而不是重写父类方法。3.子类和父类的方法必
  • java子类重写父类方法,跟子类自己重新定义一个方法有什么区别? 最好贴上代码讲解一下
  • 继承,子类重写父类方法 一:继承 class Phone { constructor(name, price) { this.name = name; this.price = price } start(){ console.log(this.name,'开始执行函数'); this.father(this.name,this....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 260,116
精华内容 104,046
关键字:

子类重写父类的方法

友情链接: propview.zip