Java继承性（包含方法重写和super关键字）

ice-Hamster

已于 2023-03-06 22:36:32 修改

阅读量1k

点赞数

分类专栏： Java学习文章标签： java eclipse 后端学习方法经验分享

于 2022-11-17 21:31:58 首次发布

本文链接：https://blog.csdn.net/m0_64681789/article/details/127910913

版权

Java学习专栏收录该内容

11 篇文章 0 订阅

订阅专栏

一、继承性含义

继承是面向对象最显著的一个特性。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。类和类之间的继承关系可以用UML符号表示，其中父类又叫超类或基类，子类又叫派生类。父类是子类的一般化，子类是父类的特化（具体化)。

1.1、继承性的理解

通俗来讲继承性可以比喻成，先定义一个类叫车，车有以下属性：车的大小，颜色，品牌，轮子，而又由车这个类派生出轿车和卡车两个类，为轿车添加一个小后备箱，而为卡车添加一个大货箱。

二、继承性的好处

①减少了代码的冗余，提高了代码的复用性，提高了代码的运行。

②继承性的使用利于后期程序的其他功能的扩展。

③为Java的多态性提供了前提。

三、继承性的格式

3.1、书写格式

class A extends B{ }

其中：A指：子类、派生类 B指：父类、超类、基类

3.2、继承性的体现

一旦子类 A 继承父类 B 以后，子类 A 就获取了父类 B 中声明的所有属性和方法。
其中还有特别的，父类中声明为 private 的属性或方法，子类继承父类以后，仍然认为获取了父类中私有的结构。只是因为封装性的影响，使得子类不能直接调用父类的结构而已。

3.3、继承的说明

        子类继承父类之后，还可以声明自己特有的属性或方法：实现功能拓展。子类和父类的关系，不同于子集和集合的关系 Java 只支持单继承和多层继承，不允许多重继承。
①一个子类只能有一个父类
②一个父类可以派生出多个子类

        例如：class A extends B{ }   //true

                   class A extends B,C{ } //false

四、Java对于继承性的规定

①一个类可以被多个子类继承。

②Java中类是单继承的：一个类只有一个子类。

③子父类是相对的概念。

④子类直接继承父类称为：直接父类。

子类间接继承父类称为：间接父类。

⑤子类继承父类后，就获取了直接父类以及所有间接父类中声明的属性和方法。

4.1、注意事项

①如果我们没有显示的声明一个类的父类的话，则这个类继承于Java.lang.object类。

②所有的Java类（除Java.lang.object类之外）都直接间接的继承于Java.lang.object类。

③这也意味着，所有的Java类都有Java.lang.object声明的功能。

五、继承性的代码演示

首先，先在一个包下创建两个类，（Animal和Animaltest）如图所示：

Animal类

package cn.inheritance.contact;

class Animal {
	
	int age = 0;
	private String name;
	
	public void setName(String name) {
		this.name = name;
	}
	
	public String getName() {
		return name;
	}
	
	public void eat() {  
		System.out.println("动物吃东西");
	}
}

class Dot extends Animal{  //定义一个Dot类继承于Animal类
	
}

Animaltest类

package cn.inheritance.contact;

public class Animaltast {
	
	public static void main(String[] args) {
		Dot dot = new Dot();  //生成一个Dot的对象dot
		
		System.out.println("年龄为：" + dot.age);  //继承了Animal的age（输出结果为："年龄为：0"）
		/* 
		 *  我们可以看到在Dot类中我们没有声明age，但是我们却可以调用age，这就是因为Dot类继承了Animal类，
		 *  所以子类Dot就获得了父类Animal中所有的属性和方法。(这就是继承性)
		 */
		dot.age = 10;  //在给age附上新的值
		System.out.println("年龄为：" + dot.age); //输出结果为："年龄为：10"
		
		//dot.name = "小白";   //无法调用
		/*
		 *这是因为父类Animal中name已经被声明为private（私有性）了，
		 *但要注意的是子类继承父类以后，仍然认为获取了父类中私有的结构。
		 *只是因为封装性的影响，使得子类不能直接调用父类的结构而已。
		 *
		 */
		
		//所以在父类中要写出相对应的（public）的get、set方法，来对name属性进行赋值输出等操作。
		System.out.println("名字为：" + dot.getName());   //输出结果为:"名字为:null"  (还没进行赋值操作)
		dot.setName("小白");
		System.out.println("名字为：" + dot.getName());   //输出结果为:"名字为:小白"
	}
}

六、方法重写

6.1、重写的含义

子类继承父类以后，对父类中同名同参数的方法，进行的覆盖操作叫做重写。

注意：重写后，当子类创建对象以后，通过子类调用和其父类中同名同参数的方法时，实际上执行的是子类重写其父类后的方法。

6.2、重写的规定

①方法的声明：权限修饰符、返回值类型、方法名（形参列表）、throws异常的类型{

对应的方法......

}

②子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同。

③子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符；特殊情况：子类不能重写父类中声明为 private 权限的方法。

④父类被重写的方法的返回值类型是 void，则子类重写的方法的返回值类型只能是 void。

⑤父类被重写的方法的返回值类型是 A 类型，则字方法重写的方法的返回值类型只能是 A 类或 A 类的子类。

⑥父类被重写的方法的返回值类型是基本数据类型（比如 double形），则子类重写的方法的返回值类型必须是基本数据类型（也必须是 double形）。

⑦子类重写的方法跑出的异常类型不大于父类被重写的方法抛出的异常类型。

⑧子类和父类中的同名同参数的方法要么都声明为非 static 的（考虑重写），要么都声明为 static 的（不是重写）。

6.3、重写的代码演示

在上文继承性的代码的例子上，我们已知子类Dot会继承父类的属性和方法，所以我们在测试类中直接用子类调用父类的eat（）方法。

package cn.inheritance.contact;

public class Animaltast {
	
	public static void main(String[] args) {
		Dot dot = new Dot();
		
		dot.eat();  //输出结果是父类的eat（）方法的："动物吃东西"
	}
}

接下来我们将父类中的eat（）进行重写：

class Dot extends Animal{  //定义一个Dot类继承于Animal类
	public void eat() {
		System.out.println("小狗吃骨头");
	}
}

在测试类Animaltest中进行测试

package cn.inheritance.contact;

public class Animaltast {
	
	public static void main(String[] args) {
		Dot dot = new Dot();
		
		dot.eat();  //输出结果是子类重写父类后的eat（）方法的："小狗吃骨头"
	}
}

以上就是基本的重写操作

七、super关键字

7.1、super关键字的介绍

super可以理解为：父类的。super可以用来调用：属性、方法、构造器。

7.2、super关键字的使用

①在子类的方法或构造器中，我们可以通过super.属性或super.方法的方式，显式调用父类中声明的属性或方法。但是一般情况下我们会省略这个super。

②在子类和父类中都定义了同名的属性时，要想在子类中调用父类中声明的属性时，就要使用super.属性的方式，表面调用的是父类中声明的属性。

③在子类中重写了父类中的方法后，要想在子类的方法中调用父类中被重写的方法时，就要使用super.方法的方式，表面调用的是父类中被重写的方法。

7.3、super调用构造器

①可以在子类的构造器中使用super（形参列表）的方式，调用父类中声明的指定的构造器。

②super（形参列表）的使用要在子类构造器的首行。

③在类的构造器中，对于this（形参列表）或super（形参列表）只能出现一个，不能同时出现。

④在构造器的首行，既没有this(形参列表)或super（形参列表），则系统会默认调用父类中的空参构造器super（）。

⑤在类的多个构造器中，至少有一个类的构造器使用了super（形参列表），调用父类中的构造器。

7.4、super的代码演示

对于下面的代码我们知道，子类Dot重写父类Animal后输出的是子类重写父类得到的eat（）方法。这时如果我们想代用父类中的eat（）方法，就要到我们的super出场了。

将Dot类中进行一点改造

class Dot extends Animal{  //定义一个Dot类继承于Animal类
	public void eat() {
		System.out.println("小狗吃骨头");
	}
	
	public void eat1() {    //利用super写一个新的方法，来调用父类中的eat（）方法
		super.eat();
	}
}

开始测试

package cn.inheritance.contact;

public class Animaltast {
	
	public static void main(String[] args) {
		Dot dot = new Dot();  //生成一个Dot的对象dot
		
		dot.eat();  //输出结果是子类重写父类后的eat（）方法的："小狗吃骨头"
		dot.eat1();   //输出结果是父类中的eat（）方法："动物吃东西"	
		}
}

最后到这里，文章就结束了，如果在内容上有问题，恳请各位大佬指出。

ice-Hamster

关注

0
点赞
踩
16

收藏

觉得还不错? 一键收藏
0
评论
Java继承性（包含方法重写和super关键字）

继承是面向对象最显著的一个特性。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。减少了代码的冗余，提高了代码的复用性，提高了代码的运行。继承性的使用利于后期程序的其他功能的扩展。为Java的多态性提供了前提。子类继承父类以后，对父类中同名同参数的方法，进行的覆盖操作叫做重写。super可以理解为：父类的。super可以用来调用：属性、方法、构造器。在子类中重写了父类中的方法后，要想在子类的方法中调用父类中被重写的方法时，就要使用super.方法的方式
复制链接

扫一扫