zoukankan      html  css  js  c++  java

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

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

    　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　作者：尹正杰

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

    一.继承的概述

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

     

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

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

    1>.什么是父类和子类

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

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

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

     1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 
 8 //定义员工类：成员变量（name），成员方法（work）
 9 public class Employee {
10     String name;
11     
12     public void work(){
13         System.out.println("员工在工作.....");
14     }
15 }
    Employee.java 文件内容
     1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 //定义研发部员工，属于员工中的一种，研发员工继承员工类，使用关键字extends。
 8 public class Development extends Employee{
 9     public void print(){
10         System.out.println(name);
11     }
12 }
    Development.java 文件内容
     1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 public class Test {
 8     public static void main(String[] args){
 9         Development d = new Development();
10         d.name = "yinzhengjie";
11         d.print();
12     }
13 }

    3>.继承的好处

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

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

    4>.继承的注意事项

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

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

     

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

    5>.继承的体系

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

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

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

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

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

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

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

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

    1 /*
2 @author :yinzhengjie
3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
4 EMAIL:y1053419035@qq.com
5 */
6 
7 public class Father {
8     int age = 40;
9 }
    Father.java 文件内容
     1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 public class Son extends Father {
 8     int age = 18;        //该变量存在与堆内存中。
 9     
10     public void print() {
11         int age = 20;    //该变量随着方法弹栈执行，因此改变量存在栈内存。
12         System.out.println("当前作用域的age变量的值为："+age);
13         System.out.println("本类中成员变量age的值为："+this.age);
14         System.out.println("父类中成员变量age的值为："+super.age);
15     }
16 }
    Son.java 文件内容
     1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 public class Test {
 8     public static void main(String[] args){
 9         Son s = new Son();
10         s.print();
11     }
12 }
13 
14 
15 
16 /*
17 以上代码此时结果如下：
18 当前作用域的age变量的值为：20
19 本类中成员变量age的值为：18
20 父类中成员变量age的值为：40
21 */
    Test.java 文件内容

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

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

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

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

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

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

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

     1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 public class Father {
 8     public void print() {
 9         System.out.println("父类的print()方法！");
10     }
11 }
    Father.java 文件内容
     1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 public class Son extends Father {
 8     public void print() {
 9         System.out.println("子类的print()方法！");
10     }
11 }
    Son.java 文件内容
     1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 public class Test {
 8     public static void main(String[] args){
 9         Son s = new Son();
10         s.print();
11     }
12 }
13 
14 
15 
16 /*
17 以上代码此时结果如下：
18 子类的print()方法！
19 */
    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>.雇员示例

    需求：

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

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

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

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

     1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 //雇员抽象类，定义：姓名，工号，薪水
 8 public abstract class Employee{
 9     private String name;
10     private String id;
11     private int salary;
12     
13     public void setName(String name){
14         this.name = name;
15     }
16     public String getName(){
17         return name;
18     }
19     public void setId(String id){
20         this.id = id;
21     }
22     public String getId(){
23         return id;
24     }
25     public void setSalary(int salary){
26         this.salary = salary;
27     }
28     public int getSalary(){
29         return salary;
30     }
31     
32     public void show(){
33         System.out.printf("姓名：%s
工号：%s
薪资：%d
",name,id,salary);
34     }
35     
36     //抽象方法work
37     public abstract void work();
38 }
    Employee.java 抽象类定义
     1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6     
 7 //项目经理类
 8 public class Manager extends Employee{
 9     //奖金
10     private int money;
11     public void setMoney(int money){
12         this.money = money;
13     }
14     public int getMoney(){
15         return money;
16     }
17     //重写show方法
18     public void show(){
19         System.out.printf("姓名：%s
工号：%s
薪资：%d
奖金：%d
",getName(),getId(),getSalary(),getMoney());
20     }
21     
22     //实现抽象方法
23     public void work(){
24         System.out.println("项目经理开会...");
25     }
26 }
    Manager.java 子类定义
     1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 //程序员类
 8 public class Programmer extends Employee{
 9     //实现抽象方法
10     public void work(){
11         System.out.println("程序员写代码...");
12     }
13 }
    Programmer.java 子类定义
     1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 //雇员测试类
 8 public class EmployeeDemo{
 9     public static void main(String[] args){
10         Programmer p = new Programmer();
11         p.setName("tom");
12         p.setId("9527");
13         p.setSalary(8000);
14         p.show();    //调用的是抽象类（Employee）的方法
15         p.work();    //调用的是程序员类(Programmer)实现抽象方法的方法
16         
17         Manager m = new Manager();
18         m.setName("John");
19         m.setId("0001");
20         m.setSalary(7000);
21         m.setMoney(8000);
22         m.show();    //调用的是项目经理类（Manager）重写的方法
23         m.work();    //调用的是项目经理类（Manager）实现抽象方法的方法
24     }
25 }
26 
27 
28 
29 /*
30 以上代码测试结果如下：
31 姓名：tom
32 工号：9527
33 薪资：8000
34 程序员写代码...
35 姓名：John
36 工号：0001
37 薪资：7000
38 奖金：8000
39 项目经理开会...
40 */
    EmployeeDemo.java 测试类文件内容

    b>.抽象类作为形参

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

     1 /*
 2 @author :yinzhengjie
 3 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 4 EMAIL:y1053419035@qq.com
 5 */
 6 
 7 //定义一个抽象类A
 8 abstract class A{
 9     public abstract void show();
10 }
11 //子类B继承抽象类A
12 class B extends A{
13     //子类B实现父类的抽象方法
14     public void show(){
15         System.out.println("B.show()...");
16     }
17 }
18 //子类C继承抽象类A
19 class C extends A{
20     //子类C实现父类的抽象方法
21     public void show(){
22         System.out.println("C.show()...");
23     }
24 }
25 //定义将抽象类A作为形参的类
26 class ParameterAbstract{
27     public void ParameterAbstract(A a){
28         //此时需要传入的参数是此抽象类的实现类的一个对象,也就是说，此时的a一定是一个A的子类对象,
29         a.show();
30     }
31     public A getA(){
32         B b = new B();
33         //实际上返回的是此抽象类子类的一个对象
34         return b;    
35     }
36 }
37 
38 public class AbstractDemo{
39     public static void main(String[] args){
40         B b = new B();
41         //用匿名对象的方式调用ParameterAbstract方法，传入的参数是抽象类实现子类的一个对象
42         new ParameterAbstract().ParameterAbstract(b);
43         
44         C c = new C();
45         ParameterAbstract t = new ParameterAbstract();
46         //调用ParameterAbstract类的构造方法
47         t.ParameterAbstract(c);
48     }
49 }
50 
51 
52 
53 
54 /*
55 以上代码执行结果如下：
56 B.show()...
57 C.show()...
58 */

    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>.调用方法不同

    　　　静态变量可以通过类名和对象名两名方式调动，推荐使用类名调用实例变量只能使用对象名的方式调用。
  • 相关阅读:
    网站后台编辑器怎样才能兼容IE6、IE8
    map area
    纯CSS圆角
    【转】Linux 查看某一进程的占用CPU的Cacti 脚本
    查看/修改Linux时区和时间，更新系统时间
    Centos下安装X Window+GNOME Desktop+FreeNX
    rhel6 kvm做桥接
    Gentoo网络配置
    常用正则表达式
    VS 设置备忘
  • 原文地址：https://www.cnblogs.com/yinzhengjie/p/8784602.html
Copyright © 2011-2022 走看看