继承
概述
如果多个类中存在相同的属性和行为时，将这些内容抽取到单独的一个类中，那么多个类就无需再定义这些属性和行为，只要去继承这个单独的类即可。
其中这些多个类称为子类或派生类，单独的那一个类称为父类，超类，基类
继承描述的时事物之间的所属关系，这种关系是一种"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(…)两种构造方法调用时，不能同时调用
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
