java继承

于 2023-08-15 21:09:33 发布
阅读量49 收藏
点赞数
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangxx12138/article/details/132307164
版权

继承

1.1 继承快速入门

面向对象编程有三大特征，继承、封装和多态。接下来分享一下继承。

在这里插入图片描述

接下来，我们演示一下使用继承来编写代码，注意观察继承的特点。

public class Jianlin {
    // 公开成员
    public long money;
    public void youTin(){}

    // 私有成员
    private String waZi;
    private void shouJi(){}
}

然后，写一个SiCong类，让SiCong类继承Jianlin类。在继承Jianlin类的同时，SiCong类中新增一个方法paiDui()

public class SiCong extends Jianlin{

    // 子类可以继承父类的非私有成员
    public void paiDui(){
        //由于money和youTin()是属于父类的公有成员，在子类中可以直接被使用
        System.out.println(money);
        youTin();

        //由于waZi和shouJi()是属于父类A的私有成员，在子类中不可以被使用
        // System.out.println(waZi);
        // shouJi();
    }
}

接下来，我们再演示一下，创建SiCong类对象，能否调用父类Jianlin的成员。

写一个测试类

public class Test {
    public static void main(String[] args) {
        // 目标：认识继承、掌握继承的特点。
        SiCong siCong = new SiCong();
		//父类公有成员，子类对象是可以调用的
        System.out.println(siCong.money);
        siCong.youTin();

        //父类私有成员，子类对象时不可以调用的
        // System.out.println(siCong.waZi);
        // siCong.shouJi();
    }
}

继承的内存原理。

我们需要关注一点：子类对象实际上是由子、父类两张设计图共同创建出来的。

所以，在子类对象的空间中，既有本类的成员，也有父类的成员。但是子类只能调用父类公有的成员。

在这里插入图片描述

1.2 继承的好处(重点)

继承的好处我们只需要记住：继承可以提高代码的复用性

  • Cat
public class Cat {
    private String name;
    private int age;

    public void say() {
        System.out.println(getName() + "在叫");
    }

    public void catchMouse() {
        System.out.println("猫捉老鼠");
    }

    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;
    }
}
  • Dog
public class Dog {
    private String name;
    private int age;

    public void say() {
        System.out.println(getName() + "在叫");
    }

    public void watchDoor() {
        System.out.println("看门");
    }

    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;
    }
}
  • 最后再写一个测试类，再测试类中创建Teacher、Consultant对象，并调用方法。
public class Test {
    public static void main(String[] args) {
        // 目标：搞清楚继承的好处。
        Cat cat = new Cat();
        // 重复代码放到了父类中
        cat.setName("傻猫");
        cat.setAge(3);
        cat.say();
        // 子类独有的代码
        cat.catchMouse();

        Dog dog = new Dog();
        // 重复代码放到了父类中
        dog.setName("来财");
        dog.setAge(5);
        dog.say();
        // 子类独有的代码
        dog.watchDoor();
    }
}

执行代码，打印结果如下：

继承的好处我们只需要记住：继承可以提高代码的复用性

1.3 权限修饰符

刚才使用继承编写的代码中我们有用到两个权限修饰符，一个是public（公有的）、一个是private（私有的），实际上还有两个权限修饰符，一个是protected（受保护的）、一个是缺省的（不写任何修饰符）。

什么是权限修饰符呢？

权限修饰符是用来限制类的成员（成员变量、成员方法、构造器…）能够被访问的范围。

每一种权限修饰符能够被访问的范围如下

在这里插入图片描述

下面我们用代码演示一下，在本类中可以访问到哪些权限修饰的方法。

public class Fu {
    // 1、私有:只能在本类中访问
    private void privateMethod(){
        System.out.println("==private==");
    }

    // 2、缺省：本类，同一个包下的类
    void method(){
        System.out.println("==缺省==");
    }

    // 3、protected: 本类，同一个包下的类，任意包下的子类
    protected void protectedMethod(){
        System.out.println("==protected==");
    }

    // 4、public： 本类，同一个包下的类，任意包下的子类，任意包下的任意类
    public void publicMethod(){
        System.out.println("==public==");
    }

    public void test(){
        //在本类中，所有权限都可以被访问到
        privateMethod(); //正确
        method(); //正确
        protectedMethod(); //正确
        publicMethod(); //正确
    }
}

接下来，在和Fu类同一个包下，创建一个测试类Demo，演示同一个包下可以访问到哪些权限修饰的方法。

public class Demo {
    public static void main(String[] args) {
        Fu f = new Fu();
        // f.privateMethod();	//私有方法无法使用
        f.method();
        f.protectedMethod();
        f.publicMethod();
    }
}

接下来，在另一个包下创建一个Fu类的子类，演示不同包下的子类中可以访问哪些权限修饰的方法。

public class Zi extends Fu {
    //在不同包下的子类中，只能访问到public、protected修饰的方法
    public void test(){
        // privateMethod(); // 报错
        // method(); // 报错
        protectedMethod();	//正确
        publicMethod();	//正确
    }
}

接下来，在和Fu类不同的包下，创建一个测试类Demo2，演示一下不同包的无关类，能访问到哪些权限修饰的方法；

public class Demo2 {
    public static void main(String[] args) {
        Fu f = new Fu();
        // f.privateMethod(); // 报错
        // f.method();		  //报错
        // f.protecedMethod();//报错
        f.publicMethod();	//正确

        Zi zi = new Zi();
        // zi.protectedMethod();
    }
}

1.4 单继承、Object(重点)

一个子类可以继承多个父类吗？

Java语言只支持单继承，不支持多继承，但是可以多层继承。就像家族里儿子、爸爸和爷爷的关系一样：一个儿子只能有一个爸爸，不能有多个爸爸，但是爸爸也是有爸爸的。

在这里插入图片描述

public class Test {
    public static void main(String[] args) {
        // 目标：掌握继承的两个注意事项事项。
        // 1、Java是单继承的：一个类只能继承一个直接父类；
        // 2、Object类是Java中所有类的祖宗。
        A a = new A();
        B b = new B();

        ArrayList list = new ArrayList();
        list.add("java");
        System.out.println(list.toString());
    }
}

class A {} //extends Object{}
class B extends A{}
// class C extends B , A{} // 报错
class D extends B{}

1.5 方法重写(重点)

在继承的基础之上还有一个很重要的现象叫做方法重写。

什么是方法重写

当子类觉得父类方法不好用，或者无法满足子类需求时，子类可以重写一个方法名称、参数列表一样的方法，去覆盖父类的这个方法，这就是方法重写。

注意：重写后，方法的访问遵循就近原则。下面我们看一个代码演示

写一个A类作为父类，定义两个方法print1和print2

public class A {
    public void print1(){
        System.out.println("111");
    }

    public void print2(int a, int b){
        System.out.println("111111");
    }
}

再写一个B类作为A类的子类，重写print1和print2方法。

public class B extends A{
    // 方法重写
    @Override // 安全，可读性好
    public void print1(){
        System.out.println("666");
    }


    // 方法重写
    @Override
    public void print2(int a, int b){
        System.out.println("666666");
    }
}

接下来，在测试类中创建B类对象，调用方法

public class Test {
    public static void main(String[] args) {
        // 目标：认识方法重写，掌握方法重写的常见应用场景。
        B b =  new B();
        b.print1();
        b.print2(2, 3);
    }
}

执行代码，我们发现真正执行的是B类中的print1和print2方法

在这里插入图片描述

方法重写注意事项：

- 1.重写的方法上面，可以加一个注解@Override,用于标注这个方法是复写的父类方法
- 2.子类复写父类方法时，访问权限必须大于或者等于父类方法的权限
	public > protected > 缺省
- 3. 重写的方法返回值类型，必须与被重写的方法返回值类型一样，或者范围更小
- 4. 私有方法、静态方法不能被重写，如果重写会报错。

关于这些注意事项，同学们其实只需要了解一下就可以了。实际上我们实际写代码时，只要和父类写的一样就可以（ 总结起来就8个字：声明不变，重新实现）

方法重写的应用场景

学习完方法重写之后，接下来，我们还需要大家掌握方法重写，在实际中的应用场景。方法重写的应用场景之一就是：子类重写Object的toString()方法，以便返回对象的内容。

比如：有一个Student类，这个类会默认继承Object类。

public class Student extends Object{
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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;
    }
}

其实Object类中有一个toString()方法，直接通过Student对象调用Object的toString()方法，会得到对象的地址值。

public class Test {
    public static void main(String[] args) {
        Student s = new Student("播妞", 19);
        // System.out.println(s.toString());
        System.out.println(s);
    }
}

在这里插入图片描述

但是，此时不想调用父类Object的toString()方法，那就可以在Student类中重新写一个toSting()方法，用于返回对象的属性值。

package com.itheima.d12_extends_override;

public class Student extends Object{
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

重新运行测试类，结果如下

在这里插入图片描述

1.6 子类中访问成员的特点

继承至少涉及到两个类，而每一个类中都可能有各自的成员（成员变量、成员方法），就有可能出现子类和父类有相同成员的情况，那么在子类中访问其他成员有什么特点呢？

  • 原则：在子类中访问其他成员（成员变量、成员方法），是依据就近原则的

定义一个父类，代码如下

public class F {
    String name = "父类名字";

    public void print1(){
        System.out.println("==父类的print1方法执行==");
    }
}

再定义一个子类，代码如下。有一个同名的name成员变量，有一个同名的print1成员方法；

public class Z extends F {
    String name = "子类名称";
    public void showName(){
        String name = "局部名称";
        System.out.println(name); // 局部名称
    }

    @Override
    public void print1(){
        System.out.println("==子类的print1方法执行了=");
    }

    public void showMethod(){
        print1(); // 子类的
    }
}

接下来写一个测试类，观察运行结果，我们发现都是调用的子类变量、子类方法。

public class Test {
    public static void main(String[] args) {
        // 目标：掌握子类中访问其他成员的特点：就近原则。
        Z z = new Z();
        z.showName();
        z.showMethod();
    }
}
  • 如果子类和父类出现同名变量或者方法，优先使用子类的；此时如果一定要在子类中使用父类的成员，可以加this或者super进行区分。
public class Z extends F {
    String name = "子类名称";

    public void showName(){
        String name = "局部名称";
        System.out.println(name); // 局部名称
        System.out.println(this.name); // 子类成员变量
        System.out.println(super.name); // 父类的成员变量
    }

    @Override
    public void print1(){
        System.out.println("==子类的print1方法执行了=");
    }

    public void showMethod(){
        print1(); // 子类的
        super.print1(); // 父类的
    }
}

1.7 子类中访问构造器的特点

子类中访问构造器的语法规则

  • 首先，子类全部构造器，都会先调用父类构造器，再执行自己。

    执行顺序，如下图按照① ② ③ 步骤执行：
    在这里插入图片描述

子类访问构造器的应用场景

  • 如果不想使用默认的super()方式调用父类构造器，还可以手动使用super(参数)调用父类有参数构造器。

在这里插入图片描述

在本类中访问自己的构造方法

刚才我们学习了通过super()和super(参数)可以访问父类的构造器。有时候我们也需要访问自己类的构造器。语法如下

this(): 调用本类的空参数构造器
this(参数): 调用本类有参数的构造器

在这里插入图片描述

zhangxx12138
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Java继承超详细
霖hero
03-03 5万+
前言 继承是面向对象语法的三大特征之一。继承可以降低代码编写的冗余度，提高编程的效率。通过继承，子类获得了父类的成员变量和方法。一个子类如何继承父类的字段和方法，如何修改从父类继承过来的子类的方法呢。今天我们开始学习有关Java继承的知识。 继承 继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。 继承的作用：通过继承可以快速创建新的类，实现代码的重用，提高程序的可维护性，节省大量创建新类的时间，提高开发效率和开发质量。
java继承关键字_Java继承
weixin_42168230的博客
02-19 1720
继承的特性子类拥有父类非 private 的属性、方法。子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。子类可以用自己的方式实现父类的方法。Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 A 类继承 B 类，B 类继承 C 类，所以按照关系就是 C 类是 B 类的父类，B 类是 A 类的父类，这是 Java 继承区别于 C++ 继承的一个...
Java坦克大战
Daxi595的博客
06-16 1455
Java
Java 继承
南辞的博客
11-06 7746
面向对象三大特征之二：继承
Java继承
m0_60591654的博客
11-21 2593
1.概念. java中可以通过extends关键字表示继承关系，extends左边的是子类，右边的类是父类。 2.好处. 继承可以实现代码的复用，实现代码的扩展。 3.继承使用细节. 1⃣️子类继承父类的所有属性和方法，可以直接访问父类的非私有属性和方法，不能直接访问私有属性和方法，必须通过公共的方法来访问 2⃣️子类必须调用父类的构造器，完成父类的初始化 3⃣️如果父类没有默认的无参构造器，子类必须显示的调用父类的有参构造器 4⃣️如果子类想调用父类的某个构造器，必须在子类的构造器中显示调
JAVA 继承
啊Q老师
12-05 3742
JAVA 类的封装
Java继承（超详解）
最新发布
m0_52896041的博客
07-18 2万+
继承是面向对象的三大特征之一，可以使得子类具有父类的属性和方法，还可以在子类中重新定义，追加属性和方法。继承是指在原有类的基础上，进行功能扩展，创建新的类型。继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。JAVA中类只有单继承，没有多继承!继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等。继承关系的两个类，一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示。子类和父类之间,从意义上讲应该具有"is a"的关系。
Java继承实例
赵继源的博客
04-10 8043
创建父类Animal和两个子类Dog、Penguin，创建测试文件Animal_Test。将四个文件放在一个包里“主题六_类和对象的高级应用” 1、父类Animal package 主题六_类和对象的高级应用; //定义一个公共类作为父类 public class Animal { private String name; private int month; private String species; //初始化属性值 public Animal() { } ..
java 继承关键字_Java继承
weixin_29798865的博客
02-12 3170
继承的概念继承是Java面向对象编程的基石，因为它允许创建分等级层次的类。生活中的继承：类的继承格式class 父类{}class 子类 extends 父类{}继承类型需要注意的是Java不支持多继承，但支持多重继承。继承的特性子类拥有父类非private的属性、方法。子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。子类可以用自己的方式实现父类的方法。Java的继承是单继承，但是可以多重...
Java继承详解
01-20
什么是继承？ 　多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。... 　1.Java只支持单继承，不支持多继承。 　//一个类只能有
图解Java继承内存分配
01-20
　（1）Java不支持多继承，也是说子类至多只能有一个父类。 　（2）子类继承了其父类中不是私有的成员变量和成员方法，作为自己的成员变量和方法。 　（3）子类中定义的成员变量和父类中定义的成员变量相同时，...
java教程之java继承示例详解
09-04
"java继承示例详解" java继承是指新定义的类从已有的类中获取属性和方法的现象。这个已有的类叫做父类，而从这个父类获取属性和方法的类叫做子类。继承的主要优点是提高了代码的重用性，让类和类之间产生了关系，为...
java继承类实例
12-19
在这个特定的程序中，我们看到了一个关于Java继承的实例，它演示了子类对象初始化时涉及的各个步骤，包括构造方法、初始化值、父类构造方法以及父类的初始化值。 首先，我们有一个名为`Parent`的父类，它有两个实例...
Java继承方法重写实现原理及解析
08-25
Java继承方法重写实现原理及解析 Java继承方法重写是面向对象编程中的一种重要概念，指的是子类可以继承父类的方法，并对其进行修改或扩展。下面是Java继承方法重写的实现原理及解析。 一、继承方法重写的定义 ...
Java 继承原理与用法实例分析
08-25
Java 继承原理与用法实例分析 Java 继承是面向对象编程技术的基石之一，它允许创建分等级层次的类。继承的概念是指子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，...
JAVA 继承例题
09-12
在Java编程语言中，继承是...解压"InheritanceSolution"文件，你应该能看到一系列的示例代码和练习，通过这些例子，你可以更好地掌握Java继承的实际应用。在实践中不断学习和改进，你的Java编程技能会得到显著提升。
Java继承上
05-03
Java是完全对象化的程序语言,编程重点在于产生对象、操作对象以及如何使对象能一起协调工作,以实现程序的功能。 2.语法简单 Java语言的语法结构类似于C和C++,熟悉
Java继承与类型转换详解
"Java继承是面向对象编程中的一个重要概念，允许一个类（子类）继承另一个类（父类）的属性和方法。这种机制使得代码重用和类的组织更加高效。强制类型转换在此过程中扮演关键角色，允许我们根据需要在父类和子类...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值