精华内容
下载资源
问答
  • 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编程关于子类重写父类方法问题的理解,分享了有关子类重写父类的实例,具有一定参考价值,需要的朋友可以了解下。
  • 子类不能重写父类的静态方法,私有方法。即使你看到子类中存在貌似是重写的父类的静态方法或者私有方法,编译是没有问题的,但那其实是你重新又定义的方法,不是重写。具体有关重写父类方法的规则如下:重写规则之一...

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

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

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

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

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

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

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

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

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

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

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

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

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

    展开全文
  • 关于子类能否重写父类的静态方法,对像我这种初级的编程爱好者来说仍是值得讨论的一件事,下面我们通过具体实例,对此问题进行简单的探索。
  • 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 code

    class 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 subClass = new SubClass();

    System.out.println(parentClass.i + subClass.i);

    }

    }

    控制台的输出结果是多少呢?20?40?还是60?

    变量,或者叫做类的属性,在继承的情况下,如果父类和子类存在同名的变量会出现什么情况呢?这就是这道题要考查的知识点——变量(属性)的覆盖。

    这个问题虽然简单,但是情况却比较复杂。因为我们不仅要考虑变量、静态变量和常量三种情况,还要考虑private、friendly(即不加访问修饰符)、protected和public四种访问权限下对属性的不同影响。

    我们先从普通变量说起。依照我们的惯例,先来看一段代码:

    Java code

    class ParentClass {

    private String privateField = "父类变量--private";

    /* friendly */String friendlyField = "父类变量--friendly";

    protected String protectedField = "父类变量--protected";

    public String publicField = "父类变量--public";

    // private的变量无法直接访问,因此我们给他增加了一个访问方法

    public String getPrivateFieldValue() {

    return privateField;

    }

    }

    public class SubClass extends ParentClass {

    private String privateField = "子类变量--private";

    /* friendly */String friendlyField = "子类变量--friendly";

    protected String protectedField = "子类变量--protected";

    public String publicField = "子类变量--public";

    // private的变量无法直接访问,因此我们给他增加了一个访问方法

    public String getPrivateFieldValue() {

    return privateField;

    }

    public static void main(String[] args) {

    // 为了便于查阅,我们统一按照private、friendly、protected、public的顺序

    // 输出下列三种情况中变量的值

    // ParentClass类型,ParentClass对象

    ParentClass parentClass = new ParentClass();

    System.out.println("ParentClass parentClass = new ParentClass();");

    System.out.println(parentClass.getPrivateFieldValue());

    System.out.println(parentClass.friendlyField);

    System.out.println(parentClass.protectedField);

    System.out.println(parentClass.publicField);

    System.out.println();

    // ParentClass类型,SubClass对象

    ParentClass subClass = new SubClass();

    System.out.println("ParentClass subClass = new SubClass();");

    System.out.println(subClass.getPrivateFieldValue());

    System.out.println(subClass.friendlyField);

    System.out.println(subClass.protectedField);

    System.out.println(subClass.publicField);

    System.out.println();

    // SubClass类型,SubClass对象

    SubClass subClazz = new SubClass();

    System.out.println("SubClass subClazz = new SubClass();");

    System.out.println(subClazz.getPrivateFieldValue());

    System.out.println(subClazz.friendlyField);

    System.out.println(subClazz.protectedField);

    System.out.println(subClazz.publicField);

    }

    }

    这段代码的运行结果如下:

    ParentClass parentClass = new ParentClass();

    父类变量--private

    父类变量--friendly

    父类变量--protected

    父类变量--public

    ParentClass subClass = new SubClass();

    子类变量--private

    父类变量--friendly

    父类变量--protected

    父类变量--public

    SubClass subClazz = new SubClass();

    子类变量--private

    子类变量--friendly

    子类变量--protected

    子类变量--public

    从上面的结果中可以看出,private的变量与其它三种访问权限变量的不同,这是由于方法的重写(override)而引起的。关于重写知识的回顾留给以后的章节,这里我们来看一下其它三种访问权限下变量的覆盖情况。

    分析上面的输出结果就会发现,变量的值取决于我们定义的变量的类型,而不是创建的对象的类型。

    在上面的例子中,同名的变量访问权限也是相同的,那么对于名称相同但是访问权限不同的变量,情况又会怎样呢?事实胜于雄辩,我们继续来做测试。由于private变量的特殊性,在接下来的实验中我们都把它排除在外,不予考虑。

    由于上面的例子已经说明了,当变量类型是父类(ParentClass)时,不管我们创建的对象是父类(ParentClass)的还是子类(SubClass)的,都不存在属性覆盖的问题,因此接下来我们也只考虑变量类型和创建对象都是子类(SubClass)的情况。

    Java code

    class ParentClass {

    /* friendly */String field = "父类变量";

    }

    public class SubClass extends ParentClass {

    protected String field = "子类变量";

    public static void main(String[] args) {

    SubClass subClass = new SubClass();

    System.out.println(subClass.field);

    }

    }

    运行结果:

    子类变量

    Java代码

    class ParentClass {

    public String field = "父类变量";

    }

    public class SubClass extends ParentClass {

    protected String field = "子类变量";

    public static void main(String[] args) {

    SubClass subClass = new SubClass();

    System.out.println(subClass.field);

    }

    }

    运行结果:

    子类变量

    上面两段不同的代码,输出结果确是相同的。事实上,我们可以将父类和子类属性前的访问修饰符在friendly、protected和public之间任意切换,得到的结果都是相同的。也就是说访问修饰符并不影响属性的覆盖,关于这一点大家可以自行编写测试代码验证。

    对于静态变量和常量又会怎样呢?我们继续来看:

    Java code

    class ParentClass {

    public static String staticField = "父类静态变量";

    public final String finalField = "父类常量";

    public static final String staticFinalField = "父类静态常量";

    }

    public class SubClass extends ParentClass {

    public static String staticField = "子类静态变量";

    public final String finalField = "子类常量";

    public static final String staticFinalField = "子类静态常量";

    public static void main(String[] args) {

    SubClass subClass = new SubClass();

    System.out.println(SubClass.staticField);

    System.out.println(subClass.finalField);

    System.out.println(SubClass.staticFinalField);

    }

    }

    运行结果如下:

    子类静态变量

    子类常量

    子类静态常量

    虽然上面的结果中包含“子类静态变量”和“子类静态常量”,但这并不表示父类的“静态变量”和“静态常量”可以被子类覆盖,因为它们都是属于类,而不属于对象。

    上面的例子中,我们一直用对象来对变量(属性)的覆盖做测试,如果是基本类型的变量,结果是否会相同呢?答案是肯定的,这里我们就不再一一举例说明了。

    最后,我们来做个总结。通过以上测试,可以得出一下结论:

    由于private变量受访问权限的限制,它不能被覆盖。

    属性的值取父类还是子类并不取决于我们创建对象的类型,而是取决于我们定义的变量的类型。

    friendly、protected和public修饰符并不影响属性的覆盖。

    静态变量和静态常量属于类,不属于对象,因此它们不能被覆盖。

    常量可以被覆盖。

    对于基本类型和对象,它们适用同样的覆盖规律。

    最后我们再回到篇首的那道题,我想答案大家都已经知道了,结果是40。

    展开全文
  • java子类父类属性重复问题

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

    java 子类继承 父类, 但子类中 包含和父类相同 属性 ,给子类赋值之后,父类的相同的属性值还是空的。

    类定义如下:

    public class Person {

    private String name;

    private String age;

    // ignore getter and setter

    }

    public class Student extends Person {

    private String name;

    private String score;

    // ignore getter and setter

    }

    public static void main(String[] args){

    Student stu = new Student();

    stu.setAge("12");

    stu.setName("test");

    }

    debug看到

    a7748842bd41590ea920778ca1542707.png

    父类(Person)的name属性值是null,继承的方法是子类会覆盖掉父类相同的方法,但是这属性为什么没覆盖

    父类的属性被私有了,子类也重写了父类的方法,重写方法的时候也没去调用父类的方法,所以造成了父类属性值为空。

    都是private的啊!

    相同成员变量不会覆盖,http://blog.csdn.net/iwaich/article/details/9126661

    变量没有重写这一说

    变量是局部变量,你定义成public也不是同一个变量啊。这是两个家庭,恰好有一个孩子名字相同,但本质上是两个不同的变量。

    建议贴出setter方法体 如果使用了 super关键字 再讨论这个问题比较好

    可以在Student里编一个方法a(),在方法里用super调用Person类里方法,然后再在main方法里调用该a()方法,应该可行

    这个问题已经解决了。

    我只是指出题主在题目描述中的一点不准确的地方:

    父类(Person)的name属性值是null,继承的方法是子类会覆盖掉父类相同的方法,但是这属性为什么没覆盖。

    其实,根据我的理解:“子类属性对父类同名属性的作用”与“子类方法对父类同名方法的作用”是相同的。

    其实,所谓子类”覆盖了“父类同名方法,其实并没有真地覆盖,父类方法还在那里。只不过你在debug根据里看不到而已。

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

    千次阅读 2021-03-14 01:15:16
    最近在学习到Java的继承和多态...比较直观的理由是,子类要能够重写父类的方法的前提条件是继承,子类对父类的私有方法并不继承,也没有访问权限,自然也是不能重写的。接下来看一个例子:[java] view plaincopypub...
  • 多态的体现。...(该方法未被子类重写) 2.2 该实例如果调用父类中的方法,若该方法被子类重写,则一定调用的是在子类重写后的该方法。 2.3 该实例不可以调用父类中没有的方法。(该方法子类特有)
  • Java子类使用Override能否重写父类中的属性值?       首先,让我们来看一个例子,大家可以猜测下输出结果是什么。 1.父类 public class FatherClass { String info=...
  • 用学生的输出为例子,子类继承父类,然后在子类中新定义一个属性并可以给父类属性赋值,以及重写tostring和重写equals方法。 demo测试 package Student; public class demo { public static void main(String[] ...
  • 最近在学习到Java的继承和多态...比较直观的理由是,子类要能够重写父类的方法的前提条件是继承,子类对父类的私有方法并不继承,也没有访问权限,自然也是不能重写的。接下来看一个例子:[java] view plaincopypub...
  • 四十六:子类重写父类的方法   上一节详细介绍了通过关键字Super 实现在子类中调用父类属性或方法的过程,本节介绍下在子类中如何重写父类的方法。 1.理论整理 2.实践 1.在子类中 “重写” 父类中static 类型的...
  • 关于子类重写父类方法的问题

    千次阅读 2019-06-30 13:05:56
    子类重写父类的方法; 1.父类中私有方法不能被重写。因为父类私有方法子类根本无法继承。 2.父类中方法有final修饰的不能被重写 3.子类所重写的方法的访问修饰符必须高于或者等于父类的访问修饰符。 4.如果父类的...
  • corejava_子类重写父类

    2021-09-21 12:22:45
    * 子类重写父类的方法后,再创建子类对象,就一定会调用子类重写的方法 */ /* * 父类私有属性和方法其实可以被继承,但继承后有一个筛选的过程,使得子类不能访问父类的私有属性和方法。 * 1)私有属性可以通过...
  • 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 ...
  • Java重写父类的方法

    千次阅读 2020-08-08 12:24:08
    大部分时候子类是以父类为基础的,但是有时候子类需要重写父类的方法。比如说我们定义了一个Person类来表示人类。里面定义了一个方法为上洗手间,ManPeople 继承了这个类,Man上洗手间的方式和Woman上洗手间的地方...
  • java子类调用父类的方法中包含子类重写的实例方法# 看题目是不是很绕,这个我也不知道怎么才能更简单的表达了# 先看代码:public class Common {public static void main(String[] args) {Sub sub = new Sub();...
  • JAVA重写父类方法

    千次阅读 2021-11-13 13:37:06
    “两小”:指的是子类方法返回类型应比父类方法返回类型更小或者相等 八大基本类型大小 byte 8bit short 16bit char 16bit int 32bit float 32bit long 64bit double 64bit “一大”指的是子类方法的访问...
  • 如果子类重写父类的方法的访问权限低于其在父类中的访问权限,会影响多态。 在父类中是public的方法,如果子类中将其降低访问权限为private, 那么父类在实现多态时如果调用子类的这个重写方法,但是这个方法已经...
  • java 子类强转父类 父类强转子类

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

    千次阅读 2021-02-12 08:55:55
    子类(1)子类定义class 子类名 extends 父类名 {...}(2)子类继承性子类继承了父类的所有属性和除了构造方法的其余方法。子类父类在同个包中:子类继承父类除了private成员子类父类在不同包中:子类继承父类除了...
  • 子类可以重写父类的private方法吗

    千次阅读 2020-08-14 08:56:42
    “private是私有的,其他类是不能访问的,子类也不可以访问,所以你可以重新实现父类的该方法,不会有冲突,但是你重新实现的方法,不叫重写也不叫重载,是一个该子类新增的方法,和子类的一般扩展方法一样” public ...
  • 子类不能重写父类静态方法和变量,但是可以继承。主要是因为静态只属于类,他在类中开辟一个空间专门存放静态的东西。而子类之所以”重写“是因为他自己也建立了一个同名的变量/方法,然后写了自己的东西在里面。
  • 在学装饰者模式的时候发现子类重写父类方法时调用父类同名方法: public abstract class Beverage { String description = "Unknown Beverage"; public String getDescription() { return description; } ...
  • Python子类调用父类属性的方法

    千次阅读 2020-12-02 07:12:35
    最常见的就是初始化方法__init__()python中类的初始化方法是__init__(),因此父类子类的初始化方法都是这个,如果子类不实现这个函数,初始化时调用父类的初始化函数,如果子类实现这个函数,就覆盖了父类的这个函数...
  • 之前一直以为 this关键字 是指调用者对象,但是这次才真正理解,this代表当前对象,但是指向...如下,this.s ,无论B 子类有没有 s属性,又或者s 的修饰符是 private 或者 public ,this.s 永远会打印出 当前类的 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 114,738
精华内容 45,895
关键字:

java子类重写父类属性

java 订阅