认识Java的第九天（下）——继承

由来：
多个类中存在相同的属性和行为，将这些内容抽取到一个单独的类里面，那么多个类无需定义这些属性和行为，只要继承那一个类就可以。
继承描述的是事物之间的所属的关系，这种关系一般用is----a的关系，例如我们图上，我们猫是属于动物的，可以看到，父类更通用，我们通过继承，可以使多个事物形成一种关系体现。

定义

继承：就是子类继承父类的属性和行为，使得子类对象具有和父类相同的属性和相同的行为，子类可以直接访问父类中的非私有的属性和行为。

好处：

1、提高我们的代码复用性
2、类和类之间产生一种关系，是多态的一个前提。

继承的格式：

通过extends关键字，可以声明一个子类继承另外一个父类，格式：
class 父类{
…
}

class 子类 extends 父类{
…
}

public class test06 {
    /*定义一个类，作为我们的父类*/
    String name;//定义属性
    public  void work(){
        System.out.println("积极写博客");
    }
}

public class test07 extends test06{
    public void print(){
        //写了一个打印方法
        System.out.println("name="+name);
    }
}

public class test678 {
    public static void main(String[] args) {
        //创建一个student类的对象
        test07 student=new test07();
        //为了我们student的name属性赋值
        student.name="不辞树";
        //调用test06的方法
        student.work();
        //也可以调用student自己独有的方法
        student.print();
    }
}
/*积极写博客
name=不辞树*/

继承后的特点

成员变量

当类之间产生了关系，其中各个类的成员变量怎么访问？

成员变量不重名的时候：

如果子类父类中出现不重名的成员变量，这时的访问是没有任何影响的。

public class fu {
    int num=10;
}

public class zi extends fu {
    int num2=20;
    public void show(){
        System.out.println("fu num="+num);
        System.out.println("zi num="+num2);
    }
}

public class test09 {
    public static void main(String[] args) {
        zi zi=new zi();
        zi.show();
    }
}

成员变量重名的时候：

如果子类和父类中出现成员变量重名，这时访问就是有影响了
子类中出现了重名的成员变量时，在子类中需要访问父类的非私有的成变量，需要使用super关键字。修饰父类的成变量，类似前面this。

public class fu {
    int num=10;
}

public class zi extends fu {
    int num=20;
    public void show(){
        System.out.println("fu num="+super.num);
        System.out.println("zi num="+this.num);
    }
}

父类中成员变量是非私有的，子类中可以在直接访问，如果父类中的成员变量私有化了，子类不能直接访问，通常我们的编码时，我们遵循封装的原则，使用private修饰成员变量，那么如何去访问私有的变量，需要父类中提供相应的get和set方法。

成员方法

当类之间产生了关系，其中各个类的成员方法，又怎么访问？

成员方法不重名的时候：

如果子类和父类中出现不重名的成员方法，这时调用不会有任何影响，对象调用时，会先在类中查找相应的方法，如果子类中存在的就会执行子类的方法，如果子类中不存在，就会执行父类中的相应的方法。

public class fu01 {
    public void show(){
        System.out.println("我是父类的show方法");
    }
}

public class zi01 extends fu01 {
    public void show1() {
        System.out.println("我是子类的show方法");
    }
}

public class test10 {
    public static void main(String[] args) {
        zi01 zi=new zi01();
        zi.show();
        zi.show1();
    }
}
//我是父类的show方法
//我是子类的show方法

成员方法重名的时候

如果子类中和父类中出现重名的成员方法，这时访问是一种特殊的情况，叫做方法重写，
方法重写：子类这种出现与父类一模一样的方法时（返回值类型，方法名和参数列表），会出现覆盖的效果，也称方法的重写或者复写。申明不变，重新实现。

public class fu01 {
    public void show(){
        System.out.println("我是父类的show方法");
    }
}

public class zi01 extends fu01 {
    public void show1() {
        System.out.println("我是子类的show方法");
    }
}

public class test10 {
    public static void main(String[] args) {
        zi01 zi=new zi01();
        zi.show();
    }
}
//我是子类的show方法

重写

子类可以根据需要，定义特定于自己的行为，既沿袭例如父类的功能的名称，又根据子类的需要重写实现父类的方法，从而进行扩展的增强，比如：新的手机增加了来电显示头像的功能。

public class Phone {
    public void sendMessage(){
        System.out.println("发短信");
    }
    public void call(){
        System.out.println("打电话");
    }
    public void showNum(){
        System.out.println("来电显示号码");
    }
}

public class NewPhone extends Phone {
    @Override
    public void showNum() {
        //调用父类已有的功能super
        super.showNum();
        //增加一些特有的功能：
        System.out.println("显示来电姓名");
        System.out.println("显示头像");
    }
}

public class test01 {
    public static void main(String[] args) {
        NewPhone newPhone=new NewPhone();
        //发短信
        newPhone.sendMessage();
        newPhone.call();
        newPhone.showNum();
    }
}

注意事项：
1、子类方法覆盖父类的方法，必须要保证权限大于等于父类的权限。
2、子类方法覆盖父类的方法，返回值类型，函数名和参数列表都要一模一样。

构造方法

1、构造方法的名字和类名一致，所以子类无法继承父类的构造方法
2、构造方法的作用是初始化成员变量，所以子类的初始化过程中，必须先执行父类的初始化操作。子类的构造方法中有默认的super();.表示调用父类的构造方法，父类成员变量初始化，才可以给子类使用

public class Fu {
    private int n;
    Fu(){
        System.out.println("Fu");
    }
}

public class Zi {
    Zi(){
        super();
        System.out.println("Zi");
    }
}

public class test02 {
    public static void main(String[] args) {
        Zi zi=new Zi();
    }
}

Super和this：

父类空间优于子类的对象产生：
每次创建子类对象的时候，先初始化父类的空间，再创建子类的对象本事，目的在于子类对象中包含了其对应父类的空间 ，便可以包含父类的成员，如果父类成员非private修饰，则子类可以随意使用父类成员。
Super和this的含义：
Super:代表的是父类额度存储空间，可以理解父类的引用
this:代表当前对象的引用（谁调用我，我就代表谁）

1、访问成员
this.成员变量 super.成员变量
this.成员方法() super.成员方法()
this()–本类的构造方法 super()----父类的构造方法

继承的特点：

1、java只支持单继承，不支持多继承
一个类只有一个父类
class C extends A{}; //可以
class C extends A,B,C{}; //不可以
2、Java支持多层继承
Class C extends D{}
Class B extends C{}
Class A extends B{}