Java的继承

继承：

概述：
多个类中都具有一些相同的属性和行为，将这些相同的属性和行为提取到一个单独的类中，那么这些类就不用重复定义这些属性和行为，只需要继承一个类就可以了。

继承关系是事物之间的一种所属关系，如上图所示，兔子和羊都属于食草动物，狮子和豹都属于食肉动物。
父类更通用，子类更具体，通过继承，可以让多个事物形成一种关系体系。

定义：

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

好处：

1，提高代码的通用性。
2，类和类之间产生关系，是多态的前提。

格式：

class 父类类名{
	代码行
}

关键字：extends 继承

class 子类类名 extends 父类类名{
	代码行
}

继承的特点：

成员变量
当两个类之间产生了继承关系，那么各类中的成员变量怎么样？

成员变量名不相同：

public class Fu{
	int num=24;
}

public class Zi extends Fu{
	int num2=8;
	public void show(){
		System.out.println(num);
		System.out.println(num2);
	}
}

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

输出结果：

24
8

成员变量名相同：

public class Zi extends Fu{
	int num=8;
	public void show(){
		System.out.println(num);		
	}
}

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

输出结果：

8

当成员变量名相同的时候，子类的成员变量会将父类的成员变量覆盖。

成员方法重名：重写（override）
如果子类父类中出现重名的成员方法，这时的访问是一种特殊情况，叫方法重写。
方法重写：子类中出现和父类中重名的方法时（返回类型，方法名和参数列表相同），就会出现覆盖的现象，也叫方法的重写，申明不变，重新实现。

public class Fu {
    int num=24;
    
    public void show(){
        System.out.println("我是父类中的show方法");
    }
}

public class Zi extends Fu {
    int num=8;
    
    public void show(){
        System.out.println("我是子类中的show方法");
    }
}

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

输出结果：

我是子类中的show方法

上面的例子就是子类将父类中的show方法进行了重写。

重写的一种应用：
重写就是子类根据自己的需要，定义自己特有的行为，但有时候需要在继承父类的基础上添加自己特有的行为。

定义一个手机类

public class Fu {
    public void sendMessage(){
        System.out.println("发短信！");
    }
    public void call(){
        System.out.println("打电话！");
    }

    public void show(){
        System.out.println("来电显示！");
    }
}

public class Zi extends Fu {
    int num=8;

    public void show(){
        super.show();
        System.out.println("显示头像！");
        System.out.println("显示名字！");
    }
}

public class Demo {
    public static void main(String[] args) {
        Zi zi = new Zi();        
        zi.sendMessage();
        zi.call();
        zi.show();
    }
}

输出结果：

发短信！
打电话！
来电显示！
显示头像！
显示名字！

继承的特点：构造方法

注意：构造方法不需要 void 和 基本数据类型等等…

public class Fu {
    public  Fu(){
        System.out.println("父类的构造方法");
    }
}

public class Zi extends Fu {
    public  Zi(){
        System.out.println("子类的构造方法");
    }
}

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

输出结果：

父类的构造方法
子类的构造方法

super 和 this 关键字：

每当我们创建子类对象的时候，先初始化我们父类的构造方法，再创建子类本身的对象。
super：代表父类的存储空间的标识。
this：代表啊子类的对象的引用。

访问对象的时候：
this.成员变量 = 本类中的成员变量。
super.成员变量 = 父类中的成员变量。
this.成员方法（） = 本类中的成员方法。
super.成员方法（） = 父类中的成员方法。
super（） ： 调用父类的构造方法

继承的特点：

1，Java只支持单继承，不支持多继承。
class A extends B（）单继承
clas A extends B ，C（）多继承不行
2，Java中支持多层继承。
class A extends B（）
class C extends A（）
A继承了B类，C又继承了A类，所以C可以调用A和B的属性和行为。
在Java中所有类的顶级父类（祖宗）：Object类，系统默认继承Object类
3，子类和父类是一种相对的概念。

抽象类：

由来：
父类中的方法，被其子类重写，子类各自实现的各不相同，那么父类中方法的申明和方法体，只剩申明有意义，方法体就没什么用了。我们把没有方法体的方法称为抽象方法。Java语言中规定包含抽象方法的类是抽象类。

定义：
抽象方法：没有方法体的方法。
抽象类：包含抽象方法的类。

abstract 关键字

使用这个关键字修饰方法，该方法就成了一个抽象方法，抽象方法只包含一个方法名，没有方法体。

格式：

public abstract class Test01 {//抽象类
    //抽象方法，没有方法体
    public abstract void A();//没有方法体，所以不需要{}大括号

    //抽象方法一定在抽象类中，但抽象类中不一定都是抽象方法
    public void B(){
        System.out.println("抽象类中的非抽象方法");
    }
}

父类中的抽象方法，子类一定要实现。

public class Demo extends Test01{
    @Override
    public void A() {
        System.out.println("这是父类的抽象方法");
    }
}

注意事项：（细节比较）

1，抽象类不能创建对象（抽象类中方法没有方法体，所以即便创建了对象去调用也没有任何意义）。
2，抽象类中，可以构造方法，提供给子类创建对象的时候使用。
3，抽象类中不一定都是抽象方法，但抽象方法一定在抽象类中。
4，抽象类的子类，必须重写抽象父类中的所有抽象方法，否则会编译报错。除非子类也是一个抽象类，这时候可以不用实现。