广告

扫码关注官方微信

扫码下载APP
返回顶部
首页 > 资讯 > 后端开发 > Python >Java基础之方法重写详解
  • 595

0
分享到

Java基础之方法重写详解

2024-04-02 19:04:59 595人浏览 安东尼

Python 官方文档：入门教程 => 点击学习

摘要

一、java方法重写 方法的重写是子类根据需求对父类继承的方法进行重新的编写，在重写时，可以使用super方法的方式来保留父类中的方法，注意:构造方法不可以被重写。 创建一个人类，属

一、java方法重写

方法的重写是子类根据需求对父类继承的方法进行重新的编写，在重写时，可以使用super方法的方式来保留父类中的方法，注意:构造方法不可以被重写。

创建一个人类，属性包括姓名 性别 年龄 行为方法是输出信息

二、super关键字

方法重写时要在子类中定义一个和父类相同名称的方法，并采用super关键字super.方法名();,这样就实现了方法的重写


package cn.zhz.Kind.dh;

public class Person1 {
    public String sex;
    public String name;
    public int age;

    public void showInfo() {
        System.out.println("姓名:" + name + "年龄:" + age + "性别:" + sex);
    }
}

创建一个学生类，属性包括学号 学科，行为方法是输出信息


package cn.zhz.Kind.dh;

public class Student1 extends Person1{
    public int stuId;
    public String stuSubject;
    public void showInfo(){
        super.showInfo();
        System.out.println("学号:"+ stuId+ "学科:"+ stuSubject);
    }
}

创建学生类的一个实例，进行赋值操作，赋值后输出


package cn.zhz.Case.dh;

import cn.zhz.Kind.dh.Student1;

public class Student1Test {
    public static void main(String[] args) {
        Student1 student1 = new Student1();
        student1.stuId = 1;
        student1.name = "张三";
        student1.age = 18;
        student1.sex = "男";
        student1.stuSubject = "物理";
        student1.showInfo();
    }
}

2.1 super关键字的介绍

super可以应用在子类访问父类成员中，比如说:

访问父类的属性super.print(); 注意是非private的方法
访问父类的方法super.name;
访问父类的构造方法super();


package cn.zhz.Inherit.dh;

public class Pet {
    private String name = "无名氏";
    private int health = 100;
    private int love = 0;
    public int age = 1;

    public Pet() {
        System.out.println("父类无参构造方法");
    }

    public Pet(String name) {
        this.name = name;
    }

    public Pet(String name, int health, int love) {
        //this可以调用本类的构造方法，且在第一行
        //this(name);
        this.name = name;
        this.health = health;
        this.love = love;
        System.out.println("父类带参构造方法");
    }

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

    public int getAge() {
        return age;
    }

    public void setHealth(int health) {
        if (health < 0 || health > 100) {
            System.out.println("宠物的健康值在0-100之间");
            this.health = 60;
            return;
        }
        this.health = health;
    }

    public int getHealth() {
        return this.health;
    }

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

    public String getName() {
        return this.name;
    }

    public void setLove(int love) {
        if (love < 0 || love > 100) {
            System.out.println("宠物的亲密度只能在0-100之间");
            this.love = 60;
            return;
        }
        this.love = love;
    }

    public int getLove() {
        return this.love;
    }

    //输出宠物的信息
    public void print() {
        System.out.println("宠物的自白:\n我的名字叫" + this.name + "健康值是" + this.health + "和主人的亲密度是:" + this.love);
    }
}


package cn.zhz.Inherit.dh;

public class Dog extends Pet {
    private String strain = "聪明的拉布拉多犬";

    public Dog() {
        System.out.println("子类狗狗的无参构造方法");
    }

    public Dog(String name, int health, int love, String strain) {
        //通过super调用父类的构造方法，必须是第一句
        //super();
        super(name, health, love);
        this.strain = strain;
        System.out.println("狗狗的带参构造方法");
    }

    public void setStrain(String strain) {
        this.strain = strain;
    }

    public String getStrain() {
        return this.strain;
    }

    public void print() {
        //调用父类的非private的print()方法
        super.print();
        System.out.println("我是一只" + this.strain);
    }

    public void m1() {
        //super不可以调用父类的private属性
//        System.out.println(super.name);
        System.out.println(super.age);
    }
}

在使用super关键字来访问父类的成员时，使用super关键字，super代表的是父类的对象，super只可以出现在子类的方法和构造方法中，使用super调用构造方法时，只可以是第一句，super不可以访问父类的private成员。

2.2 super关键字的使用

当子类中的方法重写了父类的方法，或者是在子类中定义了和父类的同名称的成员变量，使用super关键字可以使被屏蔽的成员可见。.


package cn.zhz.Inherit.dh;

public class Pet {
    private String name = "无名氏";
    private int health = 100;
    private int love = 0;
    public int age = 1;

    public Pet() {
        System.out.println("父类无参构造方法");
    }

    public Pet(String name) {
        this.name = name;
    }

    public Pet(String name, int health, int love) {
        //this可以调用本类的构造方法，且在第一行
        //this(name);
        this.name = name;
        this.health = health;
        this.love = love;
        System.out.println("父类带参构造方法");
    }

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

    public int getAge() {
        return age;
    }

    public void setHealth(int health) {
        if (health < 0 || health > 100) {
            System.out.println("宠物的健康值在0-100之间");
            this.health = 60;
            return;
        }
        this.health = health;
    }

    public int getHealth() {
        return this.health;
    }

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

    public String getName() {
        return this.name;
    }

    public void setLove(int love) {
        if (love < 0 || love > 100) {
            System.out.println("宠物的亲密度只能在0-100之间");
            this.love = 60;
            return;
        }
        this.love = love;
    }

    public int getLove() {
        return this.love;
    }

    //输出宠物的信息
    public void print() {
        System.out.println("宠物的自白:\n我的名字叫" + this.name + "健康值是" + this.health + "和主人的亲密度是:" + this.love);
    }
}

子类和父类中同时定义了一个age属性，子类调用这个age属性时先会在本类中找，这时可以使用super关键字代表父类，用super.属性的方式调用父类中的age属性


package cn.zhz.Inherit.dh;

public class Dog extends Pet {
    private String strain = "聪明的拉布拉多犬";
    private int age = 10;

    public Dog() {
        System.out.println("子类狗狗的无参构造方法");
    }

    public Dog(String name, int health, int love, String strain) {
        //通过super调用父类的构造方法，必须是第一句
        //super();
        super(name, health, love);
        this.strain = strain;
        System.out.println("狗狗的带参构造方法");
    }

    public void setStrain(String strain) {
        this.strain = strain;
    }

    public String getStrain() {
        return this.strain;
    }

    public void print() {
        //调用父类的非private的print()方法
        super.print();
        System.out.println("我是一只" + this.strain);
    }

    public void m1() {
        //super不可以调用父类的private属性
//        System.out.println(super.name);
        System.out.println(super.age);
    }

    public void m2() {
        //子类会覆盖服了诶的同名成员
        System.out.println(this.age);
        //可以使用super关键字调用父类被子类覆盖的成员
        System.out.println(super.age);
    }
}

super和this的区别

区别 this super
访问属性 访问本类的属性，如果没有则从父类中找 访问父类中的属性
访问方法 访问本类方法，如果没有从父类中找 访问父类的方法
访问构造方法 调用本类的构造方法，方法构造方法的首行 调用父类的构造方法，放在子类的构造方法的首行

总结的来说是this代表的是本类，而super代表的是父类
因为super代表的是父类，那么如果声明了多个类时，子类中如果要访问父类的父类的成员，难道要使用的是super.super.的方式吗?


package cn.zhz.Kind;

//爷爷类
public class Animal {
    private int age;
    private String sex;

    public int getAge() {
        return age;
    }

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

    public String getSex() {
        return sex;
    }

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

    public void print() {
        System.out.println("爷爷类下的方法");
    }
}


package cn.zhz.Kind;

public class Person extends Animal {
    public String name;

    public String getName() {
        return name;
    }

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


package cn.zhz.Kind;

//孙子类
public class Student extends Person {
    private String sid;

    public String getSid() {
        return sid;
    }

    public void setSid(String sid) {
        this.sid = sid;
    }

    @Override
    public void print() {
        //访问父类的父类的成员，不可以使用super.super.的方法，可以直接使用super.print();来进行调用
        super.print();
        System.out.println("这个是孙子类下的方法");
    }
}


package cn.zhz.Instance;

import cn.zhz.Kind.Student;

public class StudentTest {
    public static void main(String[] args) {
        Student student = new Student();
        student.print();
    }
}

Student孙子类调用Animal爷爷类时也是通过super.成员的方式来调用，这是因为java是只支持单根继承的，一个类只可以有一个直接父类，但是一个类可以有多个的间接父类

三、继承下的构造方法的调用规则


package cn.zhz.Kind;

public class Car {
    private int site = 4;
    Car(){
        System.out.println("载客量是"+site+"人");
    }
    public void setSite(int site){
        this.site = site;
    }
    public void print(){
        System.out.println("载客量是"+site+"人");
    }
}


package cn.zhz.Kind;

public class Bus extends Car{
    public Bus(int site){
        setSite(site);
    }
}

package cn.zhz.Instance;

import cn.zhz.Kind.Bus;

public class BusTest {
    public static void main(String[] args) {
        Bus bus = new Bus(20);
        bus.print();
    }
}

子类构造方法没有通过super显示调用父类的有参构造方法，也没有通过this显示调用自身的其他构造方法时，系统会默认调用父类的无参构造方法

子类构造方法通过super显示调用父类的有参构造方法时，执行父类相应的构造方法，而不执行父类无参构造方法

子类构造方法通过this显示调用自身的其他构造方法，在相应构造方法中应用以上的两条规则

四、深入理解方法重写

 方法重写规则

方法名称相同
参数列表相同
返回值类型相同或者是其子类
访问权限不可以严于父类
父类的静态方法不可以背子类覆盖为非静态方法，父类的非静态方法不可以背子类覆盖为静态方法
子类可以定义于父类同名的静态方法，以便在子类中隐藏父类的静态方法(静态方法中无法使用super)
父类的私有方法不可以被子类覆盖
不可以跑出比父类方法更多的异常


package cn.zhz.Kind;

public class Father {
    public void m1() {
        System.out.println("父类的m1的方法");
    }
    //同一个类中同名不同参的是方法重载
    public String m1(int num1){
        return "test";
    }
    //方法返回值类型可以是自定义的数据类型
    public Father m2() {
        System.out.println("父类的m2方法");
        return new Father();
    }
    public static void m3(){
        System.out.println("父类的静态方法m3");
    }
    private void m4(){
        System.out.println("父类的私有方法m4");
    }
}


package cn.zhz.Kind;

public class Son extends Father {
    //子类重写方法不可以比父类方法访问权限小，可以扩大方法的访问权限
    //子类方法只要访问权限不严于父类,就构成了方法重写
    public void m1() {
        System.out.println("子类重写后的m1方法");
    }
    //方法重写是父子类的同名同参的
    //子类方法返回值类型可以是父类方法返回值类型的子类，也是方法重写
    public Son m2() {
        System.out.println("子类重写后的m2方法");
        return new Son();
    }
    
    //在子类中可以定义和父类一模一样的静态方法
    public static void m3(){
        //在静态方法中不可以使用super
//        super.m3();
        Father.m3();
        System.out.println("子类的非静态方法m3");
    }
    public static void main(String[] args) {
        Son son = new Son();
        son.m1();
        son.m2();
        Son.m3();
    }
}
比较项 位置 方法名称 参数列表 返回值 权限访问修饰符
方法重写 子类 相同 相同 相同或是其子类 不可以比父类更严格
方法重载 同类 相同 不相同 无关 无关

到此这篇关于Java基础之方法重写详解的文章就介绍到这了,更多相关java方法重写内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！

您可能感兴趣的文档:
点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料

--结束END--

本文标题: Java基础之方法重写详解

本文链接: https://www.lsjlt.com/news/125231.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑，方便收藏和打印～

下载Word文档
去做题
猜你喜欢
  • Java基础之方法重写详解
    一、java方法重写 方法的重写是子类根据需求对父类继承的方法进行重新的编写，在重写时，可以使用super方法的方式来保留父类中的方法，注意:构造方法不可以被重写。 创建一个人类，属...
    99+
    2022-11-12
  • java基础之方法和方法的重载详解
    目录一、带参方法1.1 带参方法的定义和调用1.2 带参方法使用注意事项1.3 带参方法的应用1.4 基本数据类型和引用数据类型传参时的区别1.5 方法传参-对象数组二、构造方法2....
    99+
    2022-11-12
  • Java基础之重载(Overload)与重写(Override)详解
    目录一、重载（Overload）二、重写(Override)三、重写与重载之间的区别四、总结一、重载（Overload） 重载是在一个类里面，方法名字相同，而参数不同。返回类型可以相...
    99+
    2022-11-12
  • java基础之方法详解
    目录一、什么是方法二、方法的定义三、方法的调用四、方法的重载五、递归一、什么是方法 Java方法是语句的集合，他们在一起执行一个功能。 1.方法是解决一类问题的步骤的有序...
    99+
    2022-11-12
  • Java基础之详解HashSet的使用方法
    Java HashSet HashSet 基于 HashMap 来实现的，是一个不允许有重复元素的集合。 HashSet 允许有 null 值。 HashSet 是无序的，即不会记录...
    99+
    2022-11-12
  • Java基础学习之构造方法详解
    目录一、构造方法概述二、构造方法的注意事项三、标准类制作一、构造方法概述 构造方法是一种特殊的方法 作用：创建对象Student stu = new Student(); 格式： p...
    99+
    2022-11-13
  • 【Java 基础】类和对象 & 方法重载详解
    《Java 零基础入门到精通》专栏持续更新中。通过本专栏你将学习到 Java 从入门到进阶再到实战的全套完整内容，所有内容均将集中于此专栏。无论是初学者还是有经验的开发人员，都可从本专栏获益。 ...
    99+
    2023-10-10
    java 开发语言 后端
  • Java基础之Maven详解
    目录一、Maven环境的搭建1. 为什么要学习Maven?2. Maven项目架构管理工具3. 下载安装Maven4. 配置环境变量5. 阿里云...
    99+
    2022-11-12
  • Java基础之StringBuffer详解
    目录一、前言二、用法三、结果四、长度 容量五、IStringBuffer接口六、value和capacity一、前言 StringBuffer是可变长的字符串 1.append 追加...
    99+
    2022-11-12
  • Java基础之ClassLoader详解
    目录一、ClassLoader简介二、内置的CLassLoader的类型三、BootstrapClassLoader四、ExtClassLoader五、AppClassLoader六...
    99+
    2022-11-12
  • Java基础之FastJson详解
    目录一、fastJson将json格式字符串转化成List集合二、fastJson将json格式字符串转化成对象三、FastJson将对象或集合转化成json格式字符串四、FastJ...
    99+
    2022-11-12
  • Java基础之TreeMap详解
    目录一、写在前面二、定义三、成员变量四、内部类五、构造器六、成员方法一、写在前面 TreeMap的底层数据结构是红黑树，且TreeMap可以实现集合元素的排序。 所以TreeMap...
    99+
    2022-11-12
  • 【Java 基础】类和对象 & 方法重载详解
    《Java 零基础入门到精通》专栏持续更新中。通过本专栏你将学习到 Java 从入门到进阶再到实战的全套完整内容，所有内容均将集中于此专栏。无论是初学者还是有经验的开发人员，都可从本专栏获益。 订阅专栏后添加我微信或者进交流群，...
    99+
    2023-08-21
    java 开发语言 后端
  • Java基础之FastJson的解决方法
    这篇文章主要介绍了Java基础之FastJson的解决方法，具有一定借鉴价值，感兴趣的朋友可以参考下，希望大家阅读完这篇文章之后大有收获，下面让小编带着大家一起了解一下。一、fastJson将json格式字符串转化成List集合注：json...
    99+
    2023-06-15
  • Java基础之数组详解
    目录前言二.创建数组三.数组的使用四.数组的遍历五.数组作为方法的参数六.数组相关方法Arrays前言 我们了解数组这个概念之前，我们先思考下面几个问题。 如果我们需要两个数据，那么...
    99+
    2022-11-12
  • Java基础之Object类详解
    object类的介绍 object是所有类的直接父类或者是间接父类，为什么这么说呢？ 可以查询java8的API帮助文档: 可见在这样的一个类树中，所有的类的根还是Object类 ...
    99+
    2022-11-12
  • 详解Java基础之封装
    目录Java基础知识(封装)封装封装的目的 封装的好处封装的步骤封装的例子总结Java基础知识(封装) 封装 那封装是什么呢？ 在面向对象程式设计方法中，封装（英语：Enc...
    99+
    2022-11-13
  • Java基础之反射详解
    目录前言一、一个需求引出反射二、反射入门三、反射原理图四、反射相关类五、反射调用优化前言 反射是我们框架的灵魂，反射也是我们框架的一个底层基石，没有反射也就没有框架，如果我们学好了反...
    99+
    2022-11-12
  • 【Java 基础篇】Java方法引用详解
    文章目录 导言一、方法引用的概念二、方法引用的语法三、方法引用的使用方法四、方法引用的限制和注意事项总结 导言 Java方法引用是Java 8引入的一项重要特性，它提供了一种简洁、可读...
    99+
    2023-09-02
    java jvm 开发语言
  • Java基础入门篇之如何理解方法和重载
    本篇内容介绍了“Java基础入门篇之如何理解方法和重载”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！一、什么是方法简单来说方法就是一段可以被...
    99+
    2023-06-15
软考高级职称资格查询
软考职称历年真题下载
软考职称资料下载
热门wiki
近期文章
推荐阅读
热门问答
热门标签
编程网，编程工程师的家园，是目前国内优秀的开源技术社区之一，形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容，为IT开发者提供了一个发现、使用、并交流开源技术的平台。

  • 官方手机版

  • 微信公众号

  • 商务合作