精华内容
下载资源
问答
  • 主要介绍了Java编程关于子类重写父类方法问题的理解,分享了有关子类重写父类的实例,具有一定参考价值,需要的朋友可以了解下。
  • 本篇文章里小编给大家整理了关于java子类调用父类方法中包含子类重写的实例方法以及相关知识点,需要的朋友们可以学习下。
  • C#子类如何重写父类方法

    千次阅读 2020-03-20 17:52:10
    子类重写父类方法代码如下: using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using System.IO; namespace 视频3._5 { class Program ...

    子类重写父类的方法代码如下:

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    using System.IO;
    
    namespace 视频3._5
    {
        class Program
        {
            static void Main(string[] args)
            {
            	Person p = new Person(); //实例化父类的对象
                p.Show();  //调用父类方法
    
                Teacher t = new Teacher(); //实例化子类对象
                t.Show(); //调用子类方法
    
                Console.ReadKey();
            }
    		
    		public class Person //父类人类
            {
            	private string _name; //字段
                public string Name  //属性
                {
                    get { return _name; }
                    set { _name = value; }
                }
    
                private int _age;
                public int Age
                {
                    get { return _age; }
                    set { _age = value; }
                }
    
                private char _gender;
                public char Gender
                {
                    get { return _gender; }
                    set { _gender = value; }
                }
                public virtual void Show()  //虚方法---
                {
                    Console.WriteLine("我是人别害怕");
                }
    
            }
    
    		public class Teacher : Person
            {
                public override void Show()//重写父类方法
                {
                    Console.WriteLine("我是老师别害怕");
                }
            }
            
    

    说明如下:

    • 子类的方法名可以和父类的方法名重写,但是代码会出现一条绿线,并不影响使用。
    • 怎么解决——可以在子类的publi修饰符后面加 new 就解决了,无论是否加new都不影响使用。
    • 第二种解决绿线的办法:在父类的方法的public修饰符后加 virtual
    • 在子类中重写父类的方法,加上一个override。调用父类的方法,但是把父类的方法进行重写了
    • 更换了方法里面的内容
    • 虚方法不能用static修饰、不能写成静态的,已经是虚方法了没有必要变成静态的。private在本类中只能访问、子类访问不到,写成虚方法就是为了让其他子类重写。
    • virtual不能与private一起使用
    • 子类当中可以拿到父类的方法、子类中new下就OK了
    展开全文
  • 子类可以重写父类的private方法

    千次阅读 2020-08-14 08:56:42
    “private是私有的,其他类是不能访问的,子类也不可以访问,所以你可以重新实现父类的该方法,不会有冲突,但是你重新实现的方法,不叫重写也不叫重载,是一个该子类新增的方法,和子类的一般扩展方法一样” public ...

    “private是私有的,其他类是不能访问的,子类也不可以访问,所以你可以重新实现父类的该方法,不会有冲突,但是你重新实现的方法,不叫重写也不叫重载,是一个该子类新增的方法,和子类的一般扩展方法一样”

    public class A {
        private void print() {
            System.out.println("A");
        }
        public static void main(String[] args) {
            A a = new B();
            a.print();
            B b = new B();
            b.print();
            new B().print();
        }
    }
    
    class B extends A {
        public void print() {    
            System.out.println("B");
        }
    }

     结果是
    A
    B
    B
    在java中,private的变量和方法对在类外是不可见的,当然更谈不上重写,B类中看似是重写了父类A中的print方法,但由于父类中为private,所以B类中的print与A类中的print方法并无任何关系,可以认为是一个全新的方法。
    举个可能不恰当的例子,继承时,父类方法在能被子类“看到”的情况下,父类的方法可以想象成直接被copy到了子类中,如果子类不想要用这个父类方法的实现,就要去重写,相当于覆盖掉了copy过来的方法,那怎么就算覆盖呢?
    方法的作用,就算通过调用某个方法,会达到一些效果或者得到一(个)些值,在重写这个概念中,子类不想要父类方法的达到的效果或者值,就要去修改,即覆盖。所以覆盖也就必须是方法参数,方法名,返回值都要和父类相同才能算是覆盖。设想,如果三个要素任一个不符合,就会产生一个和想要覆盖的那个方法不同的新方法,这个新方法是属于当前子类的,原来本想覆盖的那个类也没有被覆盖,依旧存在。(在更改的参数的情况下会成为重载,在只改变了返回值的情况下会报错,具体请查看重载的内容)
    再回到这个代码,父类中的方法是private的,即子类是“看不到”的,所以也就没有被“copy”到子类中,所以看似是重写,实际上是一个属于子类的新的方法,只不过“恰好”和父类中的方法重名了。
    再想多态的要求,子类自己新增的方法在多态的情况下是不能使用的,是不可见的,所以当调用print方法时,编译器看到子类没有父类中的那个方法或者其重写,就会选择调用父类的方法。如果将父类的private改为高一级的可视性,子类就可以“看到”了,也就“copy”过来了,输出为
    B
    B
    B

     

     

     

     

    展开全文
  • 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方法,那么子类隐藏父类的方法,而不是重写父类方法。

    展开全文
  • 关于子类重写父类方法的问题

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

    关于访问修饰符对重写父类方法的影响

    结论

    子类重写父类的方法;
    1.父类中私有方法不能被重写。因为父类私有方法子类根本无法继承。
    2.父类中方法有final修饰的不能被重写
    3.子类所重写的方法的访问修饰符必须高于或者等于父类的访问修饰符。
    4.如果父类的方法有返回值类型,则子类对应的方法的返回值须于父类相同或者是父类返回值的派生类(jdk1.5版本及以后的版本

    代码样例

    import java.util.ArrayList;
    import java.util.List;
    
    public class Person {
    
        public List method1(){
            System.out.println("Person method1");
            return null;
        }
    
        protected ArrayList method2(){
            System.out.println("Person method2");
            return null;
        }
    
        void method3(){
            System.out.println("Person method3");
        }
    
        private void method4(){
            System.out.println("Person method4");
        }
    }
    

    子类

    重写method1方法,返回值为派生类
    重写method2方法,子类的访问修饰符高于父类的访问修饰符

    import java.util.ArrayList;
    
    public class XiaoMing extends Person{
    
        @Override
        public ArrayList method1() {
            return null;
        }
    
        @Override
        public ArrayList method2() {
            return super.method2();
        }
    
        @Override
        void method3() {
            super.method3();
        }
    }
    
    展开全文
  •  上面的代码我们可以看到,上面的类有两个内部类Sub和Super,Sub继承了Super,Sub类重写父类Super的getType方法,这是一个静态方法;  而main方法中创建了一个Super变量指向了一个子类Sub对象,并调用了其...
  • 子类继承父类,重载了父类方法。面试经常考到方法的调用,以及构造函数先后顺序。 例子 定义父类,申明方法say() public class TestParent { protected static String name = "parent"; TestParent(){ say(); ...
  • 最近学习到Java的继承和多态时遇到了...比较直观的理由是,子类要能够重写父类方法的前提条件是继承,子类对父类的私有方法并不继承,也没有访问权限,自然也是不能重写的。接下来看一个例子: [java] view...
  • 1.子类重写父类方法后,如果实际是子类的对象实例, 则会调用子类的方法. 2.子类继承父类, 构造子类的时候,会先构造父类(先执行父类构造函数)后构造子类 参考: 1.例题:子类重写父类方法后的调用规则 ...
  • 子类重写父类方法,调用时会调用子类重写之后的方法 当然,这一切的前提都是 实例化子类对象 2,下面代码的输出是什么? // null      public class Base {  private String baseName = "base...
  • python 子类重写父类方法

    万次阅读 2019-09-03 20:51:57
    子类拓展了父类,子类是一种特殊的父类,大部分时候,子类总是以父类为基础,额外增加新的方法,但有一种情况例外,子类需要重写父类方法,见代码: class Animal: def eat(self): print('kkkkkk') class ...
  • 重写和重载 重写是继承的时候,重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值...子类重写父类方法 子类重写了父类的方法,如果用父类的对象去调用,就会使用父类的实现 如果用子类的对象去调用...
  • String a = "父类"; protected void Method(){ System.out.println(a); } } class B extends A{ String a = "子类"; } public class Test{ public static void main(String[] args) { B b = new B(); b.
  • 如果一个方法在子类的实例被调用,或者一个属性在子类的实例被访问,但是该方法或属性在子类中并不存在,那么就会自动的去其父类进行查找。 继承父类后,就能调用父类方法和访问父类属性,而要完成整个集成...
  • 关于子类能否重写父类的静态方法,对像我这种初级的编程爱好者来说仍是值得讨论的一件事,下面我们通过具体实例,对此问题进行简单的探索。
  • <?php class father{ //定义father类 public function method(){ //定义方法 echo '<br />father method'; } } class son extends father{ ...
  • 如果子类重写的父类的方法的访问权限低于其在父类中的访问权限,会影响多态。 在父类中是public的方法,如果子类中将其降低访问权限为private, 那么父类实现多态时如果调用子类的这个重写方法,但是这个方法已经...
  • 子类继承父类,并重写父类方法

    千次阅读 2019-04-29 16:59:54
    子类继承父类,并重写父类方法 2016年08月04日 00:04:07jinxueH专栏阅读数:17172 版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/euxnijuoh/article/details/52108863 例子...
  • java子类怎么调用和重写父类方法

    千次阅读 2019-01-09 17:09:47
    子类重写父类方法: 以下的小例子,展示了如何重写 父类: //-定义一个父类–鸟类Birds: public class Birds{ //-定义父类鸟类Birds的fly()方法 public void fly(){ System.out.println(&amp;amp;...
  • 父类的static方法不能被重写,如果在子类中定义类和父类完全相同static方法,则父类的static方法被隐藏,使用子类对象调用的还是子类方法。 演示 public class OverrideDemo { public static void main(String...
  • 子类能否重写父类的静态方法

    千次阅读 2018-09-03 23:33:27
    今天看到一个面试题:...首先我们通过例子来证明子类不能重写父类的静态方法: 父类对象代码: public class Parent { public static void staMethod(){ System.out.println("调用父类静态方法");...
  • Java:子类使用Override能否重写父类中的属性值?       首先,让我们来看一个例子,大家可以猜测下输出结果是什么。 1.父类 public class FatherClass { String info=...
  • 子类继承父类,重写了父类方法,那么调用时就会调用子类重写后的方法 例子 public class TestParent { protected static String name = "parent"; TestParent(){ say(); } public void say(){ System.out....
  • 1、子类重写父类静态方法,变为非静态方法会报错。 public class Person { public static void method(){ System.out.println("Person"); } } public class Man extends Person { public void method(){...
  • 当使用多态方式调用方法时,首先检查父类中是否有该方法,如果没有,则error;如果有,调用子类的同名方法。 example: package demo; public class people { public people(){ } public void run(){ System....
  • Java - 子类重写父类方法

    千次阅读 2019-03-16 17:21:33
    如果子类可以继承父类的某个方法,子类就可以重写这个方法 . 比如实例: 测试类: public class Test3_17 { public static void main(String[] args) { // TODO Auto-generated method stub double english ...
  • 多个子类重写父类中的抽象方法父类中调用抽象方法时,怎么判断哪个子类重写了该父类中方法

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 231,866
精华内容 92,746
关键字:

在子类中重写父类的方法