继承的概述
面对对象有三大特征分别是：封装性、继承性、多态性
继承是多态的前提，如果没有继承就没有多态
继承主要解决的问题就是：共性抽取
这里的继承并不是父子关系而是师徒关系
师徒关系是师傅会多少就会教给徒弟多少，所以每个徒弟是一样的
特点：
1、子类可以拥有父类的内容
2、子类还可以拥有自己专有的内容
继承的格式
在继承的关系中，子类就是一个父类，也就是说子类可以被当作父类看待。
例如父类是员工，子类是讲师，那么讲师其实也可以是员工。
定义父类格式：
public class父类名称{
}定义子类名称：
public class 子类名称 extends 父类名称{
}通过下面代码来解释继承
首先定义一个父类
public class carryon {
public void method(){
System.out.println("方法执行");
}
}然后定义一个子类
public class zilei extends carryon{
}最后写一个主函数
public class show {
public static void main(String[] args) {
zilei zhanshi=new zilei();
zhanshi.method();
}
}我们可以看到，父类中有执行成功的语句，子类中并没有，但是我们在主函数中写了继承的使用格式，在运行主函数时继承了父类，
运行结果如下图
这样就达到了代码复用的效果，省去了在相似类中重复写相同的代码的麻烦。
比如我定义一个员工类，一个助教类，一个班助类，这三个类都需要姓名和工号，那我用继承就只需要写一个姓名和工号的代码，其他两个类中代码可以为空，也可以加上子类特有的。
继承中成员变量的访问特点
首先看一段代码
定义父类
public class carryon {
int num=10;
}定义子类
public class zilei extends carryon{
int num2=20;
int num=1333;
}使用主函数调用一下
public class show {
public static void main(String[] args) {
carryon fu =new carryon();
zilei zi=new zilei();
System.out.println(fu.num);
System.out.println(zi.num);//子类可以拥有父类继承下的东西
System.out.println(zi.num2);
}
}
当父类和子类中变量重名时，
创建子类对象时访问有两种形式
1、直接通过子类对象访问成员变量
等号左边是谁就优先用谁，没有则向上找
2、间接通过成员方法访问成员变量
该方法属于谁就优先用谁，没有则向上找
父类
public class zilei extends carryon{
int num2=20;
int num=1333;
public void methodzi(){
System.out.println(num);//因为本类中有num优先使用本类中的
}
}
==================================
子类
public class carryon {
int num=10;
public void method (){
System.out.println(num);//使用的是本类当中的
}
}
==================================
主函数代码
public class show {
public static void main(String[] args) {
carryon fu =new carryon();
zilei zi=new zilei();
System.out.println(fu.num);
System.out.println(zi.num);
//子类可以拥有父类继承下的东西
System.out.println(zi.num2);
System.out.println("==========");
System.out.println(zi.num);
//等号左边是子类就优先用子类
System.out.println("==========");
zi.methodzi();//优先使用本类
}
}运行结果
区分三种子类方法中的重名
局部变量： 直接写变量名
本类中的成员变量： this.成员变量名
父类中的成员变量： super.成员变量名
用代码来理解一下
父类
public class carryon {
int num=10;
}
====================
子类
public class zilei extends carryon{
int num=20;
public void method (){
int num=50;
System.out.println(num);//输出50，局部变量
System.out.println(this.num);//输出20，本类的成员变量
System.out.println(super.num);//输出10，父类中的成员变量
}
}
=====================
主方法
public class show {
public static void main(String[] args) {
zilei zi=new zilei();
zi.method();
}
}
继承中成员方法的访问特点
原则：创建的对象是谁就优先用谁，如果没有则向上找
用代码理解：
父类
public class carryon {
public void methodfu(){
System.out.println("父类方法执行");
}
public void method(){
System.out.println("父类重名方法执行");
}
}
===============================
子类
public class zilei extends carryon{
int num=20;
public void methodzi (){
System.out.println("子类方法执行");
}
public void method(){
System.out.println("子类重名方法执行");
}
}
================================
主方法
public class show {
public static void main(String[] args) {
zilei zi = new zilei();
zi.methodfu();//子类中没有，所以向上找
zi.methodzi();
//重名的时候呢？
zi.method();//创建的对象是谁就优先用谁，如果没有则向上找
}
}
方法重名时，创建的对象是谁就优先用谁，如果没有则向上找。
继承中方法的覆盖重写
重写（Override） ：在继承关系中，方法名称一样，参数列表也一样
重载（Overload）：方法名称一样，参数列表不一样
方法的覆盖重写特点：创建的是子类对象优先用子类方法
方法的覆盖重写的注意事项：
1、必须保证父子类之间方法的名称相同，参数列表也相同
@override：写在方法前面，用来检测是不是有效重写，如果不是有效重写就会报错。这个注解即使不写，只要满足要求也是有效重写。
2、子类方法的返回值必须小于等于父类方法的返回值范围
java.lang.Object类是所有类的公共最高父类，java.lang.String就是Object的子类
3、子类方法的权限必须大于等于父类方法的权限修饰符
权限修饰符：比如public >protected > >(default)>private
default不是关键字，而是什么都不写留空
父类
public class fu {
public Object method(){
return null;
}
}
子类
public class zi extends fu {
@Override
public Object method(){
return null;
}
}
主方法
public class override {
}什么时候应该覆盖重写呢？
拿一张图给大家理解
这里的案例中，比如我们需要添加新的显示姓名和显示头像的功能，
那么直接使用重写就可以省去很多的繁琐。
代码演示如下
旧款手机
public class phone {
public void call(){
System.out.println("打电话");
}
public void send(){
System.out.println("发短信");
}
public void show(){
System.out.println("显示号码");
}
}
=================================
新款手机
public class newphome extends phone{
@Override
public void show(){
super.show();//父方法拿来使用
System.out.println("显示头像");
System.out.println("显示姓名");
}
}
=================================
public class text {
public static void main(String[] args) {
phone ph = new phone();
ph.call();
ph.send();
ph.show();
System.out.println("===========");
newphome ph2 = new newphome();
ph2.call();
ph2.send();
ph2.show();
}
}运行结果
继承中构造方法的访问特点
继承关系中父子类构造方法的访问特点
先访问父类构造方法，再访问子类构造方法，先有父后有子
1、子类构造方法中默认有一个隐含的super（）调用，什么都不写则默认赠送这个
代码演示
父类
public class demo10fu {
public demo10fu(){
System.out.println("父类方法！");
}
}
===========================================
子类
public class demo08 extends demo10fu{
public demo08(){
//super();默认赠送无参数父类构造，如果父类有参数则不再赠送
System.out.println("子类方法！");
}
}
============================================
主方法
public class demo09 {
public static void main(String[] args) {
demo08 zilei=new demo08();
}
}运行结果
先执行父类方法再执行子类方法，因为构造方法是无参数的，会默认赠送一个无参数的super()
那么有参数的构造方法呢？ 2、可以通过super关键字来子类构造父类重载构造
也是看个代码
父类
public class demo10fu {
public demo10fu(int num){
System.out.println("父类方法！");
}
}
===========================================
子类
public class demo08 extends demo10fu{
public demo08(){
//super();默认赠送无参数父类构造，如果父类有参数则不再赠送
super(10);
System.out.println("子类方法！");
}
}
===========================================
主方法
public class demo09 {
public static void main(String[] args) {
demo08 zilei=new demo08();
}
}super的父类构造调用，必须是子类构造方法的第一个语句
两个就会报错
super关键字用来访问父类内容，this关键字用来访问子类内容
Java继承的三个特点
Java语言是单继承的
一个类的直接父类只能有唯一一个
class A{}
class B extends A{}//正确
class C{}
class D extends A，C{}//错误
原理
Java语言可以多级继承
class A{}
classB extends A{} //正确
class C extends B{} //正确
