java中的继承

爱码驱动

已于 2024-07-26 15:52:46 修改

阅读量965

点赞数 33

分类专栏： Java 文章标签： java 开发语言学习

于 2024-07-26 15:50:45 首次发布

本文链接：https://blog.csdn.net/huangtiandi11/article/details/140702369

版权

Java 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

1、继承的概念

继承是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加新功能，这样产生新的类，称派生类。继承主要可以用来实现共性的抽取和代码的复用。

2、继承的语法

修饰符 class 子类 extends 父类{
    //.....
}

举例：

//父类
public class Father {
    public int a=100;
    public int b=200;
    public void func(){
        System.out.println("func");
    }
}
//子类
public class Son extends Father {
    public int a=101;
    public int c=300;
    public void method(){
        System.out.println(a);
        System.out.println(super.a);
    }
    public void me(){
        method();
        func();
    }
}

注意:子类会将父类中的成员变量或者成员方法继承到子类中去。

3、父类成员访问

3.1、子类中访问父类的成员变量

1、当子类和父类不存在同名变量时：

//父类
public class Father {
    public int a=100;
    public int b=200;
}
//子类
public class Son extends Father {
    public int c=300;
    public void method(){
        System.out.println("a="+a+"  b="+b+"  c="+c);
    }
}
//Main类
public class Main {
    public static void main(String[] args) {
        Son son=new Son();
        son.method();
    }
}

结果如下：

2、当子类和父类成员变量同名时

//父类
public class Father {
    public int a=100;
    public int b=200;
}
//子类
public class Son extends Father {
    public int a=101;
    public int c=300;
    public void method(){
        System.out.println("a="+a+"  b="+b+"  c="+c);
    }
}

结果如下：

由上图知：当子类和父类成员变量同名时，优先访问子类的成员变量。

综上：成员变量访问遵循就近原则，自己有优先自己的，如果没有则向父类中找。

3.2、子类中访问父类的成员方法

1、成员方法名字不同

//父类
public class Father {
    public int a=100;
    public int b=200;
    public void methodA(){
        System.out.println("Father:methodA");
    }
}
//子类
public class Son extends Father {
    public int a=101;
    public int c=300;
    public void methodB(){
        System.out.println("Son:methodB");
    }
    public void methodC(){
        methodB();//访问子类的成员方法
        methodA();//访问父类的成员方法
    }
}
//Main类
public class Main {
    public static void main(String[] args) {
        Son son=new Son();
        son.methodC();//调用methodC()
    }
}

结果如下：

注意：成员方法不同名时，优先在子类中找，子类中没有的再从父类中找。

2、成员方法名字相同

//父类
public class Father {
    public int a=100;
    public int b=200;
    public void methodA(){
        System.out.println("Father:methodA");
    }
    public void methodB(){
        System.out.println("Father:methodB");
    }
}
//子类
public class Son extends Father {
    public int a=101;
    public int c=300;
    public void methodA(){
        System.out.println("Son:methodA");
    }
    public void methodC(){
        methodB();
        methodA();
    }
}

结果如下:

由此，我们可以看出，在父类和子类成员方法名相同的情况下，访问子类成员方法。那如何在子类中访问父类相同名称的成员呢？这里我们可以使用super关键字。

4、super关键字

super关键字主要作用：在子类方法中访问父类的成员。

//
public class Father {
    public int a;
    public int b;
    public void methodA(){
        System.out.println("Father:methodA");
    }
}
public class Son extends Father {
    public int a;
    public int c;
    public void methodA(){
        System.out.println("Son:methodA");
    }
    public void methodC(){
        //访问子类
        a=100;
        c=200;
        //访问父类
        super.a=101;
        super.b=201;
        methodB();
        //访问子类
        methodA();
        //访问父类
        super.methodA();
    }
}

注意：1. 只能在非静态方法中使用

2. 在子类方法中，访问父类的成员变量和方法。

5、子类构造方法

子类对象构造时，需要先调用基类构造方法，然后执行子类的构造方法。如下：

//父类
public class Father {
    public int a;
    public int b;
    public Father(int a,int b){
        this.a=a;
        this.b=b;
        System.out.println("Father(int a,int b)");
    }
}
//子类
public class Son extends Father {
    public int a;
    public int c;
    public Son(){
        super(22,33);
        System.out.println("Son()");
    }
}
//
public class Main {
    public static void main(String[] args) {
        Son son=new Son();
    }
}

结果如下：

上面的 super(22,33);是用来调用父类的构造方法，来初始化父类的成员变量

注意：1. 若父类显式定义无参或者默认的构造方法，在子类构造方法第一行默认有隐含的super()调用，即调用父类构造方法

2. 如果父类构造方法是带有参数的，此时需要用户为子类显式定义构造方法，并在子类构造方法中选择合适的父类构造方法调用，否则编译失败。

3. 在子类构造方法中，super(...)调用父类构造时，必须是子类构造函数中第一条语句。

4. super(...)只能在子类构造方法中出现一次，并且不能和this（...）同时出现

6、final关键字

ﬁnal关键字可以用来修饰变量、成员方法以及类。

1. 修饰变量或字段，表示常量(即不能修改)

final int a=10;
a=20;//编译出错

2. 修饰类：表示此类不能被继承

public class Animal{
    //...
}
public class Bird extends Animal{
    //...
}//编译出错

3. 修饰方法：表示该方法不能被重写(也叫覆盖。是子类对父类非静态，非private，非final方法的实现过程进行重新编写，返回值和形参都不能改变。即外壳不变，核心重写)

以上便是本篇文章的全部内容，感谢各位看官的观看，如本篇文章对你有所帮助，可以点点关注收藏支持一下，感谢支持！！！