Java教程

Java面向对象之继承

本文主要是介绍Java面向对象之继承,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

类是对象的抽象,继承是面向对象的特点之一

继承的引入

拿一个学校来说,一个学校有必然有三类人,一类是学生,一类是教师,一类是员工。

  1. 定义一个学生类Student,属性可以有: 姓名,年龄,身高和学生编号。方法可以有: 吃饭,睡觉,讲话,学习

  2. 定义一个教师类Teacher,属性可以有: 姓名,年龄,身高,教师编号。方法可以有: 吃饭,睡觉,讲话,教学

  3. 定义一个员工类Employee,属性可以有: 姓名,年龄,身高,员工编号。方法可以有: 吃饭,睡觉,讲话,工作

这些类的方法和属性有很多重复,如果一一实现上述三个类多少有点繁琐,可以提取三者的共性,抽象出一个类

三者共同的东西: 人类,属性: 姓名,年龄,身高。方法: 吃饭,睡觉,讲话。

上述三个类都可以继承自这个人类,三者都具有人类的属性和方法,就无须在每个类中重复定义一些属性和方法了,提高了代码复用性。将人类这个类称为父类,基类或超类,将上述的三个类称为子类或派生类。

建立继承关系是在合理的范围中进行抽取,抽取出子类和父类的关系。

上面的案例中: 学生、员工和老师都是人,方法和属性上具有许多共同点,因此可以基于此抽象出一个基类。

代码演示

实现基类Person

public class Person {
    private int age;       // 年龄
    private String name;   // 姓名
    private double height; // 身高

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    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 void eat() {
        System.out.println("Eating food");
    }

    public void sleep() {
        System.out.println("Sleeping");
    }

    public void talk() {
        System.out.println("Talking");
    }
}

实现学生类时就可以直接使用extends关键字继承自人类

public class Student extends Person {
    private int sno; // 学号

    public int getSno() {
        return sno;
    }

    public void setSno(int sno) {
        this.sno = sno;
    }
}

并且继承后可以额外实现属性和方法

在主类中创建Student对象

public class demo {
    public static void main(String[] args) {
        Student s = new Student();
        s.setSno(1001);
        s.setName("Tom");
        s.setAge(18);
        s.setHeight(1.78);

        System.out.println(s.getSno());
        System.out.println(s.getName());
        System.out.println(s.getAge());
        System.out.println(s.getHeight());
    }
}

即使在Student中未定义上述的一些的方法和属性,但因为其父类Person实现了,所以其子类Student也具有了这些方法和属性,此处可见对父类代码的复用。

输出

1001
Tom
18
1.78

可见父类private修饰的属性,子类也继承了。

可见继承有几点好处:

  1. 提高代码的复用性,父类定义的内容,子类可以直接用,无须重复定义

  2. 便于代码的扩展

  3. 多态性的前提

有几个注意点:

  1. 一个子类只能有一个直接父类,也就是说只能直接继承一个

  2. 一个父类可以有多个子类

  3. 父类private修饰的内容,子类也继承

方法重写

发生在子类和父类中,当父类的某个方法可以不满足子类的要求时,可对这个父类方法进行重写。重写有严格的格式要求,子类的方法名字和父类必须一致,参数列表(个数,类型,顺序)也要和父类一致。

public class Student extends Person {
    private int sno; // 学号

    public int getSno() {
        return sno;
    }

    public void setSno(int sno) {
        this.sno = sno;
    }

    public void study() {
        System.out.println("Studying");
    }

    public void eat() {
        System.out.println("Eating fish");
    }
}

如上在Student类中对方法进行重写

Super关键字

java中的 super 关键字是一个引用变量,用于引用直接父类对象

Super修饰属性和方法

使用Super关键字来调用父类的东西

public void eat() {
    super.eat(); // 调用父类的eat函数
    System.out.println("Eating fish");
}

这时就会多打印一行"eat food"

要注意的是,当子类和父类的属性或方法重名时,想要使用父类属性或方法就必须加上super。类中的构造器会默认调用父类空构造器。

Super修饰构造器

如果构造器中已经显示的调用super父类构造器,那么空构造器就没有默认分配的super()了

在父类中定义构造函数

public class Person {
    private int age;
    private String name;
    private double height;

    public Person(int age,String name) {
        this.age = age;

    }

    public Person() {

    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    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 void eat() {
        System.out.println("Eating food");
    }

    public void sleep() {
        System.out.println("Sleeping");
    }

    public void talk() {
        System.out.println("Talking");
    }
}

子类中使用super调用super调用父类构造器

public class Student extends Person {
    private int sno; // 学号
    private int score;

    public int getSno() {
        return sno;
    }

    public void setSno(int sno) {
        this.sno = sno;
    }

    public void study() {
        System.out.println("Studying");
    }

    public void eat() {
        super.eat();
        System.out.println("Eating fish");
    }

    public Student() {
        super(); 
    }
    public Student(int age, String name,int score) {
        super(age,name); // 子类构造器调用父类构造器
        this.score = score;

    }
}
这篇关于Java面向对象之继承的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!