前言本文主要多方面讲解java继承,旨在让初学者通俗易懂,至于“我爸是李刚”,反正楼主也不知道谁爸是李刚。@[toc]

1、继承的概述

1.1、继承的由来

至于由来简单一句话:多个类中存在相同属性和行为时,将这些内容抽取到单独一个类中,那么多个类无需再定义这些属性和行为。

继承描述的是事物之间的所属关系,这种关系是 is-a 的关系。

1.2、继承的定义

继承:就是子类继承父类的属性行为,使得子类对象具有与父类相同的属性、相同的行为。子类可以直接访问父类中的非私有的属性和行为。

这里再声明一点,<font color=red>父类</font>又称为<font color=red>超类</font>或者<font color=red>基类</font>。而<font color=red>子类</font>又称为<font color=red>派生类</font>这点很基础!

1.3、继承的优点

  1. 提高代码的复用性
  2. 类与类之间产生关系,为多态做了完美的铺垫(不理解没关系,之后我会再写一篇多态的文章)

1.4、继承的格式

通过 extends 关键字,可以声明一个子类继承另外一个父类,定义格式如下:

  class 父类 {
   ...
   }
   class 子类 extends 父类 {
   ...
   }

2、关于继承之后的成员变量

当类之间产生了关系后,其中各类中的成员变量,产生了哪些影响呢? 关于继承之后的成员变量要从两方面下手,一是成员变量不重名方面,二是成员变量重名方面。

2.1、成员变量不重名

如果子类父类中出现不重名的成员变量,这时的访问是没有影响的。代码如下:

  class liGang {
        // 父类中的成员变量。
       String name ="李刚";//------------------------------父类成员变量是name
    }
    class LiXiaoGang extends liGang {
        // 子类中的成员变量
        String name2 ="李小刚";//--------------------------子类成员变量是name2
        // 子类中的成员方法
        public void show() {
            // 访问父类中的name,
            System.out.println("我爸是"+name);
            // 继承而来,所以直接访问。
            // 访问子类中的name2
            System.out.println("我是"+name2);
        }
    }
public class Demo {
        public static void main(String[] args) {
            // 创建子类对象
            LiXiaoGang z = new LiXiaoGang();
            // 调用子类中的show方法
            z.show();
        }
    }
    //演示结果: 我爸是李刚   我是李小刚

2.2、 成员变量重名

如果子类父类中出现重名的成员变量,这时的访问是有影响的。代码如下:

class liGang {
        // 父类中的成员变量。
       String name ="李刚";//------------------------------父类成员变量是name
    }
    class LiXiaoGang extends liGang {
        // 子类中的成员变量
        String name ="李小刚";//---------------------------子类成员变量也是name
        // 子类中的成员方法
        public void show() {
            // 访问父类中的name,
            System.out.println("我爸是"+name);
            // 继承而来,所以直接访问。
            // 访问子类中的name2
            System.out.println("我是"+name);
        }
    }
public class Demo {
        public static void main(String[] args) {
            // 创建子类对象
            LiXiaoGang z = new LiXiaoGang();
            // 调用子类中的show方法
            z.show();
        }
    }
    //演示结果: 我爸是李小刚   我是李小刚


子父类中出现了同名的成员变量时,在子类中需要访问父类中非私有成员变量时,需要使用 super 关键字,至于修饰父类成员变量,类似于之前学过的 this 。 使用格式 super.父类成员变量名

class liGang {
        // 父类中的成员变量。
       String name ="李刚";
    }
    class LiXiaoGang extends liGang {
        // 子类中的成员变量
        String name ="李小刚";
        // 子类中的成员方法
        public void show() {
            // 访问父类中的name,
            System.out.println("我爸是"+super.name);
            // 继承而来,所以直接访问。
            // 访问子类中的name2
            System.out.println("我是"+this.name);  //当然this可省略
        }
    }
public class Demo {
        public static void main(String[] args) {
            // 创建子类对象
            LiXiaoGang z = new LiXiaoGang();
            // 调用子类中的show方法
            z.show();
        }
    }
    //演示结果: 我爸是李刚   我是李小刚

2.3、关于继承中成员变量值得思考的一个问题

同学你有没有想过这样一个问题。如果父类中的成员变量非私有:子类中可以直接访问。私有:子类是不能直接访问的。如下:【java基础】java继承从“我爸是李刚”讲起-LMLPHP当然,同学你要自己体验体验编译报错过程,看图没体验感不得劲,~呕,你这无处安放的魅力,无理的要求,我佛了,行吧~

  class liGang2 {
        // 父类中的成员变量。
        private String name ="李刚";

    }
    class LiXiaoGang2 extends liGang2 {
        // 子类中的成员变量
        String name ="李小刚";
        // 子类中的成员方法
        public void show() {
            // 访问父类中的name,
            System.out.println("我爸是"+super.name);//------编译失败不能直接访问父类私有属性(成员变量)
            // 继承而来,所以直接访问。
            // 访问子类中的name2
            System.out.println("我是"+this.name);  //当然this可省略
        }
    }
public class PrivateVariable {
        public static void main(String[] args) {
            // 创建子类对象
            ExtendDemo.LiXiaoGang z = new ExtendDemo.LiXiaoGang();
            // 调用子类中的show方法
            z.show();
        }
    }

通常开发中编码时,我们遵循封装的原则,使用private修饰成员变量,那么如何访问父类的私有成员变量呢?其实这个时候在父类中提供公共的getXxx方法和setXxx方法就可以了。代码如下:

class liGang {
        // 父类中的成员变量。
      private String name ="李刚";

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }
    }
    class LiXiaoGang extends liGang {
        // 子类中的成员变量
        String name ="李小刚";
        // 子类中的成员方法
        public void show() {
            // 访问父类中的name,
            System.out.println("我爸是"+super.getName());
            // 继承而来,所以直接访问。
            // 访问子类中的name2
            System.out.println("我是"+this.name);  //当然this可省略
        }
    }
public class Demo {
        public static void main(String[] args) {
            // 创建子类对象
            LiXiaoGang z = new LiXiaoGang();
            // 调用子类中的show方法
            z.show();
        }
    }
    //演示结果: 我爸是李刚   我是李小刚

分析如下:【java基础】java继承从“我爸是李刚”讲起-LMLPHP

3、关于继承之后的成员方法

分析完了成员变量,现在我们一起来分析分析成员方法。想一想,当类之间产生了关系,其中各类中的成员方法,又产生了哪些影响呢? 同样我们依旧从两方面分析。

3.1、成员方法不重名

如果子类父类中出现不重名的成员方法,这时的调用是没有影响的。对象调用方法时,会先在子类中查找有没有对 应的方法,若子类中存在就会执行子类中的方法,若子类中不存在就会执行父类中相应的方法。代码如下:

 class liGang3 {
        // 父类中的成员方法。
       public void zhuangRen1(){//--------------------------父类方法名zhuangRen1
           System.out.println("我叫李刚,人不是我撞的,别抓我,我不认识李小刚");
       }
    }
    class LiXiaoGang3 extends liGang3 {

        // 子类中的成员方法
        public void zhuangRen() {//--------------------------子类方法名zhuangRen
            System.out.println("有本事你们告去,我爸是李刚");
        }
    }
    public class MemberMethod {
        public static void main(String[] args) {
            // 创建子类对象
            LiXiaoGang3 liXiaoGang = new LiXiaoGang3();
            // 调用子类中的show方法
            liXiaoGang.zhuangRen();
            liXiaoGang.zhuangRen1();
        }
    }

打印结果:有本事你们告去,我爸是李刚
        我叫李刚,人不是我撞的,别抓我,我不认识李小刚

【java基础】java继承从“我爸是李刚”讲起-LMLPHP

3.2、成员方法重名 【方法重写】

成员方法重名大体也可以分两种情况:

这里主要讲方法重写 :子类中出现与父类一模一样的方法时(返回值类型,方法名和参数列表都相同),会出现<font color=red>覆盖</font>效果,也称为<font color=red>重写</font>或者<font color=red>复写</font>。声明不变,重新实现。 代码如下:

    class liGang3 {
        // 父类中的成员方法。
       public void zhuangRen(int a){
           System.out.println("我叫李刚,人不是我撞的,别抓我");
       }
    }
    class LiXiaoGang3 extends liGang3 {

        // 子类中的成员方法
        public void zhuangRen(int a) {
            System.out.println("有本事你们告去,我爸是李刚");
        }
    }
    public class MemberMethod {
        public static void main(String[] args) {
            // 创建子类对象
            LiXiaoGang3 liXiaoGang = new LiXiaoGang3();
            // 调用子类中的zhuangRen方法
            liXiaoGang.zhuangRen(1);

        }
    }
    结果打印:有本事你们告去,我爸是李刚

3.3、继承中重写方法的意义

子类可以根据需要,定义特定于自己的行为。既沿袭了父类的功能名称,又根据子类的需要重新实现父类方法,从而进行扩展增强。比如李刚会开车,李小刚就牛了,在父类中进行扩展增强还会开车撞人,代码如下:

 class liGang3 {
        // 父类中的成员方法。
       public void kaiChe(){
           System.out.println("我会开车");
       }
    }
    class LiXiaoGang3 extends liGang3 {
        // 子类中的成员方法
        public void kaiChe(){
            super.kaiChe();
            System.out.println("我还会撞人");
            System.out.println("我还能一撞撞俩婆娘");
        }
    }
    public class MemberMethod {
        public static void main(String[] args) {
            // 创建子类对象
            LiXiaoGang3 liXiaoGang = new LiXiaoGang3();
            // 调用子类中的zhuangRen方法
            liXiaoGang.kaiChe();

打印结果:   我会开车
		   我还会撞人
		   我还能一撞撞俩婆娘
        }
    }

不知道同学们发现了没有,以上代码中在子类中使用了 super.kaiChe();super.父类成员方法,表示调用父类的成员方法。

下面以修饰权限为例,如下:

【java基础】java继承从“我爸是李刚”讲起-LMLPHP

4、关于继承之后的构造方法

为了让你更好的体会,首先我先编写一个程序

   class liGang4 {
        // 父类的无参构造方法。
        public liGang4(){
            System.out.println("父类构造方法执行了。。。");
        }
    }
    class LiXiaoGang4 extends liGang4 {
        // 子类的无参构造方法。
       public LiXiaoGang4(){
           System.out.println("子类构造方法执行了====");
       }
    }
    public class ConstructionDemo {
        public static void main(String[] args) {
            // 创建子类对象
            LiXiaoGang4 z = new LiXiaoGang4();

        }
    }

用一分钟猜想一下结果是什么,猜好了再看下面结果:

父类构造方法执行了。。。
子类构造方法执行了====

好了,看了结果之后,你可能有疑惑。父类构造器方法怎么执行了?我们先来分析分析,首先在main方法中实例化了子类对象,接着会去执行子类的默认构造器初始化,这个时候在构造方法中默认会在<font color=red>第一句代码</font>中添加super();没错,他就是开挂般的存在,不写也存在的!有的调~读四声“跳”~皮的同学就会说,你说存在就存在啊,无凭无据 ~呀,你这个该死的靓仔~ 如下:【java基础】java继承从“我爸是李刚”讲起-LMLPHP构造方法的名字是与类名一致的,所以子类是无法继承父类构造方法的。 构造方法的作用是初始化成员变量的。所以子类的初始化过程中,必须先执行父类的初始化动作。子类的构造方法中默认会在<font color=red>第一句代码</font>中添加super(),表示调用父类的构造方法,父类成员变量初始化后,才可以给子类使用。

当然我已经强调很多遍了 super() 不写也默认存在,而且只能是在第一句代码中,不在第一句代码中行不行,答案是当然不行,这样会编译失败,如下:【java基础】java继承从“我爸是李刚”讲起-LMLPHP

5、关于继承的多态性支持的例子

直接上代码了喔

class A{
    public String show(C obj) {
        return ("A and C");
    }

    public String show(A obj) {
        return ("A and A");
    }

}
class B extends A{
    public String show(B obj) {
        return ("B and B");
    }
}
class C extends B{
    public String show(A obj) {
        return ("A and B");
    }
}
public class Demo1 {
    public static void main(String[] args) {
        A a=new A();
        B b=new B();
        C c=new C();
        System.out.println("第一题 " + a.show(a));
        System.out.println("第二题 " + a.show(b));
        System.out.println("第三题 " + a.show(c));
    }
}
运行结果:
        第一题 A and A
        第二题 A and A
        第三题 A and C

其实吧,第一题和第三题都好理解,第二题就有点意思了,会发现A类中没有B类型这个参数,这个时候,你就应该知道子类继承就是父类,换句话说就是子类天然就是父类,比如中国人肯定是人,但是人不一定是中国人(可能是火星人也可能是非洲人),所以<font color=red>父类做为参数类型,直接传子类的参数进去是可以的</font>,反过来,子类做为参数类型,传父类的参数进去,就需要强制类型转换。

6、super与this的用法

了解他们的用法之前必须明确一点的是<font color=red>父类空间优先于子类对象产生 </font>

在每次创建子类对象时,先初始化父类空间,再创建其子类对象本身。目的在于子类对象中包含了其对应的父类空间,便可以包含其父类的成员,如果父类成员非private修饰,则子类可以随意使用父类成员。代码体现在子类的构 造方法调用时,一定先调用父类的构造方法。理解图解如下:【java基础】java继承从“我爸是李刚”讲起-LMLPHP

5.1、 super和this的含义:

5.2、 super和this访问成员

5.3、super和this访问构造方法

5.4、super()和this()能不能同时使用?

不能同时使用,thissuper不能同时出现在一个构造函数里面,因为this必然会调用其它的构造函数,其它的构造函数必然也会有super语句的存在,所以在同一个构造函数里面有相同的语句,就失去了语句的意义,编译器也不会通过。

5.5、总结一下super与this

到这里,java继承你get到了咩,get到了请咩一声,随便随手~点个赞呗~

推荐阅读本专栏的下一篇java文章

【java基础之多态】理解多态的向上向下转型从“妈妈我想吃烤山药”讲起

欢迎各位关注我的公众号,一起探讨技术,向往技术,追求技术...

【java基础】java继承从“我爸是李刚”讲起-LMLPHP

11-09 12:00