精华内容
下载资源
问答
  • 子类中重写父类方法

    2021-09-05 13:07:16
    重写的时候,不需要关注参数,只需方法名相同即可 def __init__(self): pass s1 = Son('xiaoming', 12) s1.sing() 为什么子类中重写父类方法就不能进行调用了? 之前我么讲了mro 打印继承顺序,同时其也是方法或属性的...

    定义一个Person类

    class Person(object): def init(self, name, age): self.name = name self.age = age

    定义一个Father类,继承Person

    class Father(Person): def sing(self): print('我会唱学猫叫,跟我一起来')

    def dance(self):
        print('我会跳四小天鹅,就是天鹅还缺仨')

    定义一个Son类,继承Father

    class Son(Father): # 需求:在Son执行sing方法时,我么你让他唱一分钱 def sing(self): print('我喜欢唱一分钱, 你自己学猫叫吧')

    # 我们进行方法 重写的时候,不需要关注参数,只需方法名相同即可
    def __init__(self):
        pass

    s1 = Son('xiaoming', 12)

    s1.sing()

    为什么子类中重写了父类方法就不能进行调用了?

    之前我么讲了mro 打印继承顺序,同时其也是方法或属性的调用顺序,例如想使用Son对象调用sing方法,但是不知道sing在哪个类中

    所以,系统先去当前Son类中查找,查看是否存在sing方法

    如果存在,则调用,如果不存在,则去父类中 Father中查找,如果Father类中存在sing则调用,如果不存在,则去更高级父类(person)中查找

    直到查询到object类中,如果依然不存在,则报错

    所以如果子类中书写了对应的方法,则父类中的同名方法无法被调用

    可不可以让Son类不需要使用name和age就可以创建对象呢? 在Son中重写init方法

    s1 = Son() s1.sing()

    展开全文
  • 主要介绍了Java编程关于子类重写父类方法问题的理解,分享了有关子类重写父类的实例,具有一定参考价值,需要的朋友可以了解下。
  • 本篇文章里小编给大家整理了关于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();
    
    
    	}
    
    }
    
    
    展开全文
  • 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方法,那么子类隐藏父类的方法,而不是重写父类方法。

    展开全文
  • 子类如何重写父类方法? 前提: 1-规则一:重写方法不能比被重写方法限制有更严格的访问级别。 (但是可以更广泛,比如父类方法是包访问权限,子类的重写方法是public访问权限。) 2-规则二:参数列表必须与被重写...

    子类如何重写父类的方法?

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

    (但是可以更广泛,比如父类方法是包访问权限,子类的重写方法是public访问权限。)
    2-规则二:参数列表必须与被重写方法的相同。

    (需要注意的是如果子类方法的参数和父类对应的方法不一样,那就不是重写,而是重载)

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

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

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

    6-规则六:如果一个方法不能被继承,则不能重写它

    如果子类能够继承父类的某个方法,那么子类就能够重写这个方法

    例如:

    父类

     class Demo01{
        void jkl(){
            System.out.print("你好啊");
        }
        
    
    }
    

    子类 继承父类,并且重写了他的方法

    class Demo02 extends Demo01{
        void jkl(){
            System.out.print("我好");
        }
        
    }
    
    展开全文
  • 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 ...
  • 子类可以重写父类的private方法

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

    千次阅读 2019-06-30 13:05:56
    子类重写父类方法; 1.父类私有方法不能被重写。因为父类私有方法子类根本无法继承。 2.父类中方法有final修饰的不能被重写 3.子类所重写的方法的访问修饰符必须高于或者等于父类的访问修饰符。 4.如果父类的...
  •  上面的代码我们可以看到,上面的类有两个内部类Sub和Super,Sub继承了Super,Sub类重写父类Super的getType方法,这是一个静态方法;  而main方法中创建了一个Super变量指向了一个子类Sub对象,并调用了其...
  • 重写和重载 重写是继承的时候,重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值...子类重写父类方法 子类重写了父类的方法,如果用父类的对象去调用,就会使用父类的实现 如果用子类的对象去调用...
  • 子类隐藏父类方法(通过new操作符) namespace ConsoleApp1 { class Program { static void Main(string[] args) { Student stu = new Student(); stu.Report(); CsStudent csStudent = new CsStudent(); ...
  • 继承,子类重写父类方法 一:继承 class Phone { constructor(name, price) { this.name = name; this.price = price } start(){ console.log(this.name,'开始执行函数'); this.father(this.name,this....
  • java子类怎么调用和重写父类方法

    千次阅读 2019-01-09 17:09:47
    子类重写父类方法: 以下的小例子,展示了如何重写 父类: //-定义一个父类–鸟类Birds: public class Birds{ //-定义父类鸟类Birds的fly()方法 public void fly(){ System.out.println(&...
  • 子类继承父类,重载了父类方法。面试经常考到方法的调用,以及构造函数先后顺序。 例子 定义父类,申明方法say() public class TestParent { protected static String name = "parent"; TestParent(){ say(); ...
  • 1.子类重写父类方法后,如果实际是子类的对象实例, 则会调用子类的方法. 2.子类继承父类, 构造子类的时候,会先构造父类(先执行父类构造函数)后构造子类 参考: 1.例题:子类重写父类方法后的调用规则 ...
  • 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.
  • python 子类重写父类方法

    万次阅读 2019-09-03 20:51:57
    子类拓展了父类,子类是一种特殊的父类,大部分时候,子类总是以父类为基础,额外增加新的方法,但有一种情况例外,子类需要重写父类方法,见代码: class Animal: def eat(self): print('kkkkkk') class ...
  • 如果一个方法在子类的实例被调用,或者一个属性在子类的实例被访问,但是该方法或属性在子类中并不存在,那么就会自动的去其父类进行查找。 继承父类后,就能调用父类方法和访问父类属性,而要完成整个集成...
  • 子类重写父类方法,调用时会调用子类重写之后的方法 当然,这一切的前提都是 实例化子类对象 2,下面代码的输出是什么? // null      public class Base {  private String baseName = "base...
  • Java - 子类重写父类方法

    千次阅读 2019-03-16 17:21:33
    如果子类可以继承父类的某个方法,子类就可以重写这个方法 . 比如实例: 测试类: public class Test3_17 { public static void main(String[] args) { // TODO Auto-generated method stub double english ...
  • <?php class father{ //定义father类 public function method(){ //定义方法 echo '<br />father method'; } } class son extends father{ ...
  • 关于子类能否重写父类的静态方法,对像我这种初级的编程爱好者来说仍是值得讨论的一件事,下面我们通过具体实例,对此问题进行简单的探索。
  • 子类继承父类,并重写父类方法

    千次阅读 2019-04-29 16:59:54
    子类继承父类,并重写父类方法 2016年08月04日 00:04:07jinxueH专栏阅读数:17172 版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/euxnijuoh/article/details/52108863 例子...
  • 如果子类重写父类方法的访问权限低于其在父类中的访问权限,会影响多态。 在父类中是public的方法,如果子类中将其降低访问权限为private, 那么父类在实现多态时如果调用子类的这个重写方法,但是这个方法已经...
  • 一道题发现,子类在重写父类方法时,会出现子类实例调用父类的方法而不是子类方法的情况。 一、父类使用箭头函数,子类使用传统函数 class Animal { sayName = () => { throw new Error('你应该自己实
  • 父类的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("调用父类静态方法");...
  • 多个子类重写父类中的抽象方法父类中调用抽象方法时,怎么判断哪个子类重写了该父类中方法
  • 1、子类重写父类静态方法,变为非静态方法会报错。 public class Person { public static void method(){ System.out.println("Person"); } } public class Man extends Person { public void method(){...

空空如也

空空如也

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

怎样在子类中重写父类方法