精华内容
下载资源
问答
  • A类继承了B类方法,按照继承的规则,实例化A之后应该输出一个double类型的数;然而main方法里不仅让实例化的A输出double类型的数,还需要输出一个整型一个字符串。此时就需要在子类A对父类B进行操作:public ...

    面向对象编程语言具有多态的特性;

    首先B类中定义了一个p方法,参数为double类型;

    A类继承了B类方法,按照继承的规则,实例化A之后应该输出一个double类型的数;

    然而main方法里不仅让实例化的A输出double类型的数,还需要输出一个整型和一个字符串。此时就需要在子类A中对父类B进行操作:

    public class OverrideTest{
        public static void main(String[] args){
            A a = new A();
            a.p(10);
            a.p(10.0);
            a.p("siend");
        }
    }
    
    class B {
        public void p(double i)
        {
            System.out.println(i*2);
        }
    }
    
    class A extends B{
        public void p(String i)//重载   让class A 可以输出字符串 
        {
            System.out.println(i);//重写  覆盖   让class A的输出改变为 i 
        }
        public void p(int i)//重载  让class A 可以输出整形
        {
            System.out.println(i*5);//重写  覆盖   让class A的输出改变为 i *5
        }
    }

    运行结果:
    50
    20.0
    siend

    结论 :
    重载:在子类中重新定义父类中的方法的参数

    重写(覆盖):在子类中重新定义父类中的方法的方法体

    展开全文
  • 先给出答案:可以被子类继承,不能被子类重写。 关于父类子类关系还不太了解的看一去看一下链接https://blog.csdn.net/qq_34826261/article/details/97635047,里面详细解释了父类子类不同情况下成员方法成员...

    先给出答案:可以被子类继承,不能被子类重写。
    关于父类和子类关系还不太了解的看一去看一下链接https://blog.csdn.net/qq_34826261/article/details/97635047,里面详细解释了父类和子类不同情况下成员方法和成员变量的关系。这里默认已经知道了子类和父类之间的关系。
    那么子类能不能重写父类的静态方法?

    class parent{
    	public static void printA() {
    		System.out.println("父类静态方法");
    	}
    	public void printB() {
    		System.out.println("父类普通方法");
    	}	
    }
    
    class child extends parent{
    	public static void printA() {
    		System.out.println("子类静态方法");
    	}
    	public void printB() {
    		System.out.println("子类普通方法");
    	}	
    }
    

    下面调用子类的方法

    public class Main {
        public static void main(String[] args){
        	child c1 = new child();
        	c1.printA();
        	c1.printB();
        }
    }
    // 输出
    子类静态方法
    子类普通方法
    

    可以调用printC(),这显然说明子类可以继承父类的static方法。
    那这里printA方法输出了“子类静态方法”,是子类对父类static方法的重写吗?并不是,通过子类自身调用方法肯定是调用自己的方法,即子类对象通过指针调用方法时,就是直接调用子类自身的静态方法。
    Java编程思想里说

    “覆盖”只有在某方法是基类的接口的一部分时才会出现。即,必须能将一个对象向上转型为它的基本类型并调用相同的方法。
    

    这说的是啥?看不懂,直接上例子。
    我们知道在向上转型时,对象所调用的方法时子类和父类所共有的方法,就是说父类未被覆盖的方法和父类被覆盖的方法(不懂的点链接看第五部分内容),看一下代码输出:

    public class Main {
        public static void main(String[] args){
        	parent c2 = new child();
        	c2.printA();
        	c2.printB();
        }    
    }
    // 输出
    父类静态方法
    子类普通方法
    

    这里看到printA方法输出的是“父类静态方法1”,说明printA方法并没有被覆盖。在加上重写的注释看一下,直接报错。
    在这里插入图片描述
    实际上Java里不管是static方法还是final方法不是不能被覆盖的,那为什么在子类写一个和父类同名的静态方法不会报错,而写一个同名的final方法分分钟报错给你看?其实final修饰的不管是普通方法还是静态方法,子类中都不允许由同名的方法,这是规定。那子类里的为什么可以有重名的静态方法,可以把它理解为重新定义,,静态方法是在类加载时就和类绑定在一起,是静态绑定,子类有同名的静态方法,就是在加载子类的同名静态方法时重新分配一块空间,和父类的静态方法没有任何关系!!下图只是示意图,不要死扣静态方法和普通方法的内存区不一样。
    在这里插入图片描述
    可以简单粗暴的理解一下:重写的意思是重新定义父类的虚函数,但是虚函数是动态绑定的,而静态方法是静态绑定的,所以静态函数必然不能是虚函数,也就不存在重写了。
    在最后总结一下,父类的静态方法可以被继承,不能被重写。

    展开全文
  • Java语言,子类继承父类的方法属性。如果不进行重写,那么子类就直接使用父类的属性方法。如果子类对父类的属性方法进行了重写(也就是对属性 方法进行了重新的定义),那么子类就会保存两份属性两个...

    Java语言中,子类继承父类的方法和属性。如果不进行重写,那么子类就直接使用父类的属性和方法。如果子类对父类的属性和方法进行了重写(也就是对属性 和 方法进行了重新的定义),那么子类就会保存两份属性和两个方法。程序可以通过子类对象访问这两个属性(父类对象的属性,子类对象的属性);程序也可以通过子类对象调用两个方法(父类对象的方法,子类对象的方法)。

    下面是代码示例:

    (一)父类:AutoMobile.java

    public class AutoMobile {
    	int numberOfWheel;
    	int numberOfDoor;
    	int numberOfSites;
    	String name;
    	
    	void drive(){
    		System.out.println("父类的drive()方法");
    	}
    	void start(){
    		System.out.println("父类启动");
    	}
    	void stop(){
    		System.out.println("父类关闭");
    	}
    }

    ( 二)子类:Car.java

    public class Car extends AutoMobile{
    
    	String name; //小汽车车子的名字,重写的name属性
    	int carTrunk;
    	//重写了start()方法
    	void start(){
    		System.out.println("子类start()方法");
    	}
    	void autoDrive(){
    		System.out.println("自动驾驶");
    	}
    }

    (三)测试类InheritTest.java

    通过创建一个Car对象,然后访问父类和子类属性,调用父类和子类方法

    public class InheritTest {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		Car car = new Car();
    		
    		//给子类对象的name属性赋值
    		car.name = "吉利牌小汽车";
    		//给子类对象中的父类属性赋值
    		((AutoMobile)car).name = "交通工具";
    		
    		System.out.println(car.name);
    		System.out.println(((AutoMobile)car).name);
    		
    		//调用子类对象的方法start
    		car.start();
    		//调用子类对象中的父类方法start
    		((AutoMobile)car).drive();
    	}
    }

     

    (四)执行结果

     

    展开全文
  • day09_07_继承中方法的覆盖重写_注意事项
  • day09_08_继承中方法的覆盖重写_应用场景
  • 继承: 1. 提高了代码的复用性。...必须是类与类之间有所属关系才可以继承,所属关系叫做谁是谁的一员。 父类的来源是不断从子类抽取而来的 class Student { String name; int age; void study(){ ...
    继承:

    1. 提高了代码的复用性。
    2. 让类与类之间产生了关系,有了这个关系,才有了多态的特性

    注意:千万不要为了获取其他类的功能,简化代码而继承。
    必须是类与类之间有所属关系才可以继承,所属关系叫做谁是谁中的一员
    父类的来源是不断从子类抽取而来的

    class Student 
    {
           String name;
           int age;
          void study(){
            System.out.println("study");
        }
    }
    class Worker 
    {
           String name;
           int age;
     void work(){
            System.out.println("work");
        }
    }
    

    学生和工人都有姓名年龄,这属于他们的共性内容
    将学生和工人的共性描述提取出来,单独进行描述,
    只要让学生和工人与单独描述的这个类有关系,就可以了。

    class Person{
        String name;
        int age;
    }
    class Student extends Person
    {
        void study(){
            System.out.println("study");
        }
    }
    class Worker extends Person
    {
        void work(){
            System.out.println("work");
        }
    }
    

    Java语言中,java只支持单继承,不支持多继承。

    因为多继承容易带来安全隐患:当多个父类中,定义了相同功能,当功能内容不同时,子类对象不确定要运行哪一个。

    Java支持多层继承 就是c继承了b ,b又继承了a,也就是一个继承体系。
    如何使用一个继承体系功能呢?
    想要使用体系,先查阅体系中父类的描述,因为父类中定义的是该体系中共性功能。
    通过了解共性功能,就可以知道该体系的基本功能,那么这个体系已经可以基本使用了。
    那么在具体调用时,要创建最子类的对象,为什么?

    1. 有可能父类不能创建对象。
    2. 创建子类对象可以使用更多的功能,包括基本的也包括特有的。

    当子类出现和父类一模一样的函数时,当子类对象调用该函数,会运行子类函数的内容。
    如同父类的函数被覆盖一样。

    这种情况是函数的另一个特性:重写(覆盖)。

    当子类继承了父类:有了父类的功能,但是子类虽具备该功能,但是功能的内容却和父类不一致,这时没有必要定义新功能,而是使用覆盖特性,保留父类的功能定义,并重写功能内容。

    覆盖:

    1. 子类覆盖父类,必须保证子类权限大于等于父类权限,才可以覆盖,负责编译失败。
    2. 静态只能覆盖静态。

    记住:
    重载:只看同名函数的参数列表。
    重写:子类父类方法一模一样

    权限:public private 还有默认权限 ,什么都不写为默认权限,默认权限在public与private中间


    案例:
    class Tel{
        void show(){
            System.out.println("显示电话");
        }
    }
    class NewTel extends Tel{
        void show(){
            super.show();
            System.out.println("姓名");
            System.out.println("型号");
        }       
    }
    

    定义一个手机类,显示信息,初期显示电话,后期显示电话,姓名,型号,我们应该怎么做呢?
    使用继承,利用复写这一特性而给程序提高扩展性。


    子父类中构造函数的特点-子类实例化过程

    子父类的构造函数

    在对子类对象进行初始化时,父类的构造函数也会运行,那是因为子类的构造函数默认第一行有一条隐式的语句 super()
    super(): 会访问父类中空参数的构造函数。而且子类中所有的构造函数默认第一行都是super()

    为什么子类一定要访问父类中的构造函数?
    因为父类中的数据,子类可以直接获取,所以子类对象在建立时,需要先查看父类是如何对这些数据进行初始化的。所以子类在对象初始化时,要先访问一下父类中的构造函数

    注意:super语句一定定义在子类构造函数的第一行。

    子类实例化过程
    结论:
    子类的所有构造函数,默认都会访问父类中空参数的构造函数
    因为每一个构造函数内的第一行都有一句隐式super();

    当父类中没有空参数时,子类必须手动通过super语句形式来指定要访问父类中的构造函数的构造函数

    当然:子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数,子类中至少会有一个构造函数会访问父类中的构造函数

    展开全文
  • 继承中方法覆盖的多种约束:
  • day09_06_继承中方法的覆盖重写_概念与特点
  • typescript继承和重写

    万次阅读 2018-12-18 11:59:43
    类的继承和重写 在这里通过一个例子,说一下typescript继承和重写 //父类 class Gege{ public name:string; public age:number; public sex:string; public constructor(sex:string,name:string,age:number){ ...
  • C# 重载 重写 覆盖

    千次阅读 2017-07-25 18:10:39
    一、重载 1、重载示意 重载(Overload)是重新加载的意思,指的是同一个类同名,但是参数列表不同的方法组(返回值不能区别函数是否重载),重载没有关键字。通俗点说重载是对内存中同一个类的函数或方法进行...
  • 1.接口的继承 一个类实现“子接口”:该实现类,需要既实现“子接口”的方法...Java的接口多继承时:如果IFatherIFaher2两个父接口同时存在同名的默认方法,connection(): 如果“子接口”不做任何处理
  • 类、继承和重写

    千次阅读 2021-06-13 10:03:23
    类、继承和重写前言一、类1. 成员变量2. 成员方法3. 权限修饰符4. 代码示例二、继承和重写1. 继承(1)继承的特点(2)继承示例2. 重写(1) 重写的要求(2) 重写的示例总结 前言 现实生活,对象就是事物存在的实体...
  • java子类继承父类、方法的重写覆盖)   在程序,如果想声明一个类继承另一个类,需要使用extends关键字。 格式: class 子类 extends 父类 {} public class Text { public static void main (String[]...
  • C#重写和覆盖

    千次阅读 2019-03-07 14:43:56
    在研究重写和覆盖之前我们先来研究下继承关系构造函数方法的执行顺序问题。 继承关系的构造函数方法执行顺序: class A { public A() { Console.WriteLine("这是a构造函数"); } public ...
  • equals方法: 继承中该方法存在以下的问题: 如果子类能够拥有相等的概念, 则覆盖该方法时应该采用getClass方法; 如果由超类决定相等的概念, 那么就可以使用instanceof进行检测, 这样可以在不同的子类之间进行相等的...
  • c#重写覆盖,隐藏,重载,继承

    千次阅读 2016-09-10 10:41:05
    1.重写和覆盖:在c#这两个是一个意思,重写就是覆盖覆盖就是重写 2.隐藏:隐藏就是子类与父类的方法一样(子类函数名前加一个new),并且子类不是虚方法,那么子类就会隐藏父类方法 3.重载:方法名相同,参数...
  • 重写和覆盖区别

    千次阅读 2019-09-15 09:11:51
    今天看到重写和覆盖,有些忘记了,在博客园上看到了介绍,顺便学习了,记录下方便学习,原文地址原文内容为:重写 用关键字 virtual 修饰的方法,叫虚方法。可以在子类中用override 声明同名的方法,这叫“重写”。...
  • 继承—子父类成员函数的特点-覆盖 一、成员函数 1. 子类如何查找成员函数 ·当子类父类出现的成员函数相同(返回值类型,函数名相同,参数列表相同)时,会运行子类的函数;这种现象,成为覆盖操作。这是...
  • 关于C#类方法的重写和覆盖

    千次阅读 2016-03-09 22:27:04
    在C#改变类相同名称的方法的实现过程有三种方式:重载,重写和覆盖。 首先重载是指具有相同的方法名,通过改变参数的个数或者参数类型实现同名方法的不同实现。 重写则是只在继承中,子类通过override关键字...
  • ava使用extends关键字完成继承C++继承不同之处在于java只支持单继承,不支持多重继承继承让我们的代码编码变得简单,维护也变得简单,扩展变得容易。我们在继承的时候不能继承构造方法,一个类得到构造...
  • java子父类继承时方法重写与属性覆盖
  • C#重写和覆盖的区别

    千次阅读 2016-11-16 19:27:23
    C#重写和覆盖的区别

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 141,323
精华内容 56,529
关键字:

继承中的重写和覆盖