一篇文章让你理解Java继承那些事

点击上方“大话coding”，选择“星标”公众号

重磅干货，第一时间送达

---

大家好，我是小轩

前几天有人在后台问我java继承

问题是C继承A和B继承A，C继承B一样吗？

目录

• 什么是继承？

• 继承的语法？

• 继承类型？

• 继承的特性？

• 继承关键字？

• 继承的注意事项？

什么是继承？

继承是面向对象最显著的一个特性。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。

继承的语法？

class 子类 extends 父类 {}

子类又被称为派生类；父类又被称为超类（super class）；

继承类型？

单继承、多重继承、不同类继承同一类；

注意，java继承没有多继承。

继承的特性？

• 子类拥有父类非private的属性和方法

• 子类可以对父类进行扩展；

• 子类可以用自己的方式实现父类的方法；

继承关键字？

• extends关键字

在 Java 中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类，所以 extends 只能继承一个类。

• implements关键字

使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。

public interface A {
public void eat();
public void sleep();
}


public interface B {
public void show();
}


public class C implements A,B {
}

继承的注意事项？

代码错误写法：

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

正确写法：

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

在继承关系之中，如果要实例化子类对象，会默认先调用父类构造，为父类之中的属性初始化，之后再调用子类构造，为子类之中的属性初始化，即：默认情况下，子类会找到父类之中的无参构造方法。

关于构造器补充：

如果没有定义有参构造器，默认有无参构造器；在有有参构造器的基础上，只有定义了无参构造器，这两个构造器才都有。

package com.edu.java;


class Animal {
private String name;


public Animal(String myName) {
        name = myName;
    }


public Animal(){
        System.out.println("我是动物");
    }
public void doing(){
        System.out.println(name+"正在干什么");
    }
}
class tager extends Animal {
    String name;


// 这里是tager的有参构造器，如果没有定义无参构造器，就只有有参构造器了。
public tager(String myName) {
this.name = myName;
        System.out.println("我是老虎01"+name);
    }
public tager() {
        System.out.println("我是老虎02"+name);
    }
public void doing(){
        System.out.println(name+"正在干什么");
    }
}
class Test{
public static void main(String[] args) {
        tager tager = new tager();
        tager tager2 = new tager("aa");
    }
}

默认调用的是无参构造，而如果这个时候父类没有无参构造，则子类必须通过super()调用指定参数的构造方法。

如果父类有无参构造器，子类构造器可以不使用super就可以调用父类的无参构造器。执行完父类构造器之后，再执行子类构造器。

下面是B继承A，C继承B和C继承A的举例代码：

package com.edu.java;


// A
class Animal {
private String name;
private int id;


public Animal(String myName, int myid) {
        name = myName;
        id = myid;
    }
public Animal(){


    }
public void doing(){
        System.out.println(name+"正在干什么");
    }
public void begoodat(){
        System.out.println(name+"擅长什么");
    }
public void introduction() {
        System.out.println("大家好！我是"+ id + "号" + name + ".");
    }
}


// B继承A
class tager extends Animal {
    String name;


// 这里是tager的有参构造器，如果没有定义无参构造器，就只有有参构造器了。
public tager(String myName) {
this.name = myName;
    }
public tager() {
    }
// 为了测试方便，我们这里再定义一个无参构造器
// 如果父类只有有参构造器，子类的无参构造器中只能使用super来调用父类的有参构造器。
public void doing() {
        System.out.println(name+"正在吃肉");
    }
public void begoodat() {
        System.out.println(name+"擅长奔跑");
    }
public void type(){
        System.out.println(name+"属于猫科动物");
    }
public void xingge(){
        System.out.println(name+"性格凶猛");
    }
}


// C继承B
class wolf extends tager{
public wolf(String myName) {
        super(myName);
    }


public void doing(String name) {
        System.out.println(name+"正在吃肉");
    }
public void begoodat(String name) {
        System.out.println(name+"擅长奔跑");
    }
public void type(String name){
        System.out.println(name+"属于狗科动物");
    }
public void live(String name){
        System.out.println(name+"属于群居动物");
    }
}


//C继承A
class wolf1 extends Animal{


public void doing(String name) {
        System.out.println(name+"正在吃肉");
    }
public void begoodat(String name) {
        System.out.println(name+"擅长奔跑");
    }
public void type(String name){
        System.out.println(name+"属于群居动物");
    }
public void tixing(String name){
        System.out.println(name+"体型细长");
    }
}


class Test{
public static void main(String[] args) {
        tager tager = new tager("laohu");
        tager.begoodat();
        tager.doing();
        tager.type();
// 如果现在子类中的doing()中有参数，在main中调用时候没有参数，就会去找父类中有没有不带参数的doing()方法，如果没有就直接报错。
//        tager.begoodat("laohu");
//        tager.doing("laohu");
        System.out.println("===========================");
        wolf wolf = new wolf("lang");
        wolf.begoodat(); //调用父类的方法
        wolf.type(); //调用父类的方法
        wolf.xingge();//调用父类的方法
        wolf.begoodat("lang"); //调用子类的方法
        System.out.println("===========================");
// 因为B继承A，C继承B，因为B中有扩展的方法，比如xingge().
// 在C直接继承A中就实现不了，但C直接继承A又多出了一个tixing()方法
        wolf1 wolf1 = new wolf1();
        wolf1.tixing("xiaolang");
        wolf1.begoodat("xiaolang");
    }
}

因为B在中间可能对A进行功能上的扩展，如果C直接继承A，C就和B处于同一级。