Java继承与方法的重写

于 2024-07-23 18:06:35 发布
阅读量401 收藏 19
点赞数 11
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_70718945/article/details/140641236
版权

一、继承

1.什么是继承？

父类怎么形成的：我们定义了多个类，发现这些类中有很多重复性的代码，我们就定义了一个父类，将相同的代码抽取出来，放到父类中，其他类直接继承这个父类，就可以直接使用父类中的内容了

2.继承的基本使用

第一步：定义一个父类，在其中定义重复性的代码

第二步：定义一个子类继承父类->extends

        子类  extends  父类

第三步：创建子类对象，直接使用父类中非私有成员，但是不能使用父类中的私有成员

public class Employee {
    String name;
    int age;


    public void work(){
        System.out.println("工作");

    }

    private void eat(){
        System.out.println("员工要吃饭");
    }
}
public class Manager extends Employee {
}






public class Teacher extends Employee {
}






public class Test01 {
    public static void main(String[] args) {

        Teacher teacher=new Teacher();
        teacher.name="明哥";
        teacher.age=18;
        System.out.println(teacher.name+"..."+teacher.age);

        teacher.work();
        //teacher.eat;   子类继承父类之后不能使用私有成员，只能使用父类非私有成员

        System.out.println("================");

        Manager manager = new Manager();
        manager.name="名";
        manager.age=18;
        System.out.println(manager.name+".."+manager.age);
        manager.work();


    }
}

3.继承中成员的访问特点

3.1成员变量

（1）子类和父类中的成员变量不重名

（2）子类和父类中的成员变量重名

public class Fu {
    int numFu=100;

    int num=1000;
}

public class Zi extends Fu {
    int numZi=10;

    int num=100000;
}
public class Test01 {
    public static void main(String[] args) {
        //创建父类对象
        Fu fu = new Fu();
        System.out.println(fu.numFu);
       // System.out.println(fu.numZi);//不能调用子类特有的成员
        System.out.println(fu.num);

        System.out.println("========");
        //创建子类对象
        Zi zi=new Zi();
        System.out.println(zi.numZi);
        System.out.println(zi.numFu);//继承了父类，可以使用父类中的非私有成员

        System.out.println(zi.num);

    }
}

总结：看等号左边是谁，先调用谁中的成员

     如果等号左边是父类类型，只能调用父类中的成员变量，如果是子类类型，既能调用子类的，还能调用父类中继承过来的非私有成员

继承前提下，成员变量访问特点口诀

（同样适用于多态）看等号左边是谁，先调用谁中的成员，子类没有，找父类

3.2成员方法

（1）子类和父类中的成员方法不重名

（2）子类和父类中的成员方法重名

public class Fu {

    public void methodFu() {

        System.out.println("我是父类中的methodFu");
    }

    public void  method(){
        System.out.println("我是父类的method");
    }
}

public class Zi extends Fu{
    public void methodZi(){
        System.out.println("我是子类中的methodZi");
    }
    public void  method(){
        System.out.println("我是子类的method");
    }
}

public class Test01 {
    public static void main(String[] args) {
        Fu fu=new Fu();
        fu.methodFu();
        fu.method();


        System.out.println("============");
        Zi zi=new Zi();
        zi.methodZi();
        zi.methodFu();//继承父类之后，能调用父类非私有成员
        zi.method();

    }
}

二、方法的重写

概述：子类中有一个和父类的方法名以及参数列表相同的方法

前提：继承

访问：看new的是谁，先调用谁中的，如果new的是子类，调用子类重写的方法，子类没有找父类

检测是否为重写方法：在该方法上写   @Override


public class Fu {
    public void methodFu(){
        System.out.println("我是父类中的methodFu方法");
    }

    public void method(){
        System.out.println("我是父类中的method方法");
    }

    public void method01(){


    }

    public Fu method03(){

        return null;
    }

}


public class Zi extends Fu {
    public void methodZi(){
        System.out.println("我是子类中的methodzZi");
    }



    @Override
    public  void method(){
        System.out.println("我是子类中的method方法");
    }

    @Override
    public void method01(){

    }



    @Override
    public Zi method03(){

        return null;
    }

}

public class Test01 {
    public static void main(String[] args) {
        Fu fu=new Fu();
        fu.methodFu();
        fu.method();

        System.out.println("=============");
        Zi zi=new Zi();
        zi.methodFu();
        zi.methodZi();
        zi.method();

    }


}

注意事项：

子类重写父类方法之后，权限必须保证大于等于父类权限（权限指的是访问权限）

由大到小   public -> protected ->  默认（不写任何权限修饰符）->private

子类方法重写父类方法，方法名和参数列表一样

私有方法不能被重写，构造方法不能被重写，静态方法不能被重写

子类重写父类方法以后，返回值类型应该是父类方法返回值类型的子类类型

使用场景

功能升级改造，子类需要对父类中已经实验好的功能进行重新改造

三、super和this

1.继承中构造方法的特点

注意：new子类对象时，会先初始化父类（先走父类无参构造方法）

原因：每个构造方法第一行，默认都会有一个super（）,不写jvm（虚拟机）自动提供一个

  Super()代表的是父类无参构造

public class Fu {
    public Fu(){
        System.out.println("我是父类中的无参构造");
    }
}
public class Zi extends Fu{

    public Zi(){
        super();
        System.out.println("我是子类中的无参构造");
    }

    public Zi(int i){
        System.out.println("我是子类中的有参构造");
    }
}


public class Test {
    public static void main(String[] args) {
        Zi zi = new Zi();
        System.out.println("===============");

        Zi zi1=new Zi(10);
    }
}

2.super的具体使用

概述：代表的是父类引用

作用：可以调用父类中的成员

使用： 调用父类构造方法->在子类中的构造中写

             Super（）->调用父类无参构造

             Super（实参）->调用父类有参构造

        

         调用父类成员变量

             Super.成员变量

         调用父类成员方法

              Super.成员方法（实参）

public class Zi extends Fu{
    int num=100;
    public Zi(){
        super();//调用父类中的无参构造
        System.out.println("我是子类中的无参构造");
    }
    public Zi(int num){
        super(10);//调用父类中的有参构造
        System.out.println("我是子类中的有参构造");
    }

    public void method(){
        super.method();//调用父类的method
        System.out.println("我是子类中的method方法");
        System.out.println(num);//子类自己的

        System.out.println(super.num);//调用父类的sum
    }
}
public class Fu {
    int num=10;
    public Fu(){
        System.out.println("我是父类中的无参构造");
    }

    public Fu(int data){
        System.out.println("我是父类中的有参构造");
    }

    public  void method(){
        System.out.println("我是父类中的method方法");
    }
}

public class Test01 {
    public static void main(String[] args) {

        Zi zi=new Zi();

        System.out.println("===============");
        Zi zi1=new Zi(10);
        System.out.println("============");
        Zi zi2 = new Zi();
        zi2.method();

    }
}

3.this的具体使用

概述：代表的是当前对象（那个对象调用this所在的方法，this就代表哪个对象）

作用：区分重名的成员变量和局部变量

     调用当前对象中的成员

使用：调用当前对象的构造：在构造中写

  This（）：调用当前对象的无参构造

  This（实参）：调用当前对象的有参构造

调用当前对象的成员变量：

  This.成员变量名

调用当前对象的成员方法：

        This.成员方法名（实参）

注意：不管是super还是this，只要在构造中使用，都必须在第一行，所以二者不能同时手写出来

public class Person {
    int num=10;

    public Person() {
       // this(10);
        System.out.println("我是person中的无参构造");

    }

    public Person(int data) {
      this();

      System.out.println("我是person中的有参构造");

    }

    public void method(){
        int num=20;
        System.out.println(num);//20
        System.out.println(this.num);
        this.method01();
        method01();
        System.out.println("我是Person中的method方法");
    }

    public  void method01(){
        System.out.println("我是person类中的method01方法");
    }
}
public class Test01 {
    public static void main(String[] args) {
        Person person=new Person();
        System.out.println("========");
        Person person1 = new Person(10);
        System.out.println("==========");
        Person person2 = new Person();
        person2.method();


    }
}

4.继承的特点

（1）继承只支持单继承，不能多继承      public  class  A  extends  B，C{}  ->错误

（2）继承支持多继承

       Public  class  A  extends  B{}

       Public  class  B  extends  C{}  

（3）一个父类可以有多个子类

        Public  class  A  extends  C{}

       Public  class  B  extends  C{}  

（4）构造方法不能继承，也不能重写

私有方法可以继承，但是不能被重写

静态方法可以继承，但是不能被重写

如何为父类中private的成员变量赋值（经验值）

（1）利用set赋值

（2）利用构造方法赋值

四、抽象

抽象类怎么来的：抽取共性的方法，放到父类中，发现方法没办法确定具体实现，因为每个子类对此方法的实现细节不一样，此时方法体说不清，可以定义成抽象方法，抽象方法所在的类一定是抽象类

关键字：abstract

定义抽象方法：

  修饰符  abstract  返回值类型  方法名（参数）

抽象类：public abstract class类名{}

注意：抽象方法所在的类一定是抽象类

           抽象类不一定非得有抽象方法

          子类继承抽象父类时，需要重写父类中所有的抽象方法，不然编译报错

          抽象类不能new对象，只能通过new子类对象调用重写的方法

可以将抽象类看成是一类事物的标准，要求只要属于这一类的，都必须要拥有抽象类中的方法，必须要给我实现，怎么证明拥有了，怎么证明实现了？->重写

  至于这个方法怎么实现，就要看子类重写以后怎么写方法体了

抽象注意事项

  1. 抽象类不能直接new对象，只能创建非抽象子类的对象
  2. 抽象类中不一定非得有抽象方法，但是抽象方法所在的类一定是抽象类
  3. 抽象类的子类必须重写父类中的抽象方法否则编译报错，除非该子类也是抽象类
  4. 抽象类中可以有成员变量，构造，成员方法
  5. 抽象类中可以有构造方法，是供子类创建对象时，初始化父类属性使用的
public  abstract class Employee {
    private String name;
    private int age;

    public Employee() {
    }

    public Employee(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;
    }

    public abstract void work();
}
public class Teacher extends Employee {

    public Teacher() {
    }

    public Teacher(String name, int age) {
        super(name, age);
    }

    @Override
    public void work() {
        System.out.println("我在学习");
    }
}

public class Test01 {
    public static void main(String[] args) {

        Teacher teacher = new Teacher("名",1);
        System.out.println(teacher.getName()+".."+teacher.getAge());


    }
}

如有不足，请多多指教，谢谢

编程里的小白
关注
  • 11
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
16、JAVA入门——继承和方法重写
不迁怒，不贰过。小知识，大智慧。
09-15 1708
一、继承 1、基本概念 2、super关键字和子类对象 二、方法重写 1、概念 2、方法重写规则 3、方法重载和方法重写的区别 三、Object类 1、定义 2、Object类中的方法 3、Object类中的equals()方法
Java 继承和方法重写
05-13
4. **方法覆盖与方法隐藏**： - **方法覆盖**：子类中定义了与父类同名、同参数列表的方法，属于重写。 - **方法隐藏**：子类中定义了与父类同名但参数列表不同的方法，不属于重写，只是在子类中隐藏了父类的方法...
Java的继承与方法重写
ilzy957的博客
04-09 3499
Java的继承 继承的本质是对一批类的抽象。 extends关键字，意为拓展，其内子类是对父类的扩展。public class Student extends Person，意为Student类继承了Person的所有公开属性，以及方法。 继承属于类之间的一种关系，此外还有依赖、组合聚合等。 Java中只有单继承，没有多继承，就是一个子类只能有一个父类。 修饰符： public：公共的 可继承 private：私有的 不可继承 default：默认的 可继承 protect
Java继承与重写
AAAWell的博客
07-30 1761
Java继承与重写
java继承和方法重写及其练习题
m0_56420338的博客
12-08 1135
java继承及其练习题
Java语言中类的继承与方法重写
qq_44640357的博客
10-11 1192
类的继承，成员变量，成员方法，方法的重写，重写与重载
JAVA继承与重写
ypf3442354429的博客
04-27 1543
概念:继承是面向对象语法三大特征之一,继承可以降低代码的沉余度,提高编程的效率。通过继承子类可以随意调用父类中的某些属性与方法,一个子类只能继承一个父类,一个父类可以被多个子类继承。它就好比与我们显示生活中孩子继承父亲的财产。重写的好处在于子类可以根据需要，定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法,就好比金毛与哈士奇他的特征都是来自狗,仓鼠与松鼠他们他们的特征来自老鼠,而他们身上的不同属于基因突变就相当于重写 继承的特点: 1):java中只支持单根继承,即一个类只能有一个直接父类
Java方法重写的规则
✨ 欢迎来到【Seal ^_^ 的CSDN博客】！这里是我记录技术心得、分享经验的地方。✨
06-19 5133
在Java中，方法重写（Overriding）是面向对象编程中的一个核心概念，它允许子类提供一个与父类相同名称、相同参数列表的方法，以实现或修改父类方法的行为。
Java中子类继承和方法重写
weixin_68658847的博客
11-24 1444
Java中子类继承
Java 继承和方法重写（简单易理解,建议收藏）
m0_56392935的博客
10-31 2271
抛出的异常：范围，可以被缩小，但不能扩大：ClassNotFoundException --> Exception(大)//调用父类的构造器，必须要在子类构造器的第一行。继承是类和类之间的一种关系，除此之外，类和类之间的关系还有依赖，组合，聚合等。调用父类的无参构造，不写为默认调用父类的无参。没有static时，b调用的是对象的方法，而b是用A类new的。//student.test("落花");有static时，b调用了B类的方法，因为b是用b类定义的。私有的可以被继承，但不能被直接访问，可以间接访问。
Java中的继承与重写
Hulxx的博客
07-10 1916
Java中的继承与重写 1、继承：继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。 2、作用：子类一旦继承父类,就有权使用父类中的内容，子类中也可以扩展自己独有的内容 在 Java 中通过 extends 关键字可以申明一个类是从另外一个类继承而来的，例如： class JianLian{ public String name = "王健林"; } class SiCong extends JianLian{ p
Java继承方法重写实现原理及解析
08-25
Java继承方法重写实现原理及解析 Java继承方法重写是面向对象编程中的一种重要概念，指的是子类可以继承父类的方法，并对其进行修改或扩展。下面是Java继承方法重写的实现原理及解析。 一、继承方法重写的定义 ...
java方法重写实例分析
09-04
Java方法重写是面向对象编程中的一个重要概念，它允许子类根据需要修改或扩展从父类继承而来的行为。在Java中，当一个子类创建了与父类中相同名称、参数列表和返回类型的方法时，我们就说这个子类重写了父类的方法。...
Java方法覆盖重写实现原理解析
08-25
Java方法覆盖重写实现原理解析是Java编程语言中的一种重要机制，它允许子类继承父类的方法，并对父类方法进行修改或扩展，以满足特定的需求。本文将深入分析Java方法覆盖重写实现原理，介绍相关的注意事项和实践经验...
Java方法重载和重写原理区别解析
08-19
方法重写和重载是两个不同的概念，方法重写是指子类中的方法和父类中继承的方法有完全相同的返回值类型、方法名、参数个数和参数类型，方法重载是指在一个类中，多个方法的方法名相同，但是参数列表不同。方法重写是...
12. Hibernate 模板设计模式
最新发布
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1078
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Java内存模型
weixin_44267758的博客
07-19 761
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 737
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
接口防刷！利用redisson快速实现自定义限流注解
架构师小吴的博客
07-18 1294
如登录接口，当用户使用手机号+验证码登录时，一般我们会生成6位数的随机验证码，并将验证码有效期设置为1-3分钟，如果对登录接口不加以限制，理论上，通过技术手段，快速重试100000次，即可将验证码穷举出来。解决思路：对登录接口加上限流操作，如限制一分钟内最多登录5次，登录次数过多，就返回失败提示，或者将账号锁定一段时间。在日常开发中，一些重要的对外接口，需要加上访问频率限制，以免造成资��损失。ok，通过以上两步，即可完成我们的限流注解了，下面通过一个接口验证下效果。
Java继承与方法重写详解
"该资源是关于Java继承的课件，主要讲解了方法重写、继承层次、多态、动态绑定、final类和方法、抽象类、Object类以及equals和toString方法等面向对象编程的关键概念。其中，通过一个Person类的例子展示了如何进行...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值