Java中继承的定义与使用

Java 同时被 2 个专栏收录
70 篇文章 2 订阅
53 篇文章 2 订阅

1.继承

继承的主要作用在于,在已有基础上继续进行功能的扩充。
若没有继承:

class Person {
    private String name;
    private int age;
    public String getName()
    {
        return name;
    }
    public void setName(String name)
    {
        this.name=name;
    }
    public int getAge()
    {
        return age;
    }
    public void setAge(int age)
    {
        this.age=age;
    }
}
class Student {
    private String name;
    private int age;
    private String schoolName;
    public String getName()
    {
        return name;
    }
    public void setName(String name)
    {
        this.name=name;
    }
    public int getAge()
    {
        return age;
    }
    public void setAge(int age)
    {
        this.age=age;
    }
    public String getSchoolName()
    {
        return schoolName;
    }
    public void setSchoolName(String schoolName)
    {
        this.schoolName=schoolName;
    }
}

  以上是我们定义类的方式,含有大量重复的代码,java语言一般不允许大量重复的代码出现,这段代码不仅从代码上重复,而且从概念上讲学生一定是人,只是学生类描述的范围小,具备更多的属性和方法,这个时候想要消除结构定义上的重复,就要用到继承。

1.1 继承的实现

在Java中,继承用extends关键字来实现,语法:class 子类 extends 父类{}
所以可将上述代码改为:

class Person {
    private String name;
    private int age;
    public String getName()
    {
        return name;
    }
    public void setName(String name)
    {
        this.name=name;
    }
    public int getAge()
    {
        return age;
    }
    public void setAge(int age)
    {
        this.age=age;
    }
}
class Student extends Person{ 
}
public class Test2{
    public static void main(String[] args)
    {
        Student student=new Student();
        student.setName("花花");
        student.setAge(18);
        System.out.println("姓名:"+student.getName()+"  年龄:"+student.getAge());
    }
}

在这里插入图片描述
  通过以上代码可以发现,当发生了类继承关系之后,子类可以直接继承父类的操作,可以实现代码的重用,子类最低也维持和父类相同的功能。
  子类也可以进行功能上的扩充。

class Person {
    private String name;
    private int age;
    public String getName()
    {
        return name;
    }
    public void setName(String name)
    {
        this.name=name;
    }
    public int getAge()
    {
        return age;
    }
    public void setAge(int age)
    {
        this.age=age;
    }
}
class Student extends Person{
    private String schoolName;
    public String getSchoolName()
    {
        return schoolName;
    }
    public void setSchoolName(String schoolName)
    {
        this.schoolName=schoolName;
    }
}
public class Test2{
    public static void main(String[] args)
    {
        Student student=new Student();
        student.setName("花花");
        student.setAge(18);
        student.setSchoolName("励志中学");
        System.out.println("学校:"+student.getSchoolName() +" 姓名:"+student.getName()+"  年龄:"+student.getAge());
    }
}

继承的主要作用是对类进行扩充以及代码的重用!

1.2 继承的限制

1.2.1 子类对象在进行实例化前首先调用父类构造方法,再调用子类构造方法实例化子类对象。

class Person {
    private String name;
    private int age;
    public String getName()
    {
        return name;
    }
    public void setName(String name)
    {
        this.name=name;
    }
    public int getAge()
    {
        return age;
    }
    public void setAge(int age)
    {
        this.age=age;
    }
    //构造方法
    public Person()
    {
        System.out.println("父类的构造方法");
    }
}
class Student extends Person{
    private String schoolName;
    public String getSchoolName()
    {
        return schoolName;
    }
    public void setSchoolName(String schoolName)
    {
        this.schoolName=schoolName;
    }
    //构造方法
    public Student()
    {
        System.out.println("子类的构造方法");
    }
}
public class Test2{
    public static void main(String[] args)
    {
        Student student=new Student();
        student.setName("花花");
        student.setAge(18);
        student.setSchoolName("励志中学");
        System.out.println("学校:"+student.getSchoolName() +" 姓名:"+student.getName()+"  年龄:"+student.getAge());
    }
}

在这里插入图片描述
实际在子类构造方法中,相当于隐含了一个语句super(),调用父类的无参构造。同时如果父类里没有提供无参构造,那么这个时候就必须使用super(参数)明确指明要调用的父类构造方法。

1.2.2 Java只允许单继承不允许多继承(一个子类继承一个父类)

eg:错误的继承:

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

C继承A和B的主要目的是拥有A和B中的操作,为了实现这样的目的,可以采用多层继承的形式完成。

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

  Java中不允许多重继承,但是允许多层继承!多层继承一般不会超过三层

1.2.3 在继承时,子类会继承父类的所有结构。

在进行继承的时候,子类会继承父类的所有结构(包括私有属性、构造方法、普通方法)
显示继承:所有非私有操作属于显示继承(可以直接调用)。
隐式继承:所有私有操作属于隐式继承(不可以直接调用,需要通过其它形式调用(get或者set))。

class Person {
    private String name;
    private int age;
    public String getName()
    {
        return name;
    }
    public void setName(String name)
    {
        this.name=name;
    }
    public int getAge()
    {
        return age;
    }
    public void setAge(int age)
    {
        this.age=age;
    }
    public Person()
    {
        System.out.println("父类的构造方法");
    }
    public void fun()
    {
        System.out.println("好好学习。");
    }
}
class Student extends Person{
    private String schoolName;
    public String getSchoolName()
    {
        return schoolName;
    }
    public void setSchoolName(String schoolName)
    {
        this.schoolName=schoolName;
    }
    public Student()
    {
        System.out.println("子类的构造方法");
    }
}
public class Test2{
    public static void main(String[] args)
    {
        Student student=new Student();
        student.setName("花花");
        student.setAge(18);
        //隐式继承
        System.out.println("姓名:"+student.getName()+" 年龄:"+student.getAge());
        //显示继承
        student.fun();
    }
}

在这里插入图片描述
  此时父类中的属性以及方法均被子类所继承,但是发现子类能够使用的是所有非private操作,而所有的private操作无法被直接使用,所以称为隐式继承。

2. 典型例题

class A{
    public A()
    {
        System.out.println("1.A类的构造方法");
    }
    {
        System.out.println("2.A类的构造块");
    }
    static{
        System.out.println("3.A类的静态方法");
    }
}
public class B extends A{
    public B()
    {
        System.out.println("4.B类的构造方法");
    }
    {
        System.out.println("5.B类的构造块");
    }
    static{
        System.out.println("6.B类的静态方法");
    }
    public static void main(String[] args)
    {
        System.out.println("7.start......");
        new B();
        new B();
        System.out.println("8.end.....");
    }
}

主类中的静态块优先于主方法执行,所以6应该在7前面执行,但是B类继承于A类,所以先执行A类的静态块3,所以进主方法前的执行顺序为:3 6
进主方法后执行7,new B()之后应先执行A的构造方法然后执行B的构造方法,但由于A类和B类均有构造块,构造块又优先于构造方法执行即 2 1(A的构造家族) 5 4(B的构造家族),有多少个对象,构造家族就执行几次,题目中有两个对象 所以执行顺序为:3 6 7 2 1 5 4 2 1 5 4 8
在这里插入图片描述

©️2021 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值