java学习——继承

snow deer

已于 2024-02-22 10:53:20 修改

阅读量905

点赞数 23

文章标签： java 学习开发语言

于 2024-02-22 10:52:23 首次发布

本文链接：https://blog.csdn.net/ping12138/article/details/136175991

版权

一、认识继承

1、概念

继承在Java中是一种重要的面向对象编程概念，它允许一个类（称为子类）获得另一个类（称为父类）的特征和行为。具体来说：

子类继承父类的属性和行为：这意味着子类可以自动拥有与父类相同的属性和行为，无需重新编写代码即可直接使用这些属性和行为。
访问权限控制：子类对父类非私有成员的访问通常受到限制，只能访问非私有的属性和行为。
多层次继承：通过继承，可以实现不同级别的类之间的层级关系，从而构建复杂的系统结构。
综上所述，继承使得子类对象具有与父类相同的属性和行为，提高了代码的可重用性和可维护性。

继承是面向对象的三大特征之一。

2、如何使用继承

语法

public class 子类名 extends 父类名 {

}

示例

package text.com.chapter1.animal;

public class Animal {
    protected String name;
    protected int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void eat(){
        System.out.println("动物吃饭");
    }
    public void sleep(){
        System.out.println("动物睡觉");
    }
}

package text.com.chapter1.animal;

public class Dog extends Animal{

    //本类中未定义name和age的变量，却可以使用，说明这两个变量是从父类继承过来的
    public Dog(String name, int age) {
        super(name, age);
    }


    //本类中未定义eat()和sleep()的方法，却可以使用，说明这两个方法是从父类继承过来的
    @Override
    public void eat() {
        System.out.println(age+"岁的"+name+"吃骨头");
    }

    @Override
    public void sleep() {
        System.out.println(age+"岁的"+name+"在睡觉");
    }
}

package text.com.chapter1.animal;

public class AnimalTest {
    public static void main(String[] args) {
        Animal a1=new Dog("哈巴狗",10);
        a1.eat(); a1.sleep();
    }

}

3、继承的属性和方法

不论子类在什么包中，子类会继承父类中所有的公开和受保护的成员（包括字段和方法）。如果子类和父类在同一个包中，子类也会继承父类中受保护的成员。

子类不会继承父类中定义的私有成员，尽管如此，如果父类有提供公开或受保护的访问该字段的方法，这些方法也能在子类中被使用。

示例

package text.com.chapter1.animal;

public class Animal {
    private String name;
    private int age;
    //name和age不可被继承

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    private void eat(){
        System.out.println("动物吃饭");
    }
    //eat()不可被继承
    public void sleep(){
        System.out.println("动物睡觉");
    }
}

package text.com.chapter1.animal;

public class Animal {
     String name;
     int age;
     //name和age只能在同一个包中被继承，其他的包不可继承使用
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

     void eat(){
        System.out.println("动物吃饭");
    }
    //eat()只能在同一个包中被继承，其他的包不可继承使用
    public void sleep(){
        System.out.println("动物睡觉");
    }
}

注：如果一个对象赋值给其父类的引用，此时想要调用该对象的特有的方法，那么必须要进行强制类型转换。

例子

package com.first.text.p1;

public class Person {

    public String name;
    public String sex;
    public int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void eat(){
        System.out.println(name+"吃饭");
    }
}

package com.first.text.p1;

public class Programmer extends Person{
    private int level;
    public void programming(){
        System.out.println("程序员编程");
    }

    public int getLevel() {
        return level;
    }

    public void setLevel(int level) {
        this.level = level;
    }
}

package com.first.text.p1;

public class Doctor extends Person{
    private String professional;
    public void cure(){
        System.out.println("医生治病");
    }

    public String getProfessional() {
        return professional;
    }

    public void setProfessional(String professional) {
        this.professional = professional;
    }
}

package com.first.text.p1;

public class PersonText {
    public static void main(String[] args) {
        Person p1= new Programmer();
        p1.setAge(20);
        p1.setName("章");
        p1.setSex("男");
        p1.eat();
        ((Programmer)p1).programming();
        //强制类型转换

        Person p2=new Doctor();
        p2.setAge(20);
        p2.setName("李");
        p2.setSex("女");
        p2.eat();
        ((Doctor)p2).cure();
        //强制类型转换
    }
}

二、方法重写

1、概念

子类中的一个成员方法与父类中的一个成员方法有相同的签名（方法名加上参数数量和参数类型）和返回值类型的实例方法重写了父类的方法。

2、如何使用方法重写

a、子类重写方法的能力使类可以从行为“足够近”的父类维承（足够近可理解为亲子关系，爷爷与父亲算足够近，父亲与儿子算足够近），然后根据需要修改行为。重写方法与被重写的方法具有相同的名称，数量和参数类型，并且返回类型相同。重写方法还可以返回重写方法返回的类型的子类型。此子类型称为协变返回类型。

协变返回类型例子

package com.first.text.p1;

public class Person {

    public String name;
    public String sex;
    public int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void eat(){
        System.out.println(name+"吃饭");
    }

    public Number getscore(){ //Number是父类的返回类型
        return 0;
    }
}

package com.first.text.p1;

public class Doctor extends Person{
    private String professional;
    public void cure(){
        System.out.println("医生治病");
    }

    public String getProfessional() {
        return professional;
    }

    public void setProfessional(String professional) {
        this.professional = professional;
    }

    public Integer getscore(){ //Integer是父类Number的子类
        return 90;
    }
}

package com.first.text.p1;

public class Programmer extends Person{
    private int level;
    public void programming(){
        System.out.println("程序员编程");
    }

    public int getLevel() {
        return level;
    }

    public void setLevel(int level) {
        this.level = level;
    }

    @Override
    public Double getscore() { //Double是父类Number的子类
        return 96.4;
    }
}

补充：Byte Short Integer Long Float Double 都是Number的子类。

b、重写方法时，您可能需要使用eoverride注解，该注释指示编译器您打算重写父类中的方法。如果由于某种原因，编译器检测到该方法在父类中不存在，则它将生成错误。

例子

package com.first.text.p1;

public class Person {

    public String name;
    public String sex;
    public int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void eat(){
        System.out.println(name+"吃饭");
    }

    public Number getscore(){
        return 0;
    }
}

package com.first.text.p1;

public class Programmer extends Person{
    private int level;
    public void programming(){
        System.out.println("程序员编程");
    }

    public int getLevel() {
        return level;
    }

    @Override //报错
    public void setLevel(int level) {
        this.level = level;
    }

    @Override //该注解告诉编译器，这是一个重写的方法，编译器会去检测父类中是否存在这样的方法，如果不存在，那编译器会报错
    public Number getscore() {
        return 96.4;
    }
}

注：重写方法时访问修饰符的级别不能降低。

访问修饰符级别：public > protected > 默认（包内可见）> private

三、super关键字及万物皆对象原理

1、super关键字

说明1：如果子类的构造方法没有明确调用父类的构造方法，Java编译器会自动插入一个父类无参构造的调用。如果父类没有无参构边，你将得到个编泽时错误。object类有一个无参构造，因此，如果object类是该类的唯一父类，这就没有问题。

示例一:子类和父类中都没有定义构造方法

package com.first.text;

public class father {

    public String name;
    public String sex;

    public father(){
    super();
    }

    public void eat(){
        System.out.println("吃饭");
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
}

package com.first.text;

public class child extends father {
    
    //如果一个类中没有定义构造方法，那么编译器将会给该类插入一个无参构造方法
    public child(){
      super();//如果子类构造方法中没有显示的调用父类的构造方法，那么编译器会自动插入一个父类无参构造方法
    }
    public void show(){
        System.out.println(getName());
        System.out.println(getSex());

        eat();
        sleep();
    }
}

示例二:子类中有定义构造方法，父类没有定义构造方法

package com.first.text;

public class father {

    public String name;
    public String sex;

    public void eat(){
        System.out.println("吃饭");
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
}

package com.first.text;

public class child extends father {

    //如果一个类中没有定义构造方法，那么编译器将会给该类插入一个无参构造方法
    public child(){
      super();//如果子类构造方法中没有显示的调用父类的构造方法，那么编译器会自动插入一个父类无参构造方法
    }
    
    public child(String name){
        super();
        this.name=name;
    }
    public void show(){
        System.out.println(getName());
        System.out.println(getSex());

        eat();
        sleep();
    }
}

示例三:子类和父类中都有定义构造方法

package com.first.text;

public class father {

    public String name;
    public String sex;

    public father(String name,String sex){
        super();
        this.name=name;
        this.sex=sex;
    } //父类的带参构造方法
    public void eat(){
        System.out.println("吃饭");
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
}

package com.first.text;

public class child extends father {

    //如果父类中定义了带参构造，并且没有定义无参构造，那么必须在子类的构造方法中显示的调用父类的带参构造
    // ，也就是说要主动写子类的构造方法，编译器不会自动生成
    public child(String name,String sex){
      super(name, sex);
    }

    public void show(){
        System.out.println(getName());
        System.out.println(getSex());

        eat();
        sleep();
    }
}

注：使用super调用父类的构造方法时，必须为这个构造方法的第一条语句。

例子

package com.first.text;

public class child extends father {

    //如果父类中定义了带参构造，并且没有定义无参构造，那么必须在子类的构造方法中显示的调用父类的带参构造
    // ，也就是说要主动写子类的构造方法，编译器不会自动生成
    public child(String name,String sex){
        this.name=name;
      super(name, sex); //这样会报错
    }

    public void show(){
        System.out.println(getName());
        System.out.println(getSex());

        eat();
        sleep();
    }
}

说明2：如果你的方法重写了父类的方法之一，则可以通过使用关键字super来调用父类中被重写的方法。你也可以使用super来引用隐藏字段 (尽管不建议使用隐藏字段) 。

覆盖例子

package com.first.text.p1;

public class School {
    protected String name;
    protected int age;

    public String getName() {
        return name; //相当于this.name
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

package com.first.text.p1;

public class Student extends School{
    private String name; //Student的name把父类中的name给覆盖了
    public Student(String name){
        this.name=name;
    }
}

package com.first.text.p1;

public class SchoolTest {
    public static void main(String[] args) {
        School p=new Student("小安");
        System.out.println(p.getName()); //此处引用的是父类的name，所以输出为null

        Student s=new Student("小安");
        System.out.println(p.getName()); //此处引用的是父类的name，所以输出为null
    }
}

修正例子

package com.first.text.p1;

public class School {
    protected String name;
    protected int age;

    public String getName() {
        return name; //相当于this.name
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

package com.first.text.p1;

public class Student extends School{
    private String name; //Student的name把父类中的name给覆盖了
    public Student(String name){
        this.name=name;
    }

    @Override
    public String getName() {
        return name;
    } //增加这个可以输出子类添加的name，重写方法
}

package com.first.text.p1;

public class SchoolTest {
    public static void main(String[] args) {
        School p=new Student("小安");
        System.out.println(p.getName()); //此处可输出 "小安"
    }
}

补充例子

package com.first.text.p1;

public class School {
    protected String name;
    protected int age;

    public String getName() {
        return name; //相当于this.name
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

package com.first.text.p1;

public class Student extends School{
    private String name; //Student的name把父类中的name给覆盖了
    public Student(String name){
        this.name=name;
    }

    @Override
    public String getName() {
        return name;
    }

    public void show(){
        System.out.println(this.name);//访问本类的name
        System.out.println(super.name);//访问父类的name

        //如果子类和父类中没有相同的成员变量，此时使用this和super调用的都是
        //父类的成员变量，输出结果一致
        System.out.println(this.age);
        System.out.println(super.age);

        //对于方法也可有super和this
        System.out.println(this.getName());
        System.out.println(super.getName());
    }
}

package com.first.text.p1;

public class SchoolTest {
    public static void main(String[] args) {
        Student p=new Student("小安");
        p.setAge(18);
        p.show(); //输出结果是 小安、null、18、18、小安、null
    }
}

注：如果子类中的静态方法和父类中的静态方法具有相同的签名时，这不属于方法重写，因为静态方法称之为类方法，跟对象无关，调用时只看对象的数据类型。如 StaticFather.show() 调用的是父类的，StaticChild.show() 调用的是子类的。

2、万物皆对象

概念解析：

a、除了没有父类的object之外，每个类都有一一个且只有一个直接父类(单维承)。在没有其他任何显式超类的情况下，每个类都隐式为object的子类。

b、类可以派生自另一个类，另个类又可以派生自另一个类，依此类推，并最终派生自最顶层的类object。据说这样的类是继承链中所有类的后代，并延伸到object。

所有类都是Object的子类，因此，创建对象时都需要调用Object类中的无参构造方法而Object本身就表示对象，因此创建出来的都是对象。

四、final修饰符

1、应用范围

final 修饰符应该使用在类、变量以及方法上。

2、final 修饰类说明

你可以将某些或所有类的方法声明为final。在方法声明中使用final关键字表示该方法不能被子类覆益。object类就是这样做的——它的许多方法都是最终的。

如果一个类被 fianl 修饰，表示这个类是最终的类，因此这个类不能够再被继承，因为继承就是对类进行补充。

示例

//这是包的定义
package com.AE.Gundam;

public final class RX78 {
    public void show(){
        System.out.println("show it");
    }
}

package com.AE.Gundam;

public class GP01 extends RX78{ //发生报错
}

3、fianl 修饰方法

我们可以声明整个类的 final ，声明为 final 的类不可被子类化。

例子

//这是包的定义
package com.AE.Gundam;

public class RX78 {
    public final void show(){
        System.out.println("show it");
    }
}

package com.AE.Gundam;

public class GP01 extends RX78{
    public void show(){
        //发生报错，因为父类中show()是final修饰的，不可被重写
    }
}

4、final 修饰变量

final 修饰变量时，变量必须在对象构建时完成初始化，final 修饰的变量被称为常量。

例子

//这是包的定义
package com.AE.Gundam;

public class RX78 {
    private final int age;//无初始值，编译器报错
    private final int amount=10;//编译正确

    //下面一种 final 修饰方式也正确
    private final int date;
    public RX78(){
        date=12;
    }

    //下面的 date 不可更改，date为常量
    private void change(){
        date=13;
    }
}

思考下列代码

//这是包的定义
package com.AE.Gundam;

public class RX78 {
    static {
        System.out.println("父类静态代码块执行");
    }
    public RX78(){
        super();
        System.out.println("父类构造方法执行");
    }
}

package com.AE.Gundam;

public class GP01 extends RX78{
    static {
        System.out.println("子类静态代码块执行");
    }
    public GP01(){
        System.out.println("子类构构方法执行");
    }
}

package com.AE.Gundam;

public class FunctionTest {
    public static void main(String[] args) {
        new GP01();

        //构建GP01对象时，发现GP01是RX78的子类， 而RX78又是object的子类。 因此JVM会首先加载object类
        //然后再加载RX78类，最后再加载GP01类。 而静态代码块是在类第一次加载时执行，而且只会执行一次。
        //因此RX78类中的静态代码块先执行，然后再执行GP01类中的静态化码块。然后才执行new GP01();代码。
        
        /*
          下面是执行结果：
              父类静态代码块执行
              子类静态代码块执行
              父类构造方法执行
              子类构构方法执行
         */
    }
}

snow deer

关注

23
点赞
踩
30

收藏

觉得还不错? 一键收藏
1
评论
java学习——继承

继承在Java中是一种重要的面向对象编程概念，它允许一个类（称为子类）获得另一个类（称为父类）的特征和行为。具体来说：子类继承父类的属性和行为：这意味着子类可以自动拥有与父类相同的属性和行为，无需重新编写代码即可直接使用这些属性和行为。访问权限控制：子类对父类非私有成员的访问通常受到限制，只能访问非私有的属性和行为。多层次继承：通过继承，可以实现不同级别的类之间的层级关系，从而构建复杂的系统结构。综上所述，继承使得子类对象具有与父类相同的属性和行为，提高了代码的可重用性和可维护性。
复制链接

扫一扫