继承

1.继承的概述

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-c1ocRigI-1608862409653)(F:\Java\Learn\day15\day22.assets\image-20201224091344928.png)]

2.继承的格式

package Demo2201;//定义一个父类，员工
public class Employee {public void method() {System.out.println("方法执行");}
}

package Demo2201;
//定义了一个员工的子类：讲师
public class Teacher extends Employee {}

package Demo2201;public class Assistant extends Employee {}

package Demo2201;
/*
* 在继承的关系中，“子类就是一个父类”，也就是说，子类可以被当作父类看待。
* 例如父类是员工，子类是讲师，那么，讲师就是一个员工。关系：is a。
* 定义父类的格式：（一个普通的类定义）
* public class 父类名称{
*   //...
* }
*
* 定义子类的格式：
* public class 子类名称 extends 父类名称{
* //...
* }
* */
public class Demo01Extends {public static void main(String[] args) {//创建了一个子类对象Teacher teacher = new Teacher();//Teacher类当中虽然什么都没写，但是会继承来自父类的method方法。teacher.method();//方法执行//创建另一个子类对象助教Assistant assistant = new Assistant();assistant.method();//方法执行}
}

3.继承中成员变量的访问特点

package Demo2202;public class Fu {int numFu = 10;int num = 1;public void methodFu() {//使用的是本类当中的，不会向下找子类的System.out.println(num);}
}

package Demo2202;public class Zi extends Fu{int numZi = 20;int num = 2;public void methodZi(){//因为本类当中有num，所以这里用的是本类的numSystem.out.println(num);}
}

package Demo2202;/*
在父子类的继承关系当中，如果成员变量重名，则创建子类对象时，访问有两种方式：* 直接通过子类对象访问成员变量：
*   等号左边是谁，就优先用谁，没有则向上找。
* 间接通过成员方法访问成员对象
*   该方法属于谁，就优先用谁，没有则向上找
* */
public class Demo02ExtendsField {public static void main(String[] args) {Fu fu = new Fu();//创建一个父类对象System.out.println(fu.numFu);//弹出来的只有numFu10System.out.println(fu.num);//1Zi zi = new Zi();//创建一个子类对象System.out.println(zi.numFu);//两个都有10System.out.println(zi.numZi);//20//等号左边是谁，就优先用谁System.out.println(zi.num);//2优先子类//System.out.println(zi.abc);//到处都没有，编译报错//这个方法是子类的，优先用子类的，没有再向上找zi.methodZi();//2//这个方法是在父类中定义的zi.methodFu();//1}
}

4.区分子类方法中重名的三种变量

package Demo2203;public class Fu {int num = 10;
}

package Demo2203;public class Zi extends Fu {int num = 20;public void method(){int num = 30;System.out.println(num);//30 局部变量System.out.println(this.num);//20 本类的成员变量System.out.println(super.num);//10 父类的成员变量}
}

package Demo2203;
/*
*局部变量：          直接写成员变量名
* 本类的成员变量：   this.成员变量名
* 父类的成员变量：   super.成员变量名
* */
public class Demo01ExtendsField {public static void main(String[] args) {Zi zi = new Zi();zi.method();//30,20,10}
}

5.继承中成员方法的访问特点,继承中方法的覆盖重写—概念与特点

package Demo2204;public class Fu {public void methodFu(){System.out.println("父类方法执行");}public void method(){System.out.println("父类重名方法执行");}
}

package Demo2204;public class Zi extends Fu {public void methodZi() {System.out.println("子类方法执行了");}public void method() {System.out.println("子类重名方法执行");}}

package Demo2204;
//子类可以用父类的方法；当子类和父类方法重名一样时，子类优先用自己的。
//父类不可以用子类的方法
/*
* 在父子类的继承关系当中，创建子类对象，访问成员方法的规则：
*   创建的对象是谁，就优先用谁，如果没有则向上找
* 注意事项：
* 无论是成员方法还是成员变量，如果没有都是向上找父类，绝对不会向下找子类的
*
* 重写（Override）
* 概念：在继承关系当中，方法的名称一样，参数列表也一样。
* 重写（Override）：方法的名称一样，参数列表【也一样】。覆盖，覆写。
* 重载（Overload）：方法的名称一样，参数列表【不一样】。
*
* 方法的覆盖重写特点：创建的是子类对象，则优先使用子类方法。
* */
public class Demo01ExtendsMethod {public static void main(String[] args) {Fu fu = new Fu();fu.methodFu();//父类方法执行Zi zi = new Zi();zi.methodZi();//子类方法执行了zi.methodFu();//父类方法执行//创建的是new了子类对象，所以优先用子类方法zi.method();//子类重名方法执行}
}

6.继承中方法的覆盖重写—注意事项

package Demo2205;public class Fu {public Object method(){return null;}
}

package Demo2205;public class Zi extends Fu {@Overridepublic Object method(){//如果改变method的名称，override会报错return null;}
}

package Demo2205;/*
* 方法覆盖重写的注意事项：
* 1.必须保证父子类之间方法的名称相同，参数列表也相同
* @Override:写在方法前面，用来检测是不是有效的正确覆盖重写
* 这个注解就算不写，只要满足要求，也是正确的方法覆盖重写。
*
* 2.子类方法的返回值必须小于等于父类方法的返回值范围。
* 前提：java.lang.Object类是所有类的公共最高父类（祖宗类），java.lang.String就是Object的子类
*
* 3.子类方法的权限必须大于等于父类方法的权限修饰符。
* 小扩展：Public>protected>(default)>private
* 备注：（default）不是关键字default，而是什么都不写，留空。
* */public class Demo01Override {}

7.继承方法的覆盖重写-应用场景

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DMpcO5y4-1608862409656)(F:\Java\Learn\day15\day22.assets\image-20201224163026065.png)]

package Demo2206;//本来的老款手机
public class Phone {public void call() {System.out.println("打电话了");}public void send() {System.out.println("发短信了");}public void show() {System.out.println("显示号码");}
}

package Demo2206;
//定义一个新手机，使用老手机作为父类
public class NewPhone extends Phone {@Overridepublic void show() {super.show();//把父类的show方法拿过来重复利用//自己子类再来添加更多内容System.out.println("显示姓名");System.out.println("显示头像");}
}

package Demo2206;/*
* 新手机相对于老手机多了”显示姓名，显示头像”的功能
* 对于原来老手机的显示号码，可以用super继承，后面两个功能可以自己重写
* */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();//显示号码,显示姓名,显示头像}
}

8.继承中构造方法的访问特点

package Demo2207;public class Fu {public Fu(){System.out.println("父类无参构造方法");}public Fu(int num) {System.out.println("父类有参构造方法");}
}

package Demo2207;public class Zi extends Fu{public Zi(){//super();//在调用父类无参构造方法super(20);System.out.println("子类无参构造方法");}/*public void method() {super();}*/}

package Demo2207;/*
* 继承关系中，父子类构造方法的访问特点：
*
* 1.子类构造方法中有一个默认隐含的super（）调用，所以一定是先调用的父类构造，后执行的子类构造。
* 2.子类构造可以通过super关键字来调用父类重载构造。赠送的是无参数的super
* 3.super的父类构造调用，必须是子类构造方法的第一个语句.不能一个子类构造调用多次super构造。
* 总结：
* 子类必须调用父类构造方法，不写则赠送super（）；写了则用写的指定的super调用，super只能有一个，还必须是第一个。
* */public class Demo01Constructor {public static void main(String[] args) {Zi zi = new Zi();}
/*
* 父类无参构造方法
子类无参构造方法
* */}

9.super关键字的三种用法

package Demo2208;public class Fu {int num = 20;public void method(){System.out.println("父类方法");}
}

package Demo2208;/*
* super关键字的用法有三种：
* 1.在子类的成员方法中，访问父类的成员变量。
* 2.在子类的成员方法中，访问父类的成员方法。
* 3.在子类的构造方法中，访问父类的构造方法。
*
* this是用来访问本类内容的。
* */
public class Zi extends Fu {int num = 20;public Zi(){super();}public void methodZi(){System.out.println(super.num);//10父类}public void method(){super.method();//访问父类中的methodSystem.out.println("子类方法");}
}

10.this关键字的三种用法

package Demo2209;public class Fu {int num = 30;
}

package Demo2209;/*
* super关键字用来访问父类内容，而this关键字用来访问本类内容。用法也有三种。
* 1.在本类的成员方法中，访问本类的成员变量。
* 2.在本类的成员方法中，访问本类的另一个成员方法。
* 3.在本类的构造方法中，访问本类的另一个构造方法。
* A.在第三种方法中要注意：this（）调用也必须是构造方法的第一个语句。唯一一个。
* B.super和this两种构造调用，不能同时使用，因为都是唯一的。
* */public class Zi extends Fu{int num = 20;//成员变量public Zi(){//super();//这一行不再调用this(123);//3.在本类的构造方法中，访问本类的另一个构造方法。本类的无参构造，调用本类的有参构造//this(1,2);//报错，必须唯一}public Zi(int m){this(1,2);}public Zi(int m,int n){//this(2);//不能来回调用}public void showNum(){int num = 10;//局部变量System.out.println(num);//10System.out.println(this.num);//20本类中的成员变量System.out.println(super.num);//30父类中的成员变量}public void methodA(){System.out.println("aaa");}public void methodB(){this.methodA();//2.在本类的成员方法中，访问本类的另一个成员方法。System.out.println("bbb");}
}

11.super与this关键字图解

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ha17nORa-1608862409658)(F:\Java\Learn\day15\day22.assets\image-20201225093723036.png)]

package Demo2210;public class Fu {int num = 10;public void method() {System.out.println("父类方法");}
}

package Demo2210;public class Zi extends Fu {int num = 20;@Overridepublic void method() {super.method();System.out.println("子类方法");}public void show() {int num = 30;System.out.println(num);//30System.out.println(this.num);//20System.out.println(super.num);//10}
}

package Demo2210;public class Demo {public static void main(String[] args) {Zi zi = new Zi();zi.show();zi.method();//父类方法、子类方法}
}

12.java继承的三个特点

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OHVqfmBX-1608862409661)(F:\Java\Learn\day15\day22.assets\image-20201225094652976.png)]

第22天学习Java的笔记-继承相关推荐

深入学习Java虚拟机笔记
提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档文章目录前言一.走进Java 1.4.2 HotSpot VM 1.4.4 BEA JRockit/IBM J9 VM 1.6.1 ...
第18天学习Java的笔记-ArrayList
还有31天! 对象数组 package Demo1801;public class Person {private String name;private int age;public Person( ...
第21天学习Java的笔记-数学工具类Arrays，Math
27天! 数学工具类 1.1数组工具类Arrays package Demo2101;/* 注意事项:是Arrays进行调用,不是变量进行调用!!!* java.util.Arrays是一个与数组相关 ...
第19天学习Java的笔记-String字符串
29天! 字符串 1.字符串概述和特点.构造方法和直接创建 package Demo1901;/* * java.lang.String类代表字符串. * API当中说,Java程序中的所有字符串字面 ...
第15天学习Java的笔记（封装性，this，构造方法）
还有35天! 面向对象三大特征之封装性 package Demo1501;/** 面向对象三大特征:封装.继承.多态** 封装性在Java中的体现:* 1.方法就是一种封装* 2.关键字private ...
第12天学习Java的笔记（数组小练习，数组与方法）
38天求数组中的最大值 package day1201;public class Demo01ArrayMax {public static void main(String[] args) {in ...
第24天学习Java的笔记-接口Interface
接口 1.接口概述与生活举例 2.接口的定义基本格式.接口的抽象方法定义及使用接口使用步骤: 1.接口不能直接使用,必须有一个"实现类"来"实现"该接口. 格 ...
第23天学习Java的笔记-抽象类
抽象 1.抽象的概念图形一定可以计算面积,但是计算面积方法不确定:动物一定要吃东西,但是吃东西的方法不确定. 2.抽象方法和抽象类的格式.使用 package Demo2301;/* * 抽象方法, ...
第20天学习Java的笔记-static静态
28天静态static关键字 1.概述 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1rR1rotO-1608259503514)(F:\Java\Learn\da ...

第22天学习Java的笔记-继承

继承