一继承的概述
用一张图描述继承关系
二.继承的格式
在继承的关系中,“子类就是一个父类”。也就是说,子类可以被当做父类看待。
例如父类是员工,子类是讲师,那么“讲师就是一个员工”。关系:is-a。
定义父类的格式:(一个普通的类定义)
public class 父类名称 {
// ...
}
定义子类的格式:
public class 子类名称 extends 父类名称 {
// ...
}
再demo01包下新建一个Employee类
代码示例
package cn.itcast.day09.demo1;
/**
* @description
* @author: Admin
* @create: 2023/12/12 10:59
*/
//定义一个父类,员工
public class Employee {
public void method(){
System.out.println("方法执行!");
}
}
再demo01包下新建一个Teacher类
代码示例
package cn.itcast.day09.demo1;
/**
* @description
* @author: Admin
* @create: 2023/12/12 11:01
*/
//定义了一个员工的子类,讲师
public class Teacher extends Employee {
}
再demo01包下新建一个Assistant类
代码示例
package cn.itcast.day09.demo1;
/**
* @description
* @author: Admin
* @create: 2023/12/12 11:06
*/
//定义另一个子类,助教
public class Assistant extends Employee {
}
再demo01包下新建一个主类Demo01Extends
代码示例
package cn.itcast.day09.demo1;
/**
* @description
* @author: Admin
* @create: 2023/12/12 11:02
*/
public class Demo01Extends {
public static void main(String[] args){
//创建一个子类讲师的对象
Teacher teacher=new Teacher();
// Teacher类当中虽然什么都没写,但是会继承来自父类的method方法。
teacher.method();
//创建另一个子类助教的对象
Assistant assistant=new Assistant();
assistant.method();
}
}
运行主类:
可达到代码的复用的效果
三.继承中成员变量的访问特点
(1)父类成员变量和子类成员变量不重名
父类成员变量,子类可以调用;
子类成员变量,父类不能调用;
再demo02包中创建Fu类
代码示例:
package cn.itcast.day09.demo02;
/**
* @description
* @author: Admin
* @create: 2023/12/12 13:21
*/
public class Fu {
int numFu = 10;
}
再demo02包中创建Zi类
代码示例:
package cn.itcast.day09.demo02;
/**
* @description
* @author: Admin
* @create: 2023/12/12 13:22
*/
public class Zi extends Fu{
int numZi=20;
}
再demo02包中创建主类Demo01ExtendsField
代码示例:
package cn.itcast.day09.demo02;
/**
* @description
* @author: Admin
* @create: 2023/12/12 13:24
*/
public class Demo01ExtendsField {
public static void main(String[] args){
Fu fu = new Fu(); // 创建父类对象
System.out.println(fu.numFu); // 只能使用父类的东西,没有任何子类内容
System.out.println("===========");
Zi zi = new Zi();//创建子类对象
System.out.println(zi.numFu); // 10
System.out.println(zi.numZi); // 20
System.out.println("===========");
}
}
运行主类结果:
(2)父类成员变量和子类成员变量重名
在父子类的继承关系当中,如果成员变量重名,则创建子类对象时,访问有两种方式:
①直接通过子类对象访问成员变量:
等号左边是谁,就优先用谁,没有则向上找。
②间接通过成员方法访问成员变量:
该方法属于谁,就优先用谁,没有则向上找。
①直接通过子类对象访问成员变量
举例:修改Fu类和Zi类
Fu类
Zi类
主类
②间接通过成员方法访问成员变量
修改Fu类和Zi类
Fu类
Zi类
主类
四.区分子类方法中重名的三种变量
局部变量,本类的成员变量,父类的成员变量重名;
局部变量: 直接写成员变量名
本类的成员变量: this.成员变量名
父类的成员变量: super.成员变量名
再demo03包中创建Fu类
代码示例:
package cn.itcast.day09.demo03;
/**
* @description
* @author: Admin
* @create: 2023/12/12 14:25
*/
public class Fu {
int num = 10;
}
再demo03包中创建Zi类
代码示例:
package cn.itcast.day09.demo03;
/**
* @description
* @author: Admin
* @create: 2023/12/12 14:26
*/
public class Zi extends Fu{
int num = 20;
public void method() {
//创建子类方法的局部变量num
//一共有3个num
int num = 30;
System.out.println(num); // 30,局部变量
System.out.println(this.num); // 20,本类的成员变量
System.out.println(super.num); // 10,父类的成员变量
}
}
再demo03包中创建主类Demo01ExtendsField
代码示例:
package cn.itcast.day09.demo03;
/**
* @description
* @author: Admin
* @create: 2023/12/12 14:26
*/
public class Demo01ExtendsField {
public static void main(String[] args){
Zi zi=new Zi();
zi.method();
}
}
运行主类
五.继承中成员方法的访问特点
在父子类的继承关系当中,创建子类对象,访问成员方法的规则:
创建的对象是谁,就优先用谁,如果没有则向上找。
注意事项:
无论是成员方法还是成员变量,如果没有,都是向上找父类,绝对不会向下找子类的
(1)父类与子类成员方法不重名
再demo04包中创建Fu类
代码示例:
package cn.itcast.day09.demo04;
/**
* @description
* @author: Admin
* @create: 2023/12/12 15:03
*/
public class Fu {
public void methodFu() {
System.out.println("父类方法执行!");
}
}
再demo04包中创建Zi类
代码示例:
package cn.itcast.day09.demo04;
/**
* @description
* @author: Admin
* @create: 2023/12/12 15:03
*/
public class Zi extends Fu{
public void methodZi() {
System.out.println("子类方法执行!");
}
}
再demo04包中创建主类Demo01ExtendsMethod
代码示例
package cn.itcast.day09.demo04;
/**
* @description
* @author: Admin
* @create: 2023/12/12 15:05
*/
public class Demo01ExtendsMethod {
public static void main(String[] args) {
Zi zi = new Zi();
zi.methodFu();
zi.methodZi();
}
}
运行结果:
(2)父类与子类成员方法重名
在父子类的继承关系当中,创建子类对象,访问成员方法的规则:
创建的对象是谁,就优先用谁,如果没有则向上找。
修改Fu类和Zi类
运行结果
六.继承中方法的覆盖重写--概念和特点
重写(Override)也可称覆盖重写
概念:在继承关系当中,方法的名称一样,参数列表也一样。
重写(Override):方法的名称一样,参数列表也一样。
重载(Overload):方法的名称一样,参数列表不一样。
方法的覆盖重写特点:
创建的是子类对象,则优先用子类方法。
方法覆盖重写的注意事项:
1. 必须保证父子类之间方法的名称相同,参数列表也相同。
@Override:写在方法前面,用来检测是不是有效的正确覆盖重写。
这个注解就算不写,只要满足要求,也是正确的方法覆盖重写。
2. 子类方法的返回值必须小于等于父类方法的返回值范围。
小扩展提示:java.lang.Object类是所有类的公共最高父类(祖宗类),java.lang.String就是Object的子类。
例如:Fu类
Zi类
所以:如果Fu类用String,Zi类用Object,程序就会报错
3. 子类方法的权限必须大于等于父类方法的权限修饰符。
小扩展提示:public > protected > (default) > private
备注:(default)不是关键字default,而是什么都不写,留空。
什么都不写的意思是,例如int num=1;
七.继承中方法的覆盖重写--应用场景
举例
再demo06包中创建Phone类
代码示例:
package cn.itcast.day09.demo06;
/**
* @description
* @author: Admin
* @create: 2023/12/12 16:10
*/
//本来的老款手机
public class Phone {
public void call() {
System.out.println("打电话");
}
public void send() {
System.out.println("发短信");
}
public void show() {
System.out.println("显示号码");
}
}
再demo06包中创建NewPhone类
代码示例:
package cn.itcast.day09.demo06;
/**
* @description
* @author: Admin
* @create: 2023/12/12 16:12
*/
public class NewPhone extends Phone {
@Override
public void show() {
super.show(); // 把父类的show方法拿过来重复利用
// 自己子类再来添加更多内容
System.out.println("显示姓名");
System.out.println("显示头像");
}
}
再demo06包中创建主类Demo01Phone
代码示例:
package cn.itcast.day09.demo06;
/**
* @description
* @author: Admin
* @create: 2023/12/12 16:14
*/
public class Demo01Phone {
public static void main(String[] args) {
Phone phone = new Phone();
phone.call();
phone.send();
phone.show();
System.out.println("==========");
NewPhone newPhone = new NewPhone();
newPhone.call();
newPhone.send();
newPhone.show();
}
}
运行结果:
八.继承中构造方法的访问特点
继承关系中,父子类构造方法的访问特点:
1. 子类构造方法当中有一个默认隐含的“super()”调用,所以一定是先调用的父类构造,后执行的子类构造。
2. 子类构造可以通过super关键字来调用父类重载构造。
3. super的父类构造调用,必须是子类构造方法的第一个语句。不能一个子类构造调用多次super构造。
(1)构造方法特点第一点举例
子类构造方法当中有一个默认隐含的“super()”调用,所以一定是先调用的父类构造,后执行的子类构造
再demo07包中创建Fu类
代码示例:
package cn.itcast.day09.demo07;
/**
* @description
* @author: Admin
* @create: 2023/12/12 16:26
*/
public class Fu {
public Fu() {
System.out.println("父类无参构造方法!");
}
}
再demo07包中创建Zi类
代码示例:
package cn.itcast.day09.demo07;
/**
* @description
* @author: Admin
* @create: 2023/12/12 16:26
*/
public class Zi extends Fu{
public Zi() {
System.out.println("子类无参构造方法!");
}
}
再demo07包中创建主类Demo01Constructor
代码示例:
package cn.itcast.day09.demo07;
/**
* @description
* @author: Admin
* @create: 2023/12/12 16:26
*/
public class Demo01Constructor {
public static void main(String[] args) {
Zi zi = new Zi();
}
}
运行结果
先调用的父类构造,后执行的子类构造。(先有父亲才有儿子)
super()方法(与第一点相符合)
(2)构造方法特点第二点举例
子类构造可以通过super关键字来调用父类重载构
修改代码Fu类和Zi类
Fu类
package cn.itcast.day09.demo07;
/**
* @description
* @author: Admin
* @create: 2023/12/12 16:26
*/
public class Fu {
public Fu() {
System.out.println("父类无参构造方法!");
}
public Fu(int num) {
System.out.println("父类有参构造方法!");
}
}
Zi类
package cn.itcast.day09.demo07;
/**
* @description
* @author: Admin
* @create: 2023/12/12 16:26
*/
public class Zi extends Fu{
public Zi() {
//默认隐含的“super()”调用,不写的话也会调用
//super(); // 在调用父类无参构造方法
super(20); // 在调用父类重载的构造方法
System.out.println("子类无参构造方法!");
}
}
主类不变,运行主类
(3)构造方法特点第三点举例
super的父类构造调用,必须是子类构造方法的第一个语句。不能一个子类构造调用多次super构造。
总结:
子类必须调用父类构造方法,不写则赠送super();写了则用写的指定的super调用,super只能有一个,还必须是第一个。
八.super关键字的三种用法
super关键字的用法有三种:
1. 在子类的成员方法中,访问父类的成员变量。
2. 在子类的成员方法中,访问父类的成员方法。
3. 在子类的构造方法中,访问父类的构造方法。
第一种举例
在子类的成员方法中,访问父类的成员变量
Fu类
package cn.itcast.day09.demo08;
/**
* @description
* @author: Admin
* @create: 2023/12/12 17:46
*/
public class Fu {
int num = 10;
}
Zi类
package cn.itcast.day09.demo08;
/**
* @description
* @author: Admin
* @create: 2023/12/12 17:46
*/
public class Zi extends Fu{
int num = 20;
public void methodZi() {
System.out.println(super.num); // 父类中的num值
}
}
第二种举例
在子类的成员方法中,访问父类的成员方法
Fu类
package cn.itcast.day09.demo08;
/**
* @description
* @author: Admin
* @create: 2023/12/12 17:46
*/
public class Fu {
public void method() {
System.out.println("父类方法");
}
}
Zi类
package cn.itcast.day09.demo08;
/**
* @description
* @author: Admin
* @create: 2023/12/12 17:46
*/
public class Zi extends Fu{
public void method() {
super.method(); // 访问父类中的method
System.out.println("子类方法");
}
}
第三种举例
在子类的构造方法中,访问父类的构造方法
Fu类
package cn.itcast.day09.demo08;
/**
* @description
* @author: Admin
* @create: 2023/12/12 17:46
*/
public class Fu {
}
Zi类
package cn.itcast.day09.demo08;
/**
* @description
* @author: Admin
* @create: 2023/12/12 17:46
*/
public class Zi extends Fu{
public Zi() {
super();
}
}
九.this关键字的三种用法
super关键字用来访问父类内容,而this关键字用来访问本类内容。用法也有三种:
1. 在本类的成员方法中,访问本类的成员变量。
2. 在本类的成员方法中,访问本类的另一个成员方法。
3. 在本类的构造方法中,访问本类的另一个构造方法。
在第三种用法当中要注意:
A. this(...)调用也必须是构造方法的第一个语句,唯一一个。
B. super和this两种构造调用,不能同时使用。
第一种用法的举例
在本类的成员方法中,访问本类的成员变量
Fu类
package cn.itcast.day09.demo09;
/**
* @description
* @author: Admin
* @create: 2023/12/12 18:09
*/
public class Fu {
int num=30;
}
Zi类
package cn.itcast.day09.demo09;
/**
* @description
* @author: Admin
* @create: 2023/12/12 18:09
*/
public class Zi extends Fu{
int num=20;
public void showNum() {
int num = 10;
System.out.println(num); // 局部变量10
System.out.println(this.num); // 本类中的成员变量20
System.out.println(super.num); // 父类中的成员变量30
}
}
第二种用法的举例
在本类的成员方法中,访问本类的另一个成员方法
修改Zi类
第三种用法的举例
在本类的构造方法中,访问本类的另一个构造方法
修改Zi类
十.继承的特点
相关练习:发红包案例
如有需要答案,可在评论区留言