Java继承是什么？Java继承如何使用？

本篇文章给大家带来的内容是介绍Java继承是什么？Java继承如何使用？，教给新手学会使用继承，及理解继承的概念。掌握访问修饰符、掌握 final 关键字的用法。有一定的参考价值，有需要的朋友可以参考一下，希望对你们有所助。

继承

为什么要使用继承

首先我们先看一下这两个类：

public class Teacher {
    private int teachingAge;
    private String name;
    private int age;
    public void teach() {
    }
    public void seyHi() {
        System.out.println("我是："+this.name);
    }
}

public class Student {
    private int studentNo;
    private String name;
    private int age;
    public void learn() {
    }
    public void seyHi() {
        System.out.println("我是："+this.name);
    }
}

Student 类和 Teacher 类中有一些相同的属性和方法，这些都属于重复代码，当一个程序中有大量的类时，就会产生大量的重复代码。这些重复的代码能不能抽取出来然后供其他类使用以简化呢，那就是使用继承。
使用继承优化之后：
创建 inherit 包
父类：(公共代码类)

package inherit;
public class People {
    private String name;
    private int age;
    public void sayHi() {
        System.out.println("我是："+this.name);
    }
    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;
    }
}

子类：Student.java

package inherit;
public class Student extends People{
    private int studentNo;
    public void learn() {
        System.out.println("学习课程");
    }
    public int getStudentNo() {
        return studentNo;
    }
    public void setStudentNo(int studentNo) {
        this.studentNo = studentNo;
    }
}

子类：Teacher.java

package inherit;
public class Teacher extends People{
    private int teachingAge;
    public void teach() {
        System.out.println("教授课程");
    }
    public int getTeachingAge() {
        return teachingAge;
    }
    public void setTeachingAge(int teachingAge) {
        this.teachingAge = teachingAge;
    }
}

测试类：

package inherit;
public class TestInherit {
    public static void main(String[] args) {
        //创建Student对象
        Student stu=new Student();
        stu.setName("张三");//父类中继承过来的方法
        stu.learn();//子类中特有的方法
        stu.sayHi();
        //创建Teacher对象
        Teacher teacher=new Teacher();
        teacher.setName("汤尼");
        teacher.setTeachingAge(2);//子类中特有的方法
        teacher.sayHi();
    }
}

观察上面示例代码我们发现：
1.子类的公共代码都可以放在父类中
2.子类可以有自己独有的方法和属性
3.子类一旦继承父类就会拥有父类的属性和方法
4.将公共代码放入父类，更方便统一修改代码

继承的语法

关键字：extends
1.编写父类

public class 父类{
    //公共的属性和方法
}

2.编写子类，继承父类

public class 子类 extends 父类{
    //子类特有的属性和方法
}

子类只能继承一个父类

子类访问父类成员

子类要想访问父类的成员要使用 super 关键字，super 代表父类对象
访问父类构造方法：

super();//访问无参构造
super(参数);//访问有参构造

访问父类属性：

super.name;

访问父类方法：

super.print();

访问父类构造，必须在子类构造方法中调用，必须是第一句

super 只能出现在子类的方法和构造方法中

super 不能访问父类的 private 成员

敲一敲：访问父类成员
创建包 visitparent 后在报下创建如下类
父类

package visitparent;
public class Animal {
    private String name;
    private int legs;
    public Animal() {
        this.name="无名";
        this.legs=4;
    }
    public Animal(String name,int legs) {
        this.name=name;
        this.legs=legs;
    }
    public void eat(String food) {
        System.out.println(name+" 吃食物："+food);
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getLegs() {
        return legs;
    }
    public void setLegs(int legs) {
        this.legs = legs;
    }
}

子类

package visitparent;
public class Cat extends Animal{
    private String hairColor;//毛发颜色
    private int age;
    public Cat () {
        super();//调用父类无参
    }
    public Cat(String name,int legs,String hairColor,int age) {
        super(name, legs);//这里调用相当于重用父类构造方法了
        this.hairColor=hairColor;
        this.age=age;
        //super(name, legs);//去掉注释试试
        //this.name="无名";//去掉注释试试
    }
    public void catchMouse() {
        System.out.println(super.getName()+":抓老鼠");
    }
    public void paly() {
        System.out.println(super.getName()+" 玩累了。");
        super.eat("小鱼干");
    }
    public String getHairColor() {
        return hairColor;
    }
    public void setHairColor(String hairColor) {
        this.hairColor = hairColor;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

子类不能继承父类的 private 成员

子类不能继承不同包使用默认访问权限的成员(默认访问权限就是不写访问修饰符)

子类不能继承父类的构造方法

多重继承的执行流程

在创建子类的时候父类在做什么？
下面创建3个类观察执行流程，C类继承B类，B类继承A类。
A.java

public class A {
    public A() {
        System.out.println("A类的无参构造函数执行");
    }
}

B.java

public class B extends A{
    public B() {
        System.out.println("B类的无参构造函数执行");
    }
}

C.java

public class C extends B{
    public C() {
        System.out.println("C类的无参构造函数执行");
    }
}

TestRunFlow.java 测试类，展示运行结果

public class TestRunFlow {
    public static void main(String[] args) {
        C c=new C();
    }
}

运行结果为：
A类的无参构造函数执行
B类的无参构造函数执行
C类的无参构造函数执行

如果子类构造方法通过 super 显式调用父类相应构造方法，则不执行父类无参构造方法

子类构造方法默认会调用父类无参构造方法

调用父类无参构造方法，一直到执行顶级父类Object类的的无参构造方法为止

根据以上规则，判断下面的代码是否能编译通过
父类

public class Pet {
    private String name;
    public Pet(String name) {
        this.name=name;
    }
}

子类

public class Dog extends Pet{
}

答案是不能，父类中只有有参构造方法没有无参构造方法，子类中没有任何代码默认有一个隐式无参构造方法，子类无参构造方法默认调用父类无参构造方法，然而父类中没有，所有在子类中报错。
解决办法：1.在父类中显式添加无参构造方法，2.在子类构造方法中显式调用父类有参构造方法。

java 中的访问修饰符

访问修饰符 protected 能修饰属性和方法，修饰后本类、子类、同包可以访问。

方法重写

在"继承优化后"的代码中，Teacher 继承了 People 类，(忘记代码可以翻回去再看一遍) People 类中有个一个打招呼的方法 sayHi() 用于输出人的名字，但是 Teacher 调用这个方法并不能打印出 Teacher 的属性 teachingAge 的值，但是我们还想用这个方法实现这个功能，应该怎么办呢？
我们可以使用 方法重写 解决这个问题，修改子类 Teacher 中的代码，下面看一下使用方法重写后的效果。
Teacher.java

package inherit;
public class Teacher extends People{
    //省略其他属性
    @Override
    public void sayHi() {
        System.out.println("我是："+super.getName()+" ,从事教育行业 "+this.teachingAge+" 年了。");
    }
    //省略其他方法、getter、setter
}

在 Eclipse 中重写某方法的快捷键是 Alt+Shift+S+V ，按完后选择要重写的方法

在 Idea 中重写某方法的快捷键是 Ctrl+O ，按完后选择要重写的方法

@Override 注解的作用， 用来检测是否符合重写规则，不符合重写规则将报错，这个注解可以不写

构造方法不能重写，因为构造方法不能被继承

方法重写的规则：

1.方法名相同

2.参数列表相同

3.返回值类型相同或者是其子类

4.访问权限不能严于父类

final 关键字的使用

1.final 修饰变量后变为常量

private static final long serialVersionUID = -6849794470754667710L;

2.final 修饰类后，该类不能被继承

package java.lang;
public final class Math {
    //省略属性和方法……
}

3.final 修饰方法后，该方法不能被重写

public final void teach() {
        System.out.println("教授课程");
    }

4.final 修饰创建的对象后，该对像不能再次实例化(可以修改属性)

final Teacher teacher=new Teacher();
teacher.setName("汤尼");
//teacher=new Teacher();//去掉注释试试

String 类就是一个典型的被 final 修饰的类
以上就是Java继承是什么？Java继承如何使用？的详细内容，更多请关注泽林博客其它相关文章！

本文转载于：博客园