继承
概述
如果多个类中存在相同的属性和行为时,将这些内容抽取到单独的一个类中,那么多个类就无需再定义这些属性和行为,只要去继承这个单独的类即可。
其中这些多个类称为子类或派生类,单独的那一个类称为父类,超类,基类
继承描述的时事物之间的所属关系,这种关系是一种"is - a"的关系,在继承关系中,子类就是一个“父类”。也就是说子类可以被当作父类看待。
例如:父类是员工,子类是讲师,那么”讲师就是一个员工“。关系:“is - a”
一般情况下父类更通用,子类更具体。我们可以通过继承,使多种事物形成一种关系体系
定义
就是子类继承父类的属性和行为,使得子类对象具有和父类相同的属性相同的行为,子类可以直接访问父类中非私有的属性和行为
好处:
- 可以提高代码的复用性。
- 类与类之间可以产生一种关系,是多态的前提。
继承关系当中的特点:
-
子类可以拥有父类的内容
-
子类也可以在拥有自己专有的内容
继承的格式:
通过 extends 关键字可以声明一个子类继承另一个父类
public class FuClass{
//....
}
public class ZiClass extends FuClass{
//....
}
代码演示:
//定义一个员工类 Employ,父类
public class Employee{
String name;//name属性
int id;//工号属性
//定义员工的工作方法
public void work() {
System.out.println(name + "努力的工作");
}
}
//定义教师类 Teacher 继承 员工类
public class Teacher extends Employee{
//定义教师专有的方法
public void teach(){
System.out.println(name + "在教课");
}
}
//定义一个测试类
public class TestExtendsDemo01{
public static void main(String[] args) {
//创建一个教师类
Teacher t = new Teacher();
//为该员工的name属性赋值
t.name = "小张";
//调用该员工中的讲课的方法
t.teach();
//调用Teacher类继承过来的方法
t.work();
}
}
继承后的特点—成员变量
当类之间产生了关系后,其中各类中的成员变量有那些影响?
成员变量不重名
如果子类父类中定义的成员变量不重名,这时的访问没有任何影响。代码演示
public class Fu{
//定义父类中的成员变量
int num = 10;
}
public class Zi extends Fu{
//定义子类中的成员变量
int num2 = 20;
//定义子类成员方法
public void show(){
//访问父类中的成员变量 num
System.out.println("父类中的成语变量" + num);//10 继承来的可以直接访问
//访问子类中的成员变量 num2
System.out.println("子类中的成语变量" + num2);//20
}
}
public class TextExtendsField{
public static void main(String[] args) {
//创建子类对象
Zi zi = new Zi();
//调用子类的方法
zi.show();
}
}
//结果 10
// 20
成员变量重名
如果子类父类出现重名的成员变量,这时的访问是有影响的。代码演示
public class Fu{
//定义父类中的成员变量
int num = 10;
}
public class Zi extends Fu{
//定义子类中的成员变量
int num = 20;
//定义子类成员方法
public void show(){
//访问父类中的成员变量 num
System.out.println("父类中的成语变量" + num);//20
//访问子类中的成员变量 num
System.out.println("子类中的成语变量" + num);//20
}
}
public class TextExtendsField{
public static void main(String[] args) {
//创建子类对象
Zi zi = new Zi();
//调用子类的方法
zi.show();
}
}
//结果
//20
//20
在父子类的继承关系当中,如果成员变量重名,则创建子类对象时,有两种访问方式:
1. 直接通过子类对象访问成员变量:等号左边是谁就优先用谁,如果没有向上找
2. 间接通过成员方法类访问成员变量:该方法属于谁,就优先用谁,没有就向上找
子父类中出现了重名的成员变量时,在子类中想要访问父类总非私有的成员变量时,需要使用super关键字,修饰父类的成员变量,类似于this操作
使用格式
super.父类的成员变量名
子类方法代码需要修改
public class Zi extends Fu{
//定义子类中的成员变量
int num = 20;
//定义子类成员方法
public void show(){
//访问父类中的成员变量 num
System.out.println("父类中的成语变量" + super.num);//20
//访问子类中的成员变量 num
System.out.println("子类中的成语变量" + num);//20
}
}
//结果
// 10
// 20
备注:Fu类的成员变量是非私有的,子类中可以直接访问,若父类中的成员变量私有了,子类不能直接访问。通常编码时,我们遵循的是封装的原则,使用private关键字修饰成员变量,那么如何访问父类中的私有成员变量?可以借助于父类中功能的getXxx和setXxx方法。
继承后的特点—成员方法
成员方法不重名
如果子类父类中出现不重名的成员方法,这时的调用是没有任何影响的,对象调用方法时,会现在子类中查找有没有对应的方法,若子类中存在该方法就执行该方法,若子类当中不存在该方法就会执行父类当中的成员方法。
public class Fu {
int num = 10;
public void show(){
System.out.println("父类中的方法再执行");
System.out.println("Fu类中的成员变量num" + num);
}
}
public class Zi entends Fu {
int num = 20;
public void show02(){
System.out.println("子类中的方法再执行");
System.out.println("Zi类中的成员变量num" + num);
}
}
public class TestExtends {
public static void main(String[] args){
//构建子类对象
Zi zi = new Zi();
zi.show();//调用父类当中的show()方法
zi.show02();//调用子类当中的show02()方法
}
}
成员方法重名—重写(Overrid)
如果父子类中出现了重名的成员方法,这时的访问是一种特殊情况。叫做方法的重写(Overrid)
-
方法重写:子类中出现了与父类一模一样的方法时,(返回值类型,方法名,参数列表),会出现覆盖效果,也成为重写或者复写。简称"声明不变,重新实现"
实例代码
public class Fu { int num = 10; public void show() { System.out.println("Fu show()方法再执行"); System.out.println("Fu 成员变量num" + num); } } public class Zi extends Fu{ int num = 20; public void show() { System.out.println("Zi show()方法再执行"); System.out.println("Zi 成员变量num" + num); } } public class TestExtends { public static void main(String[] args){ //构建子类对象 Zi zi = new Zi(); //调用show()方法 ,执行重写后的show()方法 zi.show(); //Zi show()方法再执行 20 } }
重写的应用
子类可以根据需要,定义特定于自己的行为,及沿袭了父类的功能名称,又根据子类的需要重新实现父类方法,从而进行功能的扩展
对于已经投入使用的类,尽量不要进行修改,推荐新定义一个类,通过继承,来重复利用共性的内容,并且额可以添加新的内容
public class Phone {
//打电话
public void call(){
System.out.println("打电话");
}
public void sendMessage(){
System.out.println("发短信");
}
//来电显示
public void show(){
System.out.println("来电显示电话号码");
}
}
public class Iphone12 extends Phone {
//从写父类当中的来电显示功能,增加自己的显示头像和姓名
public void show(){
//父类当中的功能不变
super.show();
//新增功能
System.out.println("显示姓名");
System.out.println("显示头像");
}
}
public class ExtendsDemo03 {
public static void main(String[] args) {
//创建子类对象
IPhone12 iphone = new IPhone12();
//调用父类当中的打电话
iphone.call;
//调用重写后的来电显示
iphone.show();//显示电话,显示姓名,显示头像
}
}
重写:方法名称一样,参数列表一样,返回值类型一样,,重写的前提是有继承关系
重载:方法名称一样,参数列表不一样,返回值类型无要求,再本类中。
注意事项:
- 子类方法重写父类方法必须要权限要大于等于父类对象
- 子类方法覆盖父类方法,返回值类型,方法名称和参数列表要一模一样。
继承后的特点—构造方法
构造方法的定义和作用:
-
构造方法的名字和类名要保持一致,所以子类是无法继承父类当中的构造方法
-
构造方法的作用一般是用来初始化成员变量,所以子类再初始化过程中,必须先执行父类中的初始化动作,子类的构造方法当中默认有一个super()方法,表示调用的父类的构造方法,父类的成员变量初始化之后,才可以给子类使用。
public class Fu { private int n; public Fu() { System.out.println("Fu()"); } } public class Zi extends Fu{ public Zi() { //super() 调用父类的构造方法 隐式调用 System.out.println("Zi()"); } } public class TestExtendsDemo04 { public static void main(String[] args){ Zi zi = new Zi(); } } //输出结果 //Fu() //Zi()
继承特点
-
Java语言的继承是单继承的,一个类的直接父类只能有唯一一个。
-
java不能多继承,可以多级继承
class A{}
class B{}
class C extends A,B{} //错误写法,不可以多继承
class C extends B{} //多级继承
class B extends C{}
-
顶层父类是Object类,所有的类默认都继承Object
-
子类和父类是一种相对概念。
-
一个类的直接父类是唯一的,但一个父类可以同时拥有多个子类
class A{}
class B extends A{}
class C extends A{}
super 和 this
父类空间优先于子类对象的产生
每次创建子类对象的时候,先初始化父类空间,再创建子类对象。目的在于子类对象中包含了其对应的父类空间,便可以包含父类的成员,如果父类成员非私有,则子类可以随意使用父类成员,代码体现在子类的构造方法调用时会先调用父类的构造方法。
super和this的含义
- super代表的是父类的存储空间标识(可以理解为父类的引用)
- this:代表当前对象的引用(谁调用谁就是谁)
super和this的用法
- 访问父类的成员变量
super.成员变量
super.成员方法
-
访问父类的构造方法
super(....) 父类的构造方法
-
在继承关系中,父类的构造方法的访问特点
- 子类的构造方法当中有一个默认的隐式的super()调用,所以一定是先调用父类的构造,后执行子类构造
- 子类构造可以通过super关键字来调用父类的重载构造
- super的父类构造调用,必须是子类的第一行语句,。不能一个子类构造多次调用super构造
总结:子类必须调用父类的构造方法,不写则赠送super();写了则用写了的指定的super调用,super只能由一个,还必须是第一个。
this
-
访问当前类的成员
this.成员变量; this.成员方法;
-
访问当前类的构造方法
this(...) 当前类的构造方法
this()构造方法在调用时不能形成闭合
this(…)调用时也必须是构造方法的第一个语句,唯一一个
super(…)和this(…)两种构造方法调用时,不能同时调用