关于java:JavaSE第10篇面向对象之继承

本篇咱们将持续学习面向对象编程，在之前咱们曾经学习过了面向对象之封装，晓得了如何定义一个规范的类及如何创立和应用对象。面向对象有三大特色，封装、继承、多态。那么接下来，咱们将会学习面向对象编程的继承。

什么是继承？

继承，指的是事物与事物之间的关系。

在生活中，咱们所了解的“继承”更多的是“子承父业”，就是儿子与父亲之间存在“继承”关系。

在 Java 编程中，咱们用类来形容事物，那么在面向对象编程中，“继承”指的是类与类之间的关系，通常是子类和父类之间的关系，子类能够继承父类中的非公有成员（属性和办法）。

为什么要有继承？

继承有什么益处呢？

在生活中，很显然，儿子继承父亲的财产，能够少奋斗几十年甚至几辈子。

在编程中，继承有什么作用呢？咱们先来看一个需要，需要如下：

用面向对象的形式，形容几种动物，狗、猫、牛
- 狗，有名字、年龄、性别、毛色、爱吃食物、会看门
- 猫，有名字、年龄、性别、毛色、爱吃食物、会撒娇
- 牛，有名字、年龄、性别、毛色、爱吃食物、会耕地

此时面临这个需要时，咱们通常会定义三品种来形容，形容如下：

咱们察看能够发现，会存在这样一种景象：猫、狗、牛，存在一些共性的成员，这些共性都别离在不同的类中定义了。

问题：这样在编程中，就呈现的代码冗余（反复），若是当前有更多的动物品种呈现，还是要从新定义它们的共性成员，在整个工程看来，代码将会变得越来越冗余，越来越臃肿，不易于程序前期的保护。那如何解决呢？

解决：此时就能够应用继承机制解决代码的冗余问题，抽取共性，让共性复用。抽取的形式就是，形象出更高级的类（超类、父类），把共性定义在父类中，让其余也要领有这些共性成员的类作为子类继承父类。

对于上述需要，咱们能够形象出它们的父类，动物类。它们都是动物，动物都有属性 - 名字、年龄、毛色、性别，都是吃货，最终类的定义形容如下：

所以，在面向对象编程中，继承的作用：

进步代码的复用性，缩小代码冗余。
继承是多态的根底（后续解说）

总结

什么是继承：
- 继承就是，子类与父类之间的关系，子类能够继承父类中的成员。
继承的作用：
- 进步代码复用性，缩小代码冗余。

通过上述解说，咱们晓得了什么是继承以及继承的作用，接下来咱们来学习一下 Java 中定义继承的格局。

格局

关键字：extends

class 父类 {...}

class 子类 extends 父类 {...}

示例

父类：动物类

package www.penglei666.com.demo03;
/**
 * 动物类，父类
 */
public class Animal {
    String name;
    int age;
    String color;
    String gender;
    public void eat(){System.out.println("我是吃货！");
    }
}

子类：狗类

package www.penglei666.com.demo03;

/**
 * 狗类，子类，继承了 Animal
 */
public class Dog extends Animal {public void alert(){System.out.println("正告，我是看门专家");
    }
}

测试类：Test

package www.penglei666.com.demo03;

public class Test {public static void main(String[] args) {Dog wc = new Dog();
        // 能够应用父类中的属性：name、age、gender、color
        wc.name = "旺财";
        wc.age = 10;
        wc.gender = "公";
        wc.color = "yellow";
        // 能够调用父类中的办法：eat，也能够调用本人的办法
        wc.eat();   // 我是吃货！wc.alert(); // 正告，我是看门专家}
}

在上述代码中，Dog 类通过 extends 关键字继承了 Animal 类，这样 Dog 类便是 Animal 类的子类。

从运行后果不难看出，子类尽管没有定义 name、age、gender 等属性和 eat 办法，然而却能操作这几个成员。这就阐明，子类在继承父类的时候，会主动领有父类的成员。

若是父类中的成员和子类中的成员重名，子类对象在调用重名的成员时，会使怎么的景象呢？

子类和父类成员重名时

父类：Animal

package www.penglei666.com.demo03;
/**
 * 动物类，父类
 */
public class Animal {int age = 10;}

子类：Dog

package www.penglei666.com.demo03;

/**
 * 狗类，子类，继承了 Animal
 */
public class Dog extends Animal {
    int age = 11;
    public void printAge(){System.out.println("年龄：" + this.age);
    }
}

测试类：Test

package www.penglei666.com.demo03;

public class Test {public static void main(String[] args) {Dog wc = new Dog();
        wc.printAge(); // 输入后果：年龄：11}
}

通过输入后果能够发现，输入的并不是父类中的后果值，而是子类本人的。

那么，如何在重名的状况下，如何拜访到父类中的成员呢？此时能够应用关键字：super

咱们之前，学习过 this 关键字，示意代表调用者自身的援用，而 super 关键字，示意父类的援用。

super 关键字的应用

应用格局：super. 父类成员变量名

批改子类代码：Dog 类

package www.penglei666.com.demo03;

/**
 * 狗类，子类，继承了 Animal
 */
public class Dog extends Animal {
    int age = 11;
    public void printAge(){System.out.println("父 age：" + super.age);
        System.out.println("子 age：" + this.age);
    }
}

测试类：Test

package www.penglei666.com.demo03;

public class Test {public static void main(String[] args) {Dog wc = new Dog();
        wc.printAge(); 
        /* 输入后果：父 age：10
            子 age：11
        */
    }
}

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

在每次创立子类对象时，先初始化父类空间，再创立其子类对象自身。

目标在于子类对象中蕴含了其对应的父类空间，便能够蕴含其父类的成员，如果父类成员非 private 润饰，则子类能够随便应用父类成员。

代码体现在子类的构造方法调用时，肯定先调用父类的构造方法。了解图解如下：

super 和 this 的含意：

super：代表父类的 存储空间标识(能够了解为父亲的援用)。
this：代表 以后对象的援用(谁调用就代表谁)。

super 和 this 调用成员属性和办法

this. 成员变量        --    本类的
super. 成员变量        --    父类的

this. 成员办法名()      --    本类的    
super. 成员办法名()   --    父类的

super 和 this 调用构造方法

this(...)        --    本类的构造方法
super(...)       --    父类的构造方法

子类的每个构造方法中均有默认的 super()，调用父类的空参结构。

手动调用父类结构会笼罩默认的 super()。

super() 和 this() 都必须是在构造方法的第一行，所以不能同时呈现。

办法重写 Override

如果子类父类中呈现 不重名 的成员办法，这时的调用是 没有影响的。

对象调用办法时，会先在子类中查找有没有对应的办法，若子类中存在就会执行子类中的办法，若子类中不存在就会执行父类中相应的办法。代码如下：

父类：Fu

package www.penglei666.com.demo04;

public class Fu {public void fn1(){System.out.println("父类办法：fn");
    }
}

子类：Zi

package www.penglei666.com.demo04;

public class Zi extends Fu {
    @Override
    public void fn2() {System.out.println("Zi 类中的办法：fn");
    }
}

测试类：Test

package www.penglei666.com.demo04;

public class Test {public static void main(String[] args) {Zi zi = new Zi();
        zi.fn1(); // 输入后果：父类办法：fn
        zi.fn2(); // 输入后果：Zi 类中的办法：fn}
}

如果子类父类中呈现重名的成员办法，这时的拜访是一种非凡状况，叫做 办法重写 (Override)。

办法重写 ：子类中呈现与父类截然不同的办法时（返回值类型，办法名和参数列表都雷同），会呈现笼罩成果，也称为重写或者复写。 申明不变，从新实现

代码如下：

父类：Fu

package www.penglei666.com.demo04;

public class Fu {public void fn(){System.out.println("父类办法：fn");
    }
}

子类：Zi

package www.penglei666.com.demo04;

public class Zi extends Fu {
    @Override
    public void fn() {System.out.println("Zi 类中的办法：fn");
    }
}

测试类：

package www.penglei666.com.demo04;

public class Test {public static void main(String[] args) {Zi zi = new Zi();
        zi.fn(); // 输入后果：Zi 类中的办法：fn}
}

办法重写的利用

子类能够依据须要，定义特定于本人的行为。

既因循了父类的性能名称，又依据子类的须要从新实现父类办法，从而进行扩大加强。

比方新的手机减少来电显示头像的性能，代码如下：

父类：Phone

package www.penglei666.com.demo05;

/**
 * 父类：Phone
 */
public class Phone {public void sendMessage(){System.out.println("发送短信");
    }
    public void call(){System.out.println("拨打电话");
    }
    public void showNum(){System.out.println("来电显示对方号码");
    }
}

子类：

package www.penglei666.com.demo05;

/**
 * 子类：NewPhone
 */
public class NewPhone extends Phone {
    // 重写父类的来电显示号码性能，并减少本人的显示姓名和图片性能
    public void showNum(){
        // 调用父类曾经存在的性能应用 super
        super.showNum();
        // 减少本人特有显示姓名和图片性能
        System.out.println("来电显示对方姓名");
        System.out.println("来电显示对方头像");
    }
}

测试类：Test

package www.penglei666.com.demo05;

public class Test {public static void main(String[] args) {NewPhone np = new NewPhone();
        np.showNum();
        /**
         * 输入后果：* 来电显示号码
         * 来电显示对方姓名
         * 来电显示对方头像
         */
    }
}

这里重写时，用到 super. 父类成员办法，示意调用父类的成员办法。

构造方法的作用是初始化成员变量的。所以 子类的初始化过程中，必须先执行父类的初始化动作。子类的构造方法中默认有一个super()，示意调用父类的构造方法，父类成员变量初始化后，才能够给子类应用。代码如下：

父类：

package www.penglei666.com.demo06;

public class Fu {public Fu(){System.out.println("Fu 类构造方法初始化");
    }
}

子类：

package www.penglei666.com.demo06;

public class Zi extends Fu {public Zi(){// super(); 默认调用 super
        System.out.println("Zi 类构造方法初始化");
    }
}

测试类：

package www.penglei666.com.demo06;

public class Test {public static void main(String[] args) {Zi zi = new Zi();
        /* 执行后果：Fu 类构造方法初始化
            Zi 类构造方法初始化
        */
    }
    
}

特点 1：Java 只反对单继承，不反对多继承。

// 一个类只能有一个父类，不能够有多个父类。class C extends A{}     //ok
class C extends A，B...    //error

特点 2：Java 反对多层继承(继承体系)。

class A{}
class B extends A{}
class C extends B{}

抽象类的由来

当编写一个类时，咱们往往会为该类定义一些办法，这些办法是用来形容该类的性能具体实现形式，那么这些办法都有具体的办法体。

剖析事物时，发现了共性内容，就呈现向上抽取（父类中定义）。

然而，可能会有这样一种非凡状况，就是办法性能申明雷同，但办法性能主体不同。

那么这时也能够抽取，但 只抽取办法申明，不抽取办法主体。那么此办法就是一个形象办法。

如：

形容狗的行为：吃
形容猫的行为：吃
形容牛的行为：吃

狗、猫、牛之间有共性，能够进行向上抽取父类定义共性。

抽取它们的所属共性类型：动物。

因为狗、猫、牛都具备吃的性能，然而它们吃的食物不一样（比方：开篇咱们的需要狗、猫、牛都是吃货，都有吃的行为，然而吃的食物第不同的，狗啃骨头、猫吃鱼、牛吃草）。

这时在形容动物类时，发现了有些性能不可能具体形容，那么，这些不具体的性能，须要在类中标识进去，通过 java 中的关键字 abstract(形象) 润饰。当定义了形象办法的类也必须被 abstract 关键字润饰，被 abstract 关键字润饰的类是抽象类。

总结

形象办法：没有办法体的办法。
抽象类：蕴含形象办法的类。

形象办法：

应用abstract 关键字润饰办法，该办法就成了形象办法，形象办法只蕴含一个办法名，而没有办法体。

定义格局：

修饰符 abstract 返回值类型 办法名 (参数列表)；

示例代码：

public abstract void eat()；

抽象类：

如果一个类蕴含形象办法，那么该类必须是抽象类。

定义格局：

public abstract class 类名字 {}

示例代码：

public abstract class Animal {public abstract void eat();
}

抽象类的应用：

继承抽象类的子类必须重写父类所有的形象办法。否则，该子类也必须申明为抽象类。最终，必须有子类实现该父类的形象办法，否则，从最后的父类到最终的子类都不能创建对象，失去意义。

父类：Animal

package www.penglei666.com.demo07;
public abstract class Animal {public abstract void eat();
}

子类：Dog

package www.penglei666.com.demo07;
public class Dog extends Animal {
    @Override
    public void eat() {System.out.println("我爱啃骨头");
    }
}

此时的办法重写，是子类对父类形象办法的实现实现，咱们将这种办法重写的操作，也叫做 实现办法。

抽象类 不能创建对象，如果创立，编译无奈通过而报错。只能创立其非形象子类的对象。
- 了解形式：假如创立了抽象类的对象，调用形象的办法，而形象办法没有具体的办法体，没有意义。
抽象类中，能够有构造方法，是供子类创建对象时，初始化父类成员应用的。
- 了解形式：子类的构造方法中，有默认的 super()，须要拜访父类构造方法。
抽象类中，能够有成员变量。
- 了解形式：子类的共性的成员变量 , 能够定义在形象父类中。
抽象类中，不肯定蕴含形象办法，然而有形象办法的类必然是抽象类。
- 了解形式：未蕴含形象办法的抽象类，目标就是不想让调用者创立该类对象，通常用于某些非凡的类结构设计。
抽象类的子类，必须重写形象父类中 所有的 形象办法，否则，编译无奈通过而报错。除非该子类也是抽象类。
- 了解形式：假如不重写所有形象办法，则类中可能蕴含形象办法。那么创建对象后，调用形象的办法，没有意义。

案例需要：

某 IT 公司有多名员工，依照员工负责的工作不同，进行了部门的划分（研发部员工、保护部员工）。研发部依据所需研发的内容不同，又分为 JavaEE 工程师、Android 工程师；保护部依据所需保护的内容不同，又分为网络保护工程师、硬件保护工程师。

公司的每名员工都有他们本人的员工编号、姓名，并要做它们所负责的工作。

工作内容:

JavaEE 工程师：员工号为 xxx 的 xxx 员工，正在研发淘宝网站
Android 工程师：员工号为 xxx 的 xxx 员工，正在研发淘宝手机客户端软件
网络保护工程师：员工号为 xxx 的 xxx 员工，正在查看网络是否畅通
硬件保护工程师：员工号为 xxx 的 xxx 员工，正在修复打印机

请依据形容，实现员工体系中所有类的定义，并指定类之间的继承关系。进行 XX 工程师类的对象创立，实现工作办法的调用。

案例剖析：

根据上述部门的形容，得出如下的员工体系图

依据员工信息的形容，确定每个员工都有员工编号、姓名、要进行工作。则把这些独特的属性与性能抽取到父类中（员工类），对于工作的内容由具体的工程师来进行指定。

工作内容:

JavaEE 工程师：员工号为 xxx 的 xxx 员工，正在研发淘宝网站
Android 工程师：员工号为 xxx 的 xxx 员工，正在研发淘宝手机客户端软件
网络保护工程师：员工号为 xxx 的 xxx 员工，正在查看网络是否畅通
硬件保护工程师：员工号为 xxx 的 xxx 员工，正在修复打印机

创立 JavaEE 工程师对象，实现工作办法的调用。

实现代码：

员工类：Employee

public abstract class Employee {
    private String id;// 员工编号
    private String name; // 员工姓名

    public String getId() {returnid;}
    publicvoid setId(String id) {this.id = id;}
    public String getName() {returnname;}
    publicvoid setName(String name) {this.name = name;}
    
    // 工作办法（形象办法）public abstract void work();}

定义研发部员工类 Developer 继承员工类 Employee

public abstract class Developer extends Employee {}

定义保护部员工类 Maintainer 继承员工类 Employee

public abstract class Maintainer extends Employee {}

定义 JavaEE 工程师继承研发部员工类，重写工作办法

public class JavaEE extends Developer {
    @Override
    public void work() {System.out.println("员工号为" + getId() + "的" + getName() + "员工，正在研发淘宝网站");
    }
}

定义 Android 工程师继承研发部员工类，重写工作办法

public class Android extends Developer {
    @Override
    public void work() {System.out.println("员工号为" + getId() + "的" + getName() + "员工，正在研发淘宝手机客户端软件");
    }
}

定义 Network 网络保护工程师继承保护部员工类，重写工作办法

public class Network extends Maintainer {
    @Override
    public void work() {System.out.println("员工号为" + getId() + "的" + getName() + "员工，正在查看网络是否畅通");
    }
}

定义 Hardware 硬件保护工程师继承保护部员工类，重写工作办法

public class Hardware extends Maintainer {
    @Override
    public void work() {System.out.println("员工号为" + getId() + "的" + getName() + "员工，正在修复打印机");
    }
}

在测试类中，创立 JavaEE 工程师对象，实现工作办法的调用

public class Test {public static void main(String[] args) {
        // 创立 JavaEE 工程师员工对象
        JavaEE ee = new JavaEE();
        // 设置该员工的编号
        ee.setId("000015");
        // 设置该员工的姓名
        ee.setName("小明");
        // 调用该员工的工作办法
        ee.work();}
}

关于java:JavaSE第10篇面向对象之继承

第一章：继承

1.1- 继承概述（理解）

1.2- 继承的格局（记忆）

1.3-super 关键字（记忆）

1.4-super 和 this 关键字（了解）

1.5- 子类可重写父类办法（了解）

1.6- 子类的初始化过程（了解）

1.7- 继承的特点（了解）

第二章：抽象类

2.1- 抽象类概述（理解）

2.2- 抽象类、形象办法的定义和应用（记忆）

2.3- 注意事项（理解）

第三章：综合案例

Just My Socks（注册教程内含优惠码）

关于java:JavaSE第10篇面向对象之继承

第一章：继承

1.1- 继承概述（理解）

1.2- 继承的格局（记忆）

1.3-super 关键字（记忆）

1.4-super 和 this 关键字（了解）

1.5- 子类可重写父类办法（了解）

1.6- 子类的初始化过程（了解）

1.7- 继承的特点（了解）

第二章：抽象类

2.1- 抽象类概述（理解）

2.2- 抽象类、形象办法的定义和应用（记忆）

2.3- 注意事项（理解）

第三章：综合案例

Just My Socks（注册教程 内含优惠码）

Just My Socks（注册教程内含优惠码）