精华内容
下载资源
问答
  • 2021-05-17 17:20:56

    子类重写父类方法需满足以下条件:

    1、方法名和参数列表:子类重写的方法和父类被重写的方法在方法名和参数列表方面相同;

    2、返回值类型:

          如果父类被重写的方法没有返回值类型或者返回值类型为基本数据类型,则要求子类重写的方法的返回值类型和父类被重写方法的返回值类型相同;

          如果父类被重写的方法返回值类型为引用数据类型,则要求子类重写的方法的返回值类型和父类被重写方法的返回值类型相同或是其子类。(Object是一切的父类。)

    3、父类中静态方法可以被子类继承,但却不能被子类重写;

          父类的静态方法不能被子类覆盖为非静态方法(不能去掉父类方法的static关键字),但是子类可以定义与父类的静态方法同名的静态方法,为了隐藏父类的静态方法

    4、重写父类非静态方法时,重写后的方法不能添加static修饰;

    5、子类的方法不能缩小父类方法的权限否则会编译出错

    6、final问题:

    父类中被final关键字修饰的方法可以被子类继承,但却不能被子类重写;

     final关键字可以用来修饰类、方法和变量:

     final修饰的类不能被继承。 final修饰的方法不能被重写,final修饰的变量是常量,不允许二次赋值。

    7、super使用原则: 

    super关键字可以调用父类的成员变量( super.属性)和方法(super.父类方法([参数列表]))。

     子类构造方法中可以使用super关键字调用父类的构造方法:super([参数列表]);

     super 不能用于静态方法或静态代码块中。
     

    更多相关内容
  • 主要介绍了Java编程关于子类重写父类方法问题的理解,分享了有关子类重写父类的实例,具有一定参考价值,需要的朋友可以了解下。
  • 在本篇文章里小编给大家整理了关于java子类调用父类的方法中包含子类重写的实例方法以及相关知识点,需要的朋友们可以学习下。
  • 用学生的输出为例子,子类继承父类,然后在子类中新定义一个属性并可以给父类属性赋值,以及重写tostring和重写equals方法。 demo测试 package Student; public class demo { public static void main(String[] ...

    用学生的输出为例子,子类继承父类,然后在子类中新定义一个属性并可以给父类属性赋值,以及重写tostring和重写equals方法。
    在这里插入图片描述
    demo测试

    package Student;
    
    public class demo {
    
        public static void main(String[] args) {
    	// TODO Auto-generated method stub
    
    	Undergraduate s1 = new Undergraduate("张三", 30, "专科");
    
    	Undergraduate s2 = new Undergraduate("张三", 30, "本科");
    	Undergraduate s3 = new Undergraduate("张三", 30, "本科");
    	System.out.println(s1.equals(s2));
    	System.out.println(s3.equals(s2));
    	System.out.println(s1);
    	System.out.println(s2);
    	System.out.println(s3);
    
        }
    
    }
    
    

    父类定义属性

    package Student;
    
    public class Student {
        public String name;
        public int age;
    
        public Student() {
    	// TODO Auto-generated constructor stub
        }
    
        public Student(String name, int age) {
    	this.name = name;
    	this.age = age;
        }
    
        public void show() {
    	System.out.println(name + "," + age);
    
        }
    
    }
    
    

    子类定义新属性,重写函数

    package Student;
    
    public class Undergraduate extends Student {
        public String degrre;
    
        public Undergraduate(String name, int age, String degrre) {
    	super(name, age);
    	this.degrre = degrre;
        }
    
        @Override
        public int hashCode() {
    	final int prime = 31;
    	int result = 1;
    	result = prime * result + ((degrre == null) ? 0 : degrre.hashCode());
    	return result;
        }
    
        @Override
        public boolean equals(Object obj) {
    	if (this == obj)
    	    return true;
    	if (obj == null)
    	    return false;
    	if (getClass() != obj.getClass())
    	    return false;
    	Undergraduate other = (Undergraduate) obj;
    	if (degrre == null) {
    	    if (other.degrre != null)
    		return false;
    	} else if (!degrre.equals(other.degrre))
    	    return false;
    	return true;
        }
    
        @Override
        public String toString() {
    	return "degrre=" + degrre + ", name=" + name + ", age=" + age + "";
        }
    
        public void show() {
    	System.out.println(name + "," + degrre + "," + age);
    
        }
    }
    

    运行结果展示
    在这里插入图片描述

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    重写规则之一:

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

    但是可以更广泛,比如父类方法是包访问权限,子类的重写方法是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访问权限。)比如:Object类有个toString()方法,开始重写这个方法的时候我们总容易忘记public修饰符,编译器当然不会放过任何教训我们 的机会。...
  • java中,子类重写父类方法时,子类的返回值可以和父类相同,或者为父类子类。 比如 abstract class Parent{ abstract Parent test(); } class Son extends Parent{ @Override Son test() { return new Son...
  • 关于子类能否重写父类的静态方法,像我这种初级的编程爱好者来说仍是值得讨论的一件事,下面我们通过具体实例,对此问题进行简单的探索。
  • java 子类继承父类、方法的重写(覆盖)

    万次阅读 多人点赞 2018-10-28 16:10:07
    java子类继承父类、方法的重写(覆盖)   在程序中,如果想声明一个类继承另一个类,需要使用extends关键字。 格式: class 子类 extends 父类 {} public class Text { public static void main (String[]...
  • JAVA子类继承父类时的构造方法

    千次阅读 2021-12-03 16:52:22
    Java 中,无论是 explicit 还是 implicit 方式,都要求在子类的构造方法中调用其父类的构造方法。如果父类无构造方法(其实是一个默认无参的构造方法),那么子类的构造方法中会自动进行调用;如果父类有自己的构造...
  • 子类继承父类,重载了父类方法。面试中经常考到方法的调用,以及构造函数先后顺序。 例子 定义父类,申明方法say() public class TestParent { protected static String name = "parent"; TestParent(){ say(); ...
  • java中,子类是不能直接转成父类的。如果直接强转就会出现ClassCastException。 public class ChongXie extends A{ public static void hello(){ System.out.println("chongxie"); } public static void main...
  • 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 ...
  • 父类中被重写的方法使用了throws的方式处理了异常,那么子类重写的方法也应该使用throws的方式处理异常,并且其异常类不能超过父类中的异常类 举例: public class OverrideTest { public static void main...
  • 使用super关键字可以通过子类调用父类重写方法。 public class Main { public static void main(String[] args) { Children c = new Children(); c.method(); } } class Father { public void method() { ...
  • 重写是继承的时候,重写子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。 重载,是在一个类里面,方法名字相同,而参数不同。返回类型可以相同也可以不同。重载可以避免使用完全不同...
  • 1、子类重写父类静态方法,变为非静态方法会报错。 public class Person { public static void method(){ System.out.println("Person"); } } public class Man extends Person { public void method(){...
  • java子类父类属性重复问题

    千次阅读 2021-02-28 08:53:26
    java 子类继承 父类, 但子类中 包含和父类相同 属性 ,给子类赋值之后,父类的相同的属性值还是空的。类定义如下:public class Person {private String name;private String age;// ignore getter and setter}...
  • Java子类父类属性的覆盖

    千次阅读 2021-02-13 01:43:09
    Java codeclass ParentClass {public int i = 10;}public class SubClass extends ParentClass {public int i = 30;public static void main(String[] args) {ParentClass parentClass = new SubClass();SubClass su...
  • Java - 子类重写父类的方法

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

    千次阅读 2020-07-30 10:05:32
    如果子类重写父类中的一个方法,那么在调用这个方法的时候,将会调用子类中的这个方法; Java 父类强转子类 只有父类对象本身就是用子类new出来的时候, 才可以在将来被强制转换为子类对象. 在DTO层与entity层...
  • 子类重写父类成员方法

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

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 191,794
精华内容 76,717
关键字:

java子类对父类重写

java 订阅