继承

继承的好处：

1.提高了代码的复用性。

2.让类与类之间产生了关系，给第三个特征多态提供了前提。

java种支持单继承，不支持多继承，但对c++种的多继承机制进行改良。

单继承：一个子类只能有一个直接父类。

多继承：一个子类可以有多个直接父类（Java不允许，进行改良），不直接支持，因为多个父类种有相同成员，会产生调用不确定性。

java支持（多重）继承。

当使用一个继承体系时，

1.查看该体系中的顶层类，了解该体系的基本功能。

2.创建体系种的最子类对象，完成功能的使用。

什么时候定义继承呢？

当类与类之间存在着所属关系的时候，就定义继承。xxx是yyy中的一种，xxx extents yyy。

this：代表一个本类对象的引用。

super：代表一个父类空间。

package com.monfolld;

 class Fu {
    int num=4;
}
class Zi extends Fu{
     int num=5;
     void show(){                                   //父类中的成员变量名用super区分父类
         System.out.println(this.num+"+"+super.num);//本类的成员和局部变量用this区分
     }
}
class Text{
    public static void main(String[] args){
        Zi zi=new Zi();
        zi.show();
    }
}

结果：

5+4

注意：子类不能直接访问父类中的私有内容，但可以同类中定义方法间接访问

package com.monfolld;
class Fu {
    private int num=5;
    public int getNum(){   //间接访问私有数据
        return num;
    }
}
class Zi extends Fu{
    void show(){
        System.out.println(super.getNum());   
    }
}
class TestThis {
    public static void main(String[] args) {
        Zi zi=new Zi();
        zi.show();
    }

}

输出结果：

5

当子父类出现成员函数一模一样的情况，会运行子类的函数。

这种现象，称为覆盖操作，这是函数在子父类中的特性。

函数两个特性：

1.重载。同一个类中，overload。

2.覆盖。子类中，覆盖也称为重写，覆写。override

覆盖注意事项：

1.子类方法覆盖父类方法时，子类权限必须大于父类的权限。

2.静态只能覆盖静态，或被静态覆盖。

package com.monfolld;
class Fu {
    void show(){
        System.out.println("FU");
    }
}
class Zi extends Fu{
    void show(){
        System.out.println("ZI");
    }
}
class TestThis {                       
    public static void main(String[] args) {
        Zi zi=new Zi();
        zi.show();
    }

}

输出结果：

ZI

什么时候使用覆盖操作：

当对一个类进行子类扩展时，子类需要保留父类的功能声明。

但是要定义子类中该功能的特有内容时，就使用覆盖操作完成。

package com.monfolld;
class Fu {
    void show(){
        System.out.println("父方法");
    }
}
class Zi extends Fu{
    void show(){
       super.show();                     //子类方法用super调用父类内容
        System.out.println("子一方法");
        System.out.println("子二方法");
    }
}
class TestThis {
    public static void main(String[] args) {
        Zi zi=new Zi();
        zi.show();
    }

}

运行结果：

父方法
子一方法
子二方法