面向对象三大特征之一-----继承

继承

概述

多个类中存在相同的属性和行为时，我们可以将这些内容抽取到单独的一个类中，那么多个类就无需在定义这些属性和行为，只要去继承这个单独的类即可。

其中，多个类称为子类或者派生类，单独的那一个类称为父类，超类，基类

继承描述的是事物之间的所属关系，这种关系是：is-a关系。在继承关系中，子类就是一个父类，也就是说子类可以被当做父类看待 。

例如：父类是员工，子类是讲师，“那么讲师就是一个员工” is-a—是一个

一般情况下，父类更通用，子类更具体。我们可以通过继承，使多种事物之间形成一种关系体系

定义

• 继承：就是子类继承父类的属性和方法，使子类对象具有与父类相同的属性、方法。子类可以直接访问父类中的【非私有】的属性和方法

  好处

  1.可以提高代码复用性。

  2.类与类之间可以产生一种关系，是多态的前提

继承的格式

通过extends关键字，可以声明一个子类继承一个父类

public class Fuclass{
   //....    
}
public class Ziclass extends Fuclass{
    //.... 
}

/*
定义一个员工类Employee
*/
public class Employee{
    String name;
    int id;
    //定义一个员工的工作方法
    public void work(){
        System.out.println(name+"努力工作");
    }
    
}

/*
定义一个教师类继承员工类
*/
public class Teacher extends Employee{
    
    //定义教师类中的专有方法
    public void teach(){
        
        System.out.println(name+"在讲课");
    }
    
}
/*
定义一个测试类
*/
public class Test{
    
    public static void main(String[] args){
        //创建一个讲师类
        Teacher t=new Teacher();
        //为员工name属性赋值
        t.name="张三";
        //调用yuango方法
        t.teach();
        //调用Teacher类继承过来的work()方法
        t.work();
 
    }
 
}

继承后的特点–成员变量

当类之间产生关系后，其中各类中的成员变量有哪些影响？

成员变量不重名的

如果子类父类中定义的成员变量名字不重复，这时的访问时没有任何影响的

public class Fu{
    //定义一个变量
    int num=10;
 
}
public class Zi extends Fu{
    //定义一个变量
    int num02=20;
    //定义一个子类的成员方法
    public void show(){
        //访问父类中的成员变量 num
        System.out.println(num);//10
        //访问子类中的成员变量 num2
        System.out.println(num2);//20
    }
    
}

public class TestExtendsField{
    
    public static void main(String[] args){
        
        Zi z=new Zi();
        //调用子类方法
        z.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
    }
}
// 20
// 20

在父子类的继承关系中，如果成员变量重名，则创建子类对象时，访问有两种方式：

1.直接通过子类对象访问成员变量：等号左边是谁，就优先找谁，如果没有就向上找

2.间接通过成员方法访问成员变量：该方法属于谁，就优先用谁，如果没有就向上找

子父类中出现了同名的成员变量时，在子类中想要访问父类中的非私有成员变量时，需要使用super

关键字，修饰父类的成员变量，类似于this

super.父类成员变量名

子类方法代码需要修改

public class Zi extends Fu{
    
    //定义子类中的成员方法
    public void show(){
         //访问父类中的成员变量 num
        System.out.println(super.num);//10
        //访问子类中的成员变量 num
        System.out.println(num);//20
    }
}

备注：Fu类中的成员变量是非私有的，子类中可以直接访问，若Fu类中的成员变量私有了，子类不能直接访问

通常编码时，我们遵循的是封装的原则，使用private关键字修饰成员变量，那么如何访问父类中的私有成员变量。可以借助于父类中的提供的公共的setXxx和getXxx方法

继承后的特点----方法

成员方法不重名：

如果子类父类中出现不重名的成员方法，这时的调用没任何影响，对象在调用方法时，会现在子类中去查找有没有对应的方法，若子类中存在该方法，那么就执行子类中的方法。若子类当中不存在该方法，就会执行父类中的成员方法

public class Fu{
    int num=10；
    public void show(){
        
        System.our.println("父类中的方法在执行");
        System.our.println("父类中的成员变量num"+num);
        
    }
    public class Zi extends Fu{
        
        int num=20;
        public void show2(){
            
            System.our.println("子类中的方法在执行");
            System.our.println("子类中的成员变量"+num);
        }
    }
    public class Test{
        
        public static void main (Strinf []args){
            Zi zi=new Zi();
            zi.show();//调用父类当中的show方法      10
            zi.show2();//调用子类当中的show2方法     20
            
        }
    }
    
    
}

如果成员方法重名----重写

如果出现重名的成员方法，这时的访问是一种特殊情况，叫做方法的重写（Override）

• 子类中出现与父类名字相同的方法（返回值类型一样，方法名一样，参数列表一样），会出现覆盖效果

  重写或者复写，声明不变，重新实现

public class Fu{
    int num=10;
    public void show(){
        System.our.println("Fu show()在执行");
        System.our.println("Fu 成员变量"+num);
    }
    
}


public class Zi extends Fu{
    
    int num=20;
    public void show{
        System.our.println("Zi show()在执行");
        System.our.println("Zi 成员变量"+num);
    }
    
}

public class Test{
    
    public static void main(String []args){
        
        Zi zi=new Zi();
        //调用show方法
        //子类中有show方法，执行的是重写后的show（）
        zi.show();//Zi show()在执行   20
        
        
        
    }
}

重写的应用

子类可以根据需要定义特定于的自己的行为，及沿袭了父类的功能名称，又根据子类的需要重新实现父类的方法，从而可以进行功能的扩展

public class Phone{
    //打电话
    public void call(){
       System.our.println("打电话");
    }
    public void sendMessage(){
         System.our.println("发短信");
    }
    public void show(){
         System.our.println("来电显示");
    }
    
    public class IPhone12 extend Phone{
        
        //重写父类当中的来电显示功能，并增加自己的新功能
        public void show(){
            super.show();
             System.our.println("显示姓名");
             System.our.println("显示头像");
        }
        
    }
    public class Test{
        IPhone12 iphone12=new IPhone12();
        //调用父类中的打电话打电话
        iphone.call();
        
        //调用重写之后的来电显示
        iphone.show();
        
    }
    
}

重写：方法的名称一样，参数列表一样，返回值类型一样，重写的前提有继承关系

重载：方法的名称一样，参数列表不一样，返回值类型不做要求，在本类中

注意事项

1. 子类方法重写父类方法，必须要保证权限要大于等于父类权限

2. 子类方法覆盖父类方法，返回值类型，函数名称和参数列表必须一模一样

继承后的特点----构造方法

先回忆构造方法的定义和作用

1. 构造方法名字和类名保持一致，所以子类是无法继承父类当中的构造方法
2. 构造方法的作用一般是用来初始化成员变量，所以自类在初始化的过程中，必须先执行扶额李忠的初始化动作，子类的构造方法当中，默认有一个super（）方法，表示调用父类的无参构造方法，父类的成员变量初始化之后才可以给子类中使用

public class Fu{
    
    private int n;
    
    public Fu(){
         System.our.println("Fu()");
    }
}
public class Zi extend Fu{
    
    public Zi(){
        //super() 调用父类中的构造方法，隐式调用
        System.our.println("Zi()");
        
    }
    
}


public class Test{
    
    public static void main(String []args){
        Zi zi=new Zi();
        
    }
}
//Fu（）
//Zi（）

super和this

父类空间优先于子类对象产生

在每次创建子类对象的时候，先初始化父类空间，再创建子类对象，目的在于子类对象中包含了其对应的父类空间，便可以包含父类的成员，如果父类成员非私有，则子类可以随意使用父类成员，体现在子类的构造方调用时，会先调用父类构造方法