Java继承中成员变量和成员方法的访问特点

最新推荐文章于 2024-06-26 09:29:00 发布

空哥sky

最新推荐文章于 2024-06-26 09:29:00 发布

阅读量838

点赞数 17

文章标签： java 开发语言算法

本文链接：https://blog.csdn.net/TNTxd/article/details/136856554

版权

本文围绕Java开发展开，介绍了继承中成员变量和成员方法的访问特点，成员变量遵循就近原则，成员方法直接调用也遵循就近原则，还可通过super调用父类方法。同时讲解了方法重写，包括其定义、书写格式、注意事项等，并通过动物继承体系设计进行练习。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1、继承中成员变量的访问特点：就近原则：谁离得近就用谁

public class Fu {
    String name="Fu";
}
public class Zi extends Fu{
    String name="Zi";
    public void ziShow(){
        String name="ziShow";
        System.out.println(name);//这里就近原则，所以是ziShow
        System.out.println(this.name);//这里this关键字所以是本类中的Zi
        System.out.println(super.name);//这里的super表示父类，所以是父类中的Fu
    }
}

Idea中示范：

package a06extendsdemo3;

public class Test1 {
    public static void main(String[] args) {
        Zi z=new Zi();
        z.ziShow();
    }
}
 class Fu {
    String name="Fu";
}
 class Zi extends Fu{
    String name="Zi";
    public void ziShow(){
        String name="ziShow";
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }
}

运行结果：

继承中成员变量访问特点：就近原则

就近原则：先在局部位置找，本类成员位置找，父类成员位置找，逐级往上

代码示范：

package a06extendsdemo3;

public class Test2 {
    public static void main(String[] args) {
        Zi2 z=new Zi2();
        z.show();

    }
}
class Fu2{
    String name="Fu";
    String hobby="喝茶";
}
class Zi2 extends Fu2{
    String name="Zi";
    String game="吃鸡";
    public void show(){
        //如何打印Zi
        System.out.println(name);//Zi
        System.out.println(this.name);//Zi
        //如何打印Fu
        System.out.println(super.name);//Fu
        //如何打印喝茶
        System.out.println(hobby);//喝茶
        System.out.println(this.hobby);//喝茶
        System.out.println(super.hobby);//喝茶
        //如何打印吃鸡
        System.out.println(game);
        System.out.println(this.game);
    }
}

运行结果：

如果出现了重名的成员变量：

System.out.println(name);//从局部位置开始往上找
System.out.println(this.name);//从本类成员位置开始往上找
System.out.println(super.name);//从父类成员位置开始往上找

2.继承中成员方法的访问特点：

（1）直接调用满足就近原则：谁离得近就用谁

（2）super调用：直接访问父类

代码示范：

package a06extendsdemo3;

public class Test3 {
    public static void main(String[] args) {
        Student s1=new Student();
        s1.lunch();
        OverseasStudent s=new OverseasStudent();
        s.lunch();
    }
}
class Person{
    public void eat(){
        System.out.println("吃饭，吃菜");
    }
    public void drink(){
        System.out.println("喝水");
    }
}
class OverseasStudent extends Person{
    public void lunch(){
        this.eat();
        this.drink();

        super.eat();
        super.drink();
    }
    public void eat(){
        System.out.println("吃意大利面");
    }
    public void drink(){
        System.out.println("喝凉水");
    }
}
class Student extends Person{
    public void lunch(){
        eat();//前面有一个隐含的this
        drink();
        //方法在调用时需要有调用者，上面这种情况会触发就近原则
        //先在本类中查看eat和drink方法，如果有就会调用子类的，如果没有就会调用从父类中继承下来的

        super.eat();
        super.drink();
        //此时不会查看本类，直接调用父类中的eat和drink方法
    }
}

运行结果：

3.方法的重写：

当父类的方法不能满足子类现在的需求时，需要进行方法重写（上面例子中留学生吃意大利面，而父类中只有吃饭吃菜，不能满足留学生，所以需要在留学生类里进行方法重写）

书写格式：在继承体系中，子类出现了和父类中一模一样的方法声明，我们就称子类这个方法是重写的方法

注意：@Override重写注解：

1.@Override是放在重写后的方法上，校验子类重写时语法是否正确

2.加上注解后，如果有红色波浪线，表示语法错误

    @Override
    public void eat(){
        System.out.println("吃意大利面");
    }
    @Override
    public void drink(){
        System.out.println("喝凉水");
    }

方法重写的本质：如果发生了重写则会覆盖（图片来自哔站黑马程序员）

方法重写注意事项和要求：

1.重写方法的名称、形参列表必须与父类中的一致

2.子类重写父类方法时，访问权限子类必须大于等于父类（空着不写<protected<public）

3.子类重写父类方法时，返回值类型子类必须小于等于父类

4.建议：重写的方法尽量和父类保持一致

5.只有被添加到虚方法表中的方法才能被重写

练习：利用方法的重写设计继承结构

三种动物：哈士奇、沙皮狗、中华田园犬

暂时不考虑属性，只考虑行为，按照继承的思想特点进行继承体系的设计

三种动物的行为：哈士奇：吃饭（吃狗粮）、喝水、看家、拆家

沙皮狗：吃饭（吃狗粮，吃骨头）、喝水、看家

中华田园犬：吃饭（吃剩饭）、喝水、看家

狗：

package a07extendsdemo4;

public class Dog {
    public void eat(){
        System.out.println("狗吃狗粮");
    }
    public void drink(){
        System.out.println("狗喝水");
    }
    public void lookHome(){
        System.out.println("狗看家");
    }
}

哈士奇：

package a07extendsdemo4;

public class Husky extends Dog{
    //哈士奇有一个额外的方法：拆家
    public void breakHome(){
        System.out.println("哈士奇拆家");
    }
}

沙皮狗：

package a07extendsdemo4;

public class SharPei extends Dog{
    //因为沙皮狗吃狗粮和骨头
    //父类中的方法不能满足需求，所以需要重写

    @Override
    public void eat() {
        super.eat();//吃狗粮
        System.out.println("狗吃骨头");
    }
}

中华田园犬：

package a07extendsdemo4;

public class ChineseDog extends Dog{
    //父类中的方法不能满足需求，所以需要重写
    //而且中华田园犬完全用不到父类中的代码的，所以不需要通过super进行调用
    @Override
    public void eat(){
        System.out.println("吃剩饭");

    }
}

测试类：DogTest

package a07extendsdemo4;

public class DogTest {
    public static void main(String[] args) {
        //创建对象并调用方法
        Husky h=new Husky();
        h.eat();
        h.drink();
        h.lookHome();
        h.breakHome();

        ChineseDog cd=new ChineseDog();
        cd.eat();
        cd.drink();
        cd.lookHome();
    }
}

运行结果：