Java基础-面向对象第二特征之继承（Inheritance）

　　　　　　　　　　　　Java基础-面向对象第二特征之继承（Inheritance）

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　作者：尹正杰

版权声明：原创作品，谢绝转载！否则将追究法律责任。

一.继承的概述

　在现实生活中，继承一般指的是子女继承父辈的财产。在程序中，继承描述的是事物之间的所属关系，通过继承可以使多种事物之间形成了一种关系体系。例如公司中的研发部员工，运维部员工，人事部员工都属于员工，程序中便可以描述为研发部员工和维护部员工继承自员工，同理，JavaEE工程师和Python工程师继承自研发部员工，而网络运维工程师和系统运维工程师继承自维护部员工，人事部经理和培训专员继承自人事部员工。这些员工之间会形成一个继承体系，具体如下图所示：

　　在Java中，类的继承是指在一个现有的基础上去构建一个新的类，构建出来的新类被称作子类，现有类被称作父类，子类会自动拥有父类所有可继承的属性和方法。

二.继承的使用方式（extends）

1>.什么是父类和子类

　　多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要从抽取出来的那个类扩展（extends）即可，需要扩展的类称为子类（也叫派生类），抽取出来的那个类称为父类（也可以叫超类或者基类）。

2>.继承的定义格式和使用

　　继承一个类使用关键字extends来实现，格式为："class 子类 extends 父类{}",下面有一个很简单的继承案例，如下：

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:[e-mail]
 */

 //定义员工类：成员变量（name），成员方法（work）
 public class Employee {
     String name;

     public void work(){
         System.out.println("员工在工作.....");
     }
 }

Employee.java 文件内容

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:[e-mail]
 */

 //定义研发部员工，属于员工中的一种，研发员工继承员工类，使用关键字extends。
 public class Development extends Employee{
     public void print(){
         System.out.println(name);
     }
 }

Development.java 文件内容

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:[e-mail]
 */

 public class Test {
     public static void main(String[] args){
         Development d = new Development();
         d.name = "yinzhengjie";
         d.print();
     }
 }

3>.继承的好处

　　a>.继承的出现提高了代码的复用性，提高了软件开发效率；

　　b>.继承的出现让类与类之间产生了关系，提供了多态的前提（多态本篇博客暂时不涉及）。

4>.继承的注意事项

　　a>.在Java中，类只支持单继承，不允许多继承，也就是说一个类只能有一个直接父类，不可以有多个父类。

　　b>.Java支持多层继承，多重继承（在Java中，子类和父类是一种相对概念，也就是说一个类是某个父类的同时，也可以是另一个类的子类。例如：C类：同时拥有A和B的属性和方法；B类：只拥有A类属性和方法）

　　c>.多个类中可以继承一个父类。

5>.继承的体系

　　继承也有自己的体系，我们可以下面的一张图来说明特点。

6>.继承后子类父类成员变量的特点

　　子类的对象，在调用成员变量的时候遵循以下顺序：

　　　　a>.先在子类的方法中找(方法是压栈执行，里面的变量存在栈内存中，属于基本数据类型);

　　　　b>.再找子类的成员变量，子类自己有就使用自己的(类中的成员变量属于引用数据类型，成员变量存在堆内存中，需要用到关键字this)；

　　　　c>.最后再找父类的成员变量,子类没有的话就调用父类的（需要用到关键字super）；

　　　　d>.如果以上步骤都没有找到，就会编译报错！

　　说白了，就是遵循就近原则！下面的3个文件是我实际测试的代码。

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:[e-mail]
 */

 public class Father {
     int age = 40;
 }

Father.java 文件内容

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:[e-mail]
 */

 public class Son extends Father {
     int age = 18;        //该变量存在与堆内存中。

     public void print() {
         int age = 20;    //该变量随着方法弹栈执行，因此改变量存在栈内存。
         System.out.println("当前作用域的age变量的值为："+age);
         System.out.println("本类中成员变量age的值为："+this.age);
         System.out.println("父类中成员变量age的值为："+super.age);
     }
 }

Son.java 文件内容

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:[e-mail]
 */

 public class Test {
     public static void main(String[] args){
         Son s = new Son();
         s.print();
     }
 }

 /*
 以上代码此时结果如下：
 当前作用域的age变量的值为：20
 本类中成员变量age的值为：18
 父类中成员变量age的值为：40
 */

Test.java 文件内容

7>.子类重写父类方法(Overrride|Overwrite)

　　子类中，出现了和父类一模一样的方法（函数的返回值类型，函数名，参数列表都一样）的时候，子类重写父类的方法，也可以说是子类覆盖了父类的方法（当子类需要父类功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样即沿袭了父类的功能又定义了子类特有的内容。）。方法的重写是指两个类中的名词哟，而方法的重载指的的同一个类中的名词，大家不要混淆哟！

　　a>.子类中出现与父类一模一样的方法时，会出现覆盖操作，也称为重写或者复写；

　　b>.父类中私有方法不可以被重写，当然，私有方法也不能被继承；

　　c>.在子类重写方法中，继续使用被重写的方法可以通过super.方法名(...);

　　d>.覆盖注意事项：覆盖时，子类方法权限一定要大于父类方法权限；除了访问权限之外，其它部分和父类方法保持一致；静态只能覆盖静态。

　　方法重写是应该注意，子类方法覆盖父类方法，必须要保证权限大于等于父类权限。下面的三个文件就是一个简单的重写案例：

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:[e-mail]
 */

 public class Father {
     public void print() {
         System.out.println("父类的print()方法！");
     }
 }

Father.java 文件内容

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:[e-mail]
 */

 public class Son extends Father {
     public void print() {
         System.out.println("子类的print()方法！");
     }
 }

Son.java 文件内容

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:[e-mail]
 */

 public class Test {
     public static void main(String[] args){
         Son s = new Son();
         s.print();
     }
 }

 /*
 以上代码此时结果如下：
 子类的print()方法！
 */

Test.java 文件内容

　　总结：当一个类中是另一个类中的一种时，可以通继承，来继承属性和功能。如果父类具备的功能内容需要子类特殊定义时，进行方法重写。

8>.子类的实例化过程

　　a>.子类中所有的构造方法默认都会访问父类中空参构造的构造方法，因为每一个构造方法的第一行都有一条默认的语句super()，除非第一行用this或super显式调用了其它的构造方法；

　　b>.子类会具备父类中的数据，所以要先明确父类是如何对这些数据初始化的，也就是父类对象必须在子类对象初始化前完成初始化操作（没有父类，就没有子类）；

　　c>.当父类中没有空参构造方法时，子类的构造方法必须通过this或者super语句制定要访问的构造方法；

三.抽象类的使用方式（abstract）

1>.抽象类概述

a>.抽象定义

　　抽象就是从多个事物中将共性，本质的内容抽取出来（例如：狼和狗共性都是犬科，犬科就是抽象出来的概念）。

b>.抽象类

　　Java中可以定义没有方法体的方法，该方法的具体实现由子类完成，该方法称为抽象方法，包含抽象方法的类就是抽象类。

c>.抽象方法的由来

　　多个对象都具备相同的功能，但是功能具体内容有所不同，那么在抽取过程中，值抽取了功能定义，并未抽取功能主体，那么只有功能声明，没有功能主体的方法称为抽象方法。（例如：狼和狗都有吼叫的方法，可是吼叫的内容是不一样的，所以抽象出啦ID全科虽然有吼叫的功能，但是并不明确吼叫的细节。）

2>.抽象类的由来

　　如果在父类中定义一个各个子类都有不同实现的方法，那么子类需要重写这个方法，为什么父类还要定义这个方法呢？直接去掉不行么？答案是肯定的，去掉当然可以啊，只不过这样就没法使用多态啦！由于多态的要求：父类引用指向子类实例，但父类不能调用子类独有的方法，为了使用多态，父类中必须定义有这个方法，但是方法的实现又会被子类重写。

　　为了既能使用多态，又能省去在父类中现实的麻烦，Java提供了抽象方法，在父类中只定义方法签名，不用写方法的实现。

3>.抽象类的特点

　　a>.抽象类和抽象方法必须使用abstract关键字来修饰；

　　b>.抽象方法只有方法声明，没有方法体，定义在抽象类中（格式：“修饰符  abstract   返回值类型   方法名（形参列表）;”）；

　　c>.抽象类不可以被实例化，换句话说，就是抽象类不能用new 创建抽象类的对象（从理论上来说：抽象类是具体事物抽取出来的，本身是不具体的，没有对应的实例，例如：犬科是一种抽象的概念，真正存在的是狼和狗。从调用角度来说：假设抽象类可以创建对象，那么调用其抽象方法将变得毫无意义。）；

　　d>.抽象类通过子类实例化，如果子类继承了抽象类，重写了一部分的抽象方法，这个子类还是抽象类（换句话说，子类需要实现所有的抽象方法后才可以创建对象，否在该子类依然是抽象类）。

4>.抽象类的应用案例

a>.雇员示例

需求：

　　公司中程序员有姓名，工号，薪水，工作内容。

　　项目经理除了有姓名，工号，薪水，还有奖金，工作内容。

　　程序员和项目经理都是雇员，但是工作内容却不同，所以工作反方应该定义成抽象反方。

　　接下来，我们就来实现一下这个案例：

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:[e-mail]
 */

 //雇员抽象类，定义：姓名，工号，薪水
 public abstract class Employee{
     private String name;
     private String id;
     private int salary;

     public void setName(String name){
         this.name = name;
     }
     public String getName(){
         return name;
     }
     public void setId(String id){
         this.id = id;
     }
     public String getId(){
         return id;
     }
     public void setSalary(int salary){
         this.salary = salary;
     }
     public int getSalary(){
         return salary;
     }

     public void show(){
         System.out.printf("姓名：%s\n工号：%s\n薪资：%d\n",name,id,salary);
     }

     //抽象方法work
     public abstract void work();
 }

Employee.java 抽象类定义

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:[e-mail]
 */

 //项目经理类
 public class Manager extends Employee{
     //奖金
     private int money;
     public void setMoney(int money){
         this.money = money;
     }
     public int getMoney(){
         return money;
     }
     //重写show方法
     public void show(){
         System.out.printf("姓名：%s\n工号：%s\n薪资：%d\n奖金：%d\n",getName(),getId(),getSalary(),getMoney());
     }

     //实现抽象方法
     public void work(){
         System.out.println("项目经理开会...");
     }
 }

Manager.java 子类定义

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:[e-mail]
 */

 //程序员类
 public class Programmer extends Employee{
     //实现抽象方法
     public void work(){
         System.out.println("程序员写代码...");
     }
 }

Programmer.java 子类定义

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:[e-mail]
 */

 //雇员测试类
 public class EmployeeDemo{
     public static void main(String[] args){
         Programmer p = new Programmer();
         p.setName("tom");
         p.setId("9527");
         p.setSalary(8000);
         p.show();    //调用的是抽象类（Employee）的方法
         p.work();    //调用的是程序员类(Programmer)实现抽象方法的方法

         Manager m = new Manager();
         m.setName("John");
         m.setId("0001");
         m.setSalary(7000);
         m.setMoney(8000);
         m.show();    //调用的是项目经理类（Manager）重写的方法
         m.work();    //调用的是项目经理类（Manager）实现抽象方法的方法
     }
 }

 /*
 以上代码测试结果如下：
 姓名：tom
 工号：9527
 薪资：8000
 程序员写代码...
 姓名：John
 工号：0001
 薪资：7000
 奖金：8000
 项目经理开会...
 */

EmployeeDemo.java 测试类文件内容

b>.抽象类作为形参

　　抽象类作为形参，此时需要传入的参数是此抽象类实现的一个对象。抽象类作为返回值类型，实际上返回的是此抽象类子类的一个对象。下面的简单的代码实现：

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:[e-mail]
 */

 //定义一个抽象类A
 abstract class A{
     public abstract void show();
 }
 //子类B继承抽象类A
 class B extends A{
     //子类B实现父类的抽象方法
     public void show(){
         System.out.println("B.show()...");
     }
 }
 //子类C继承抽象类A
 class C extends A{
     //子类C实现父类的抽象方法
     public void show(){
         System.out.println("C.show()...");
     }
 }
 //定义将抽象类A作为形参的类
 class ParameterAbstract{
     public void ParameterAbstract(A a){
         //此时需要传入的参数是此抽象类的实现类的一个对象,也就是说，此时的a一定是一个A的子类对象,
         a.show();
     }
     public A getA(){
         B b = new B();
         //实际上返回的是此抽象类子类的一个对象
         return b;
     }
 }

 public class AbstractDemo{
     public static void main(String[] args){
         B b = new B();
         //用匿名对象的方式调用ParameterAbstract方法，传入的参数是抽象类实现子类的一个对象
         new ParameterAbstract().ParameterAbstract(b);

         C c = new C();
         ParameterAbstract t = new ParameterAbstract();
         //调用ParameterAbstract类的构造方法
         t.ParameterAbstract(c);
     }
 }

 /*
 以上代码执行结果如下：
 B.show()...
 C.show()...
 */

5>.抽象类的细节

　　a>.抽象类可以不可以不包含任何抽象方法？

　　　　答：可以，此时这个类的作用就是不让外界实例化。

　　b>.抽象类能否有构造方法？

　　　　答：抽象类中可以有成员变量，而构造方法的作用就是对成员变量初始化的，所以，可以有构造方法。

　　c>.抽象类关键字abstract不可以和那些关键字共存？

　　　　答：第一个关键字是final（final方法不能被子类重写，而抽象反方就是需要子类重写的，两者冲突）；第二个关键字是static（静态可以通过类名调用，但是本类中并没有真正的反方体）；第三个关键字是private（私有的方法子类访问不到，无法实现）。

四.面向对象常用的关键字介绍

1>.final

　　继承的出现提高了代码的复用性，并方便开发。但随之也有问题，有些类在描述之后，不想被继承，或者有些类中的部分方法功能是固定的，不想让子类重写。可是当子类继承了这些特殊类之后，就可以对其中的方法进行重写，那怎么解决呢？

　　要解决上述的这些问题，需要使用到一个关键字final，final的意思为最终，不可变。final是个修饰符，它可以用来修饰类，类的成员（不包括构造方法），以及局部变量。

　　a>.final修饰类则为最终类，即不可以被继承，但是可以继承其它类。

　　b>.final修饰的方法不可以被覆盖，但父类中没有被final修饰方法，子类覆盖（重写）后可以加final。

　　c>.final修饰的变量称为常量，这些变量只能赋值一次。

　　d>.final修饰的引用类型的变量值为对象地址值，地址值就不能更改，但是地址对象的属性可以修改；

　　e>.final修饰成员变量，需要在创建对象前赋值，否则报错（构造方法，是创建对象中的事情，可以为成员变量赋值，set方法是创建对象之后的事情，不能为final修饰的成员变量赋值哟！）；

2>.this

　作用：this代表当前正在调用方法的对象

　使用场景：　a>.setXxx方法中对成员变量赋值：区分成员变量和局部变量；

　　　　　　　b>.构造方法互相调用（注意：构造方法中使用this或者super调用其它构造方法的话必须是构造方法的第一条语句）;

　　　　　　　c>.方法中调用本类其它方法（“this(....);”）；

3>.super

　　super和this的用法类似，this代表本类对象的引用，super代表父类对象的内存的标识

　　使用场景：a>.子父类出现同名成员时，用super进行区分（“super.成员变量”或者“super.成员方法()”）；

　　　　　　    b>.子类使用super调用父类的构造方法（“super(....);”）

4>.static

　　在定义类的时候，类中都会有相应的属性和方法。而属性和方法都是通过创建本类对象调用的。当在调用对象的某个方法，这个方法没有访问到对象的特有数据时，方法创建这个对象有些多余。可是不创建对象，方法又调用不了，这是就会想，那么我们能不能不创建对象，就可以调用方法呢？

　　可以的，我们可以通过关键字static来实现，static它是静态修饰符，一般用来修饰类中的成员。

　　a>.被static修饰的成员变量属于类（随着类的加载而加载），不属于这个类的某个对象（也就是说，多个对象在访问或修改static修饰的成员变量时，其中一个对象将static成员变量值进行了修改，其它对象中的static成员变量值跟着改变，即多个对象共享同一个static成员变量，这时被static修饰的成员变量并不在堆中，而是在方法区中保存）；

　　b>.被static修饰的成员可以直接通过类名的方式访问；

　　c>.优先与对象存在（也就是说用static修饰的方法不能直接调用非静态的方法，如果你非要在静态方法中调用非静态方法，那就只能现在静态方法中创建一个对象，然后通过调用对象中的方法的形式调用非静态方法）；

　　d>.静态方法中不能写this也不能写super；

　　f>.静态方法只能访问静态成员（变量，方法），当然静态方法也可以间接访问非静态方法（需要现在静态中new出来一个对象，通过对象调用相应的方法即可），非静态的方法可以访问静态成员；

　　g>.被这个类的所有对象共享；

　　什么时候使用static呢？推荐方式：如果方法没有调用过非静态成员，建议将方法定义为静态！

5>.静态变量和实例变量的区别

　　a>.所属不同

　　　　静态变量属于类，也称为类变量。实例变量属于对象，也称为对象（实例）变量。

　　b>.在内存中的位置不同

　　　　静态变量在方法区中的静态区，实例变量在堆内存。

　　c>.生命周期不同

　　　　静态变量随着类的加载而加载，随着类的消失而消失，实例变量随着对象的创建而存在，随着对象的消失而消失。

　　d>.调用方法不同

　　　静态变量可以通过类名和对象名两名方式调动，推荐使用类名调用实例变量只能使用对象名的方式调用。