JavaSE08_面向对象之继承
JavaSE-08 【继承】
第一章 继承
1.1 继承介绍
- 继承的概念：
- 让类与类之间产生关系（子父类关系），子类可以直接使用父类中非私有的成员
- 继承是多态的前提，如果没有继承，就没有多态
- 继承主要解决的问题就是共性抽取
- 继承关系中的特点
- 1、子类可以拥有父类的内容
- 2、子类还可以拥有自己独有的内容
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oshUoeln-1686188016077)(photo/JavaSE08_面向对象之继承.assest/1664783489643.png)]
1.2 继承的格式
-
继承的格式
- 定义父类的格式
public class 父类名称(){ //... }- 定义子类的格式
public class 子类名 extends 父类名{ //... } -
定义父类
/**
* 定义一个父类
*/
public class Employer {
//定义父类的成员方法
public void work(){
System.out.println("父类的方法被调用了");
}
}
- 定义子类
/**
* 定义员工的子类 Teacher,继承父类Employer
*/
public class Teacher extends Employer{
}
/**
* 定义员工的子类 Coder，继承父类Employer
*/
public class Coder extends Employer{
}
- 测试
/**
* 继承的格式
* 定义父类的格式
* public class 父类名称(){
* // ...
* }
* 定义子类的格式：
* public class 子类名 extends 父类名{
* //...
* }
*/
public class TestExtends {
public static void main(String[] args) {
//创建一个子类Teacher的对象
Teacher teacher = new Teacher();
//Teacher类继承了父类Emoloyer中的方法
teacher.work();
//创建一个子类Coder的对象
Coder coder = new Coder();
//Coder类继承了父类Emoloyer中的方法
coder.work();
}
}
- 结果
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7w6laWtJ-1686188016078)(photo/JavaSE08_面向对象之继承.assest/1664785379097.png)]
1.3 继承中成员变量的访问特点
- 继承中成员变量的访问特点
- 在子父类继承关系中，如果成员变量重名，那么子类对象访问成员变量的方式有两种
- 1、直接通过子类对象访问成员变量
- 规则：等号左边是谁，就优先用谁，没有则向上找
- 2、间接通过成员方法访问成员变量
- 规则：该方法属于谁，就优先用谁，没有则向上找
- 定义父类和子类
/**
* 父类
*/
public class Father {
int numFu = 10;
int num = 100;
public void getFileds1(){
System.out.println(num);
}
}
/**
* 子类
*/
public class Son extends Father{
int numZi = 20;
int num = 200;
public void getFileds2(){
System.out.println(num);
}
}
- 测试
/**
* 继承中成员变量的访问特点
* 在子父类继承关系中，如果成员变量重名，那么子类对象访问成员变量的方式有两种
* 1、直接通过子类对象访问成员变量
* 规则：等号左边是谁，就优先用谁，没有则向上找
* 2、间接通过成员方法访问成员变量
* 规则：该方法属于谁，就优先用谁，没有则向上找
*/
public class TestExtendsFiled {
public static void main(String[] args) {
//创建父类对象
Father f = new Father();
//获取属性值
System.out.println(f.numFu);// 10 只能使用父类的属性，没有任何子类的内容
System.out.println("------------------");
//创建子类对象
Son s = new Son();
//获取属性，子父类的成员变量不重名
System.out.println(s.numFu);//10 获取父类的属性
System.out.println(s.numZi);//20 获取子类的属性
System.out.println("------------------");
//1、直接通过子类对象访问成员变量
//等号左边是谁，就优先用谁，没有则向上找
System.out.println(s.num);//200
System.out.println("------------------");
//2、间接通过成员方法访问成员变量
s.getFileds2();//200 该方法属于谁，就优先用谁，没有则向上找
f.getFileds1();//100
}
}
1.4 区分继承中重名的三种变量
- 区分继承中重名的三种变量
- 子类方法的局部变量： 直接写变量名访问
- 子类的成员变量： this.变量名
- 父类的成员变量： super.变量名
- 父子类
public class Father {
int num = 100;
}
public class Son extends Father{
int num = 200;
public void getFields(){
int num = 300;
System.out.println("局部变量"+num);// 300 局部变量
System.out.println("子类成员变量"+this.num);// 200 本类的成员变量
System.out.println("父类成员变量"+super.num);//100 父类的成员变量
}
}
- 测试
/**
* 区分继承中重名的三种变量
* 子类方法的局部变量： 直接写变量名访问
* 子类的成员变量： this.变量名
* 父类的成员变量： super.变量名
*/
public class TestFileds {
public static void main(String[] args) {
//创建子类对象
Son son = new Son();
//调用方法
son.getFields();
}
}
- 结果
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-x68nlUyZ-1686188016080)(photo/JavaSE08_面向对象之继承.assest/1664787336499.png)]
1.5 继承中成员方法的访问特点
- 继承中成员方法的访问特点
- 规则：创建的对象是谁，就优先用谁，如果没有就向上找
- 注意事项：无论是成员方法还是成员变量，本类如果没有找到，都是向上找，不会向下找子类的
- 父子类
public class Father {
public void methodF1(){
System.out.println("methodF1---被调用");
}
public void method(){
System.out.println("父类的重名方法被调用");
}
}
public class Son extends Father {
public void methodZ1(){
System.out.println("methodZ1---被调用");
}
public void method(){
System.out.println("子类的重名方法被调用");
}
}
- 测试
/**
* 继承中成员方法的访问特点
* 规则：创建的对象是谁，就优先用谁，如果没有就向上找
* 注意事项：无论是成员方法还是成员变量，本类如果没有找到，都是向上找，不会向下找子类的
*/
public class TestFileds {
public static void main(String[] args) {
Father father = new Father();
father.methodF1();
father.method();
System.out.println("----------------------");
Son son = new Son();
son.methodZ1();
son.methodF1();
//创建的对象是谁，就优先用谁，如果没有就向上找
son.method();//我是子类的方法
}
}
- 结果
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ayNTViZx-1686188016081)(photo/JavaSE08_面向对象之继承.assest/1664788367968.png)]
1.6 继承中方法的重写
- 方法重写：Override
- 在继承关系中，方法名相同，参数列表相同，称之为方法的重写
- 重写注解：@Override ，用于标识重写 - 注意事项：
- 必须保证父子类的方法名相同，参数列表也想同
- 子类方法的返回值类型必须小于等于父类防范的返回值范围
- 子类方法的权限修饰符必须大于父类方法的权限修饰符
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6vbnTeds-1686188016092)(photo/JavaSE08_面向对象之继承.assest/1664795791847.png)]
public class Father {
public void work(int a,int b){
System.out.println("父类的方法");
}
public Object watch(){
System.out.println("父亲在看电视");
return "新闻联播";
}
protected int add(){
return 3;
}
}
/**
* 子类从写父类方法
*/
public class Son extends Father{
//方法名相同，参数列表相同
@Override
public void work(int a,int b){
System.out.println("子类重写父类的方法");
}
//子类的返回值类型要小于等于父类
public String watch(){
System.out.println("父亲在看电视");
return "新闻联播";
}
//子类的访问修饰符要大于等于父类
//权限修饰符大到小 public > protected > default > private
public int add(){
return 3;
}
}
1.7 继承中方法重写的应用场景
对于已经使用的类，尽量不要进行修改，推荐定义一个新的类，进而重复利用其中的共性内容，同时添加新的内容
/**
* 父类：按键手机
*/
public class KeyPhone {
public void call(){
System.out.println("打电话");
}
public void sendMessage(){
System.out.println("发信息");
}
public void show(){
System.out.println("显示号码");
}
}
/**
* 子类：智能手机
*/
public class SmartPhone extends KeyPhone{
//子类重写父类的show方法
@Override
public void show() {
super.show();//调用父类的show方法重复利用
//子类扩展父类方法的功能
System.out.println("显示属地");
System.out.println("显示头像");
System.out.println("显示专用铃声");
}
}
/**
* 方法重写应用场景
*/
public class TestOverride {
public static void main(String[] args) {
//创建父类对象，调用方法
KeyPhone keyPhone = new KeyPhone();
keyPhone.call();
keyPhone.sendMessage();
keyPhone.show();
System.out.println("------------");
//创建子类对象，调用方法
SmartPhone smartPhone = new SmartPhone();
smartPhone.call();
smartPhone.sendMessage();
smartPhone.show();
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IktLGxZl-1686188016098)(photo/JavaSE08_面向对象之继承.assest/1664797300985.png)]
1.8 继承中构造方法的访问特点
- 继承中构造方法的访问特点
- 1、子类构造方法中有一个默认隐含的super()方法，所以一定是先调用父类的构造，后执行子类的构造
- 2、子类构造可以使用super关键字调用父类的构造
- 3、super语句必须是子类构造方法中的第一行，且不能多次调用
public class Father {
private String name;
//无参构造方法
public Father() {
System.out.println("父类的无参构造方法");
}
public Father(String name) {
this.name = name;
System.out.println("父类的有参构造方法");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
public class Son extends Father{
private int age;
public Son() {
super();//调用父类的无参构造方法
System.out.println("子类的无参构造方法");
}
public Son(int age) {
super("Tom");
this.age = age;
System.out.println("子类的有参构造方法");
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
/**
* 继承中构造方法的访问特点
* 1、子类构造方法中有一个默认隐含的super()方法，所以一定是先调用父类的构造，后执行子类的构造
* 2、子类构造可以使用super关键字调用父类的构造
* 3、super语句必须是子类构造方法中的第一行，且不能多次调用
*/
public class TestConstructor {
public static void main(String[] args) {
//使用子类的无参构造方法创建对象
Son son1 = new Son();
System.out.println(son1.getName());
System.out.println("--------------");
//使用子类的有参构造创建对象
Son son2 = new Son(22);
System.out.println(son2.getName());
System.out.println(son2);
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WU5zPYD5-1686188016104)(photo/JavaSE08_面向对象之继承.assest/1664801359682.png)]
第二章：this和super
2.1 super关键字的三种用法
- super关键字的用法
- super关键字用于访问父类的内容
- 1、在子类的成员方法中，访问父类的成员变量
- 2、在子类的成员方法中，访问父类的成员方法
- 3、在子类的构造方法中，访问父类的构造方法
public class Father {
int num = 100;
public void method(){
System.out.println("父类中的成员方法");
}
}
/**
* super关键字的用法
* 1、在子类的成员方法中，访问父类的成员变量
* 2、在子类的成员方法中，访问父类的成员方法
* 3、在子类的构造方法中，访问父类的构造方法
*/
public class Son extends Father{
int num = 200;
public Son() {
super();//默认存在，子类构造器默认访问父类的构造方法
}
public void methodZi(){
System.out.println(super.num);//访问父类的成员变量
}
public void method(){
super.method();//访问父类的成员方法
System.out.println("子类中的成员方法");
}
}
2.2 this关键字的三种用法
- this关键字的三种用法
- this关键字用于访问本类中的内容
- 1、在本类的成员方法中，访问本类的成员变量
- 2、在本类的成员方法中，访问本类的另外一个成员方法
- 3、在本类的构造方法中，访问本类的另一个构造方法
- 注意事项：super和this两种构造调用，不能同时使用，因为他们都必须在第一行
public class Father {
int num = 100;
}
/**
* this关键字的三种用法
* this关键字用于访问本类中的内容
* 1、在本类的成员方法中，访问本类的成员变量
* 2、在本类的成员方法中，访问本类的另外一个成员方法
* 3、在本类的构造方法中，访问本类的另一个构造方法
* 注意事项：super和this两种构造调用，不能同时使用，因为他们都必须在第一行
*/
public class Son extends Father{
int num = 200;
public void methodZi(int num){
System.out.println(num);//局部变量
System.out.println(this.num);//本类中的成员变量
System.out.println(super.num);//父类的成员变量
}
public void method1(){
System.out.println("111");
}
//在本类中的成员方法中，访问本类中的成员方法
public void method2(){
this.method1();
System.out.println("222");
}
//无参构造
public Son() {
this(300);//本类的无参构造调用本类的有参构造
}
//有参构造
public Son(int num) {
this.num = num;
}
}
2.3 Java继承的三个特点
- 1、Java语言是单继承的。一个子类只能有一个父类
- 2、Java语言可以多级继承。如A的父类是B，B的父类是C，同时C也是A的父类
- 3、一个子类的父类是唯一的，一个父类可以有多个子类
ntln(this.num);//本类中的成员变量
System.out.println(super.num);//父类的成员变量
}
public void method1(){
System.out.println("111");
}
//在本类中的成员方法中，访问本类中的成员方法
public void method2(){
this.method1();
System.out.println("222");
}
//无参构造
public Son() {
this(300);//本类的无参构造调用本类的有参构造
}
//有参构造
public Son(int num) {
this.num = num;
}
}
## 2.3 Java继承的三个特点
- 1、Java语言是单继承的。一个子类只能有一个父类
- 2、Java语言可以多级继承。如A的父类是B，B的父类是C，同时C也是A的父类
- 3、一个子类的父类是唯一的，一个父类可以有多个子类