Java面向对象基础（继承）

已于 2022-05-02 09:06:17 修改
阅读量285 收藏 1
点赞数 1
分类专栏： Java 文章标签： java eclipse
于 2022-04-24 22:11:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_56382303/article/details/124392143
版权

👨‍💻博客主页：i新木优子👀
🏆Java基础系列教程：传送门💦
🧚‍♂️寄语:种一棵树最好的时间是十年前,其次是现在👣
🎉欢迎关注🔍点赞👍收藏⭐留言📝
🙏作者水平有限,发现错误欢迎留言轰炸

文章目录

继承

1. 继承的概述

继承是面向对象三大特征之一，可以使得子类具有父类的属性和方法，还可以在子类中重新定义，追加属性和方法。

继承的格式：

  • 格式：public class 子类名 extends 父类名 {}
  • 示例：public class Zi extends Fu {}
  • Fu：是父类，也被称为基类，超类
  • Zi：是子类，也被称为派生类

继承中子类的特点：

  • 子类可以有父类的内容
  • 子类还可以有自己特有的内容
package com.company;

public class Fu {
    public void show() {
        System.out.println("show方法被调用");
    }
}

package com.company;

public class Zi extends Fu {
    public void method() {
        System.out.println("method方法被调用");
    }
}

package com.company;

public class Demo {
    public static void main(String[] args) {
        //创建方法，调用对象
        Fu f = new Fu();
        f.show();

        Zi z = new Zi();
        z.method();
        z.show();
    }
}

2. 继承的好处和弊端

继承的好处：

  • 提高的代码的复用性（多个类相同的成员可以放到同一个类中）
  • 提高的代码的维护性（如果方法的代码需要修改，修改一处即可）

继承的弊端：

  • 继承让子类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化，削弱了子类的独立性

什么时候使用继承：

  • 继承体现的关系：is a

  • 假设法：现在有两个类A和B，如果他们满足A是B的一种，或B是A的一种，就说明他们存在继承关系，这个时候，就可以考虑使用继承来体现，否则就不能滥用继承

  • 举例：🍎苹果和水果、🐱猫和动物、可以使用继承，🐱猫和🐕狗、不可以使用继承

3. 继承中变量的访问特点

在子类中访问一个变量：

  1. 子类局部范围找
  2. 子类成员范围找
  3. 父类成员范围找
  4. 如果都没有就报错（不考虑父亲的父亲…）
package com.company1;

public class Fu {
    //年龄
    public int age = 40;
}

package com.company1;

public class Zi extends Fu {
    //身高
    public int height = 185;

    //年龄
    public int age = 18;

    public void show() {
        int age = 30;
        System.out.println(age);
        System.out.println(height);
    }
}

package com.company1;

public class Demo {
    public static void main(String[] args) {
        //创建对象，调用方法
        Zi z = new Zi();
        z.show();
    }
}

4. super

super关键字的用法的this的用法相似

  • this：代表本类对象的调用
  • super：代表父类存储空间的标识（可以理解为父类对象的引用）

package com.company2;

public class Fu {
    public int age = 40;
}

package com.company2;

public class Zi extends Fu {
    public int age = 18;

    public void show() {
        int age = 30;
        System.out.println(age);
        //要访问本类中的成员变量age，怎么办？
        System.out.println(this.age);
        //要访问父类中的成员变量age，怎么办？
        System.out.println(super.age);
    }
}

package com.company2;

public class Demo {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show();
    }
}

5. 继承中构造方法的访问特点

子类中所有的构造方法默认都会访问父类中的无参构造方法

why是

  • 因为子类会继承父类中的数据，可能还会使用父类的数据，所以，子类初始化之前，一定要先完成父类数据的初始化
  • 每一个子类构造方法的第一条语句默认都是：super()

如果父类中没有无参构造方法，只有带参构方法，怎么办？

  • 通过使用super关键字去显示的调用父类的带参构造方法
  • 在父类中自己提供一个无参构造方法

推荐：自己给出无参构造方法

package com.company3;

public class Fu {

    /*
    public Fu() {
        System.out.println("Fu中的无参构造方法被调用");
    }
     */

    public Fu(){}

    public Fu(int age) {
        System.out.println("Fu中的带参构造方法被调用");
    }
}

package com.company3;

public class Zi extends Fu {
    public Zi() {
//        super(20);
        System.out.println("Zi中的无参构造方法被调用");
    }

    public Zi(int age) {
//        super(20);
        System.out.println("Zi中的带参构造方法被调用");
    }
}

package com.company3;

public class Demo {
    public static void main(String[] args) {
        //创建对象
        Zi z = new Zi();

        Zi z2 = new Zi(18);
    }
}

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

通过子类对象访问一个方法：

  1. 子类成员范围找
  2. 父类成员范围找
  3. 如果都没有就报错（不考虑父亲的父亲…）
package com.company4;

public class Fu {

    public void show() {
        System.out.println("Fu中的show()方法被调用");
    }
}

package com.company4;

public class Zi extends Fu {

    public void method() {
        System.out.println("Zi类中method()方法被调用");
    }

    public void show() {
        super.show();
        System.out.println("Zi中的show()方法被调用");
    }
}

package com.company4;

public class Demo {
    public static void main(String[] args) {
        //创建对象，调用方法
        Zi z = new Zi();
        z.method();
        z.show();
    }
}

7. 方法重写

方法重写的概述：

  • 子类中出现了和父类中一模一样的方法声明

方法重写的应用：

  • 当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容

@Override

  • 是一个注解
  • 可以帮助检查重写方法的方法声明的正确性
package com.company5;

/*
    手机类
 */
public class Phone {

    public void call(String name) {
        System.out.println("给" + name + "打电话");
    }
}

package com.company5;

/*
    新手机
 */
public class NewPhone extends Phone {

    /*
    public void call(String name) {
        System.out.println("开启视频");
//        System.out.println("给" + name + "打电话");
        super.call(name);
    }

     */

    @Override  //可以帮助检查方法重写的正确性
    public void call(String name) {
        System.out.println("开启视频");
//        System.out.println("给" + name + "打电话");
        super.call(name);
    }

}

package com.company5;

/*
    测试类
 */

public class PhoneDemo {
    public static void main(String[] args) {
        //创建对象，调用方法
        Phone p = new Phone();
        p.call("小新");
        System.out.println("----------");

        NewPhone np = new NewPhone();
        np.call("小新");
    }
}

8. 方法重写的注意事项

  1. 私有方法不能被重写（父类私有成员子类是不能继承的）
  2. 子类方法访问权限不能比父类的低（public > 默认 > 私有）
package com.company6;

public class Fu {

    private void show() {
        System.out.println("Fu中show方法被调用");
    }
    /*
    public void method() {
        System.out.println("Fu中method方法被调用");
    }
     */
    void method() {
        System.out.println("Fu中method方法被调用");
    }

}

package com.company6;

public class Zi extends Fu {

    /*
    @Override
    private void show() {
        System.out.println("Zi中show方法被调用");
    }
     */

    /*
    @Override
    public void method() {
        System.out.println("Zi中method方法被调用");
    }
     */

    @Override
    public void method() {
        System.out.println("Zi中method方法被调用");
    }
}

9. Java中继承的注意事项

  1. Java中类只支持单继承，不支持多继承
  2. Java中类支持多层继承
package com.company7;

public class Granddad {

    public void drink(){
        System.out.println("喝酒");
    }
}

package com.company7;

public class Father extends Granddad {

    public void smoke(){
        System.out.println("抽烟");
    }
}

package com.company7;

public class Son extends Father {
    
}

10. 案例

  1. 👨‍🏫老师和学生👨‍🎓

    需求：定义老师类和学生类，然后写代码测试，最后找到老师类和学生类的共性内容，抽取一个父类，用继承的方式改写代码，并进行测试

    package com.company9;

public class Person {
    private String name;
    private int age;

    public Person() {
    }

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

    package com.company9;

public class Teacher extends Person {
    public Teacher() {
    }

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

    public void teach() {
        System.out.println("教书");
    }
}

    package com.company9;

public class Student extends Person {
    public Student(String name, int age) {
        super(name, age);
    }

    public Student() {

    }

    public void study() {
        System.out.println("学习");
    }
}

    package com.company9;


public class PersonDemo {
    public static void main(String[] args) {
        //创建老师类对象
        Teacher t1 = new Teacher();
        t1.setName("小新");
        t1.setAge(18);
        System.out.println(t1.getName() + "," + t1.getAge());
        t1.teach();

        Teacher t2 = new Teacher("小新", 18);
        System.out.println(t2.getName() + "," + t2.getAge());
        t1.teach();

        //创建学生类对象
        Student s1 = new Student();
        s1.setName("小白");
        s1.setAge(19);
        System.out.println(s1.getName() + "," + s1.getAge());
        s1.study();

        Student s2 = new Student("小白", 19);
        System.out.println(s2.getName() + "," + s2.getAge());
        s2.study();
    }
}

  2. 🐈猫和狗🐕

    需求：请采用继承的思想实现猫和狗的案例，并在测试类中进行测试

    package com.company10;

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

    public Animal() {
    }

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

    package com.company10;

public class Cat extends Animal {
    public Cat() {
    }

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

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

    package com.company10;

public class Dog extends Animal {
    public Dog() {
    }

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

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

    package com.company10;

public class AnimalDemo {
    public static void main(String[] args) {
        //创建猫类对象
        Cat c1 = new Cat();
        c1.setName("加菲猫");
        c1.setAge(5);
        System.out.println(c1.getName() + "," + c1.getAge());
        c1.catchMouse();

        Cat c2 = new Cat("加菲猫", 5);
        System.out.println(c2.getName() + "," + c2.getAge());
        c2.catchMouse();

        //创建够类对象
        Dog d1 = new Dog();
        d1.setName("哈士奇");
        d1.setAge(5);
        System.out.println(d1.getName() + "," + d1.getAge());
        d1.lookDoor();

        Dog d2 = new Dog("哈士奇", 5);
        System.out.println(d2.getName() + "," + d2.getAge());
        d2.lookDoor();

    }
}

修饰符

1. 修饰符的分类

  1. 权限修饰符

  2. 状态修饰符

    • final（最终态）

      final关键字是最终的意思，可以修饰成员方法，成员变量，类

      final修饰的特点：

      • 修饰方法：表明该方法是最终方法，不能被重写
      • 修饰变量：表明该变量是常量，不能再次被赋值
      • 修饰类：表明该类是最终类，不能被继承

      final修饰局部变量：

      • 变量是基本类型：final修饰指的是基本类型的数据值不能发生改变
      • 变量是引用类型：final修饰指的是引用类型的地址值不能发生改变，但是地址里面的内容是可以发生改变的

    • static（静态）

      static关键字是静态的意思，可以修饰成员方法，成员变量

      static修饰的特点：

      • 被类的所有对象共享

        这也是判断是否使用静态关键字的条件

      • 可以通过类名调用

        当然也可以通过对象名调用

        推荐使用类名调用

        举个🌰：Student.age = 18

      static访问特点：

      1. 非静态的成员方法：
        • 能访问静态的成员变量
        • 能访问非静态的成员变量
        • 能访问静态的成员方法
        • 能访问非静态的成员方法
      2. 静态的成员方法：
        • 能访问静态的成员变量
        • 能访问静态的成员方法

      总结：静态成员方法只能访问静态成员

Java面向对象之继承练习题.doc
08-04
【Java面向对象之继承练习题】的解析与详解： 1. **类的继承**：在Java中，继承是面向对象编程的重要特性，允许一个类（子类）继承另一个类（父类）的属性和方法。例如，我们可以创建一个`Music`类作为其他音乐相关...
Java面向对象之继承练习题
weixin_60283557的博客
08-04 1677
1、实现如下类之间的继承关系，并编写Music类来测试这些类。 2.定义一个人的类（属性有名字，年龄，性别。写一个能输出各个属性值的方法showInfo（）），定义一个学生类（属性有学号），学生继承人类，要求： （1）父类的属性赋值用构造方法来实现（分别用有参数构造方法和无参数构造方法实现）； （2）子类的属性也用构造方法来赋值； （3）在子类中重写父类的showInfo（）方法 （4）声明学生类的对象，调用学生的显示信息的方法。 3、请编码实现动物世界的继承关系： 动物（Animal）具有行为：吃（ea
Java面向对象，封装，继承的基础练习
wangcd1223的博客
10-12 487
1.1面向过程：是一种编程思想，强调的是过程，凡事亲力亲为。 1.2面向对象：是一种编程思想，强调的是结果。 2.面向对象的三大特征： 1）封装 2）继承 3）多态 3.类和对象 类：是抽象的，类似于类型，我么你可以将其理解为一类事物的模板 对象：是具体的，是根据类具体创造出来的事物 4.面向对象入门案例 package cn.tedu.oop; /*本类用于面向对象入门案例 * 在一个Java文件中可以写多...
Java-Java面向对象继承的实现教程
11-09
在Java编程语言中，面向...学习Java面向对象继承的实现，不仅有助于提升编程技巧，还能更好地理解面向对象编程的核心理念。在实际开发过程中，结合视频教程和其他学习资源，可以加深对这一主题的理解，提高编程能力。
java基础之面向对象编程
02-20
Java是一种广泛使用的面向对象编程语言，其面向对象的特性使得代码更加模块化、易于...以上只是Java面向对象编程的基础知识概览，实际上，每个主题都包含了更深入的概念和实践技巧，需要通过不断的学习和实践来掌握。
Java面向对象编程之类的继承详解
08-28
"Java面向对象编程之类的继承详解" Java面向对象编程之类的继承是Java编程语言中最基本也是最重要的概念之一。继承是类和类之间的一种关系，通过继承，可以使子类继承父类的所有属性和方法，从而提高代码的复用性和...
Java面向对象编程（封装/继承/多态）实例解析
08-29
Java 面向对象编程（封装/继承/多态）...这三大特征是 Java 面向对象编程的基础，它们构成了 Java 编程的核心。 在实际开发中，需要根据具体情况选择合适的编程方式，以便实现软件系统的可维护性、灵活性和扩展性。
java(jdk) 签名 oppo 的 空包
weixin_42286658的博客
01-21 89
oppo 上架之前需要长传一个 签过名的空包
sentinel微服务保护
pscool的博客
01-18 1167
什么是雪崩问题？微服务之间相互调用，因为调用链中的一个服务故障，引起整个链路都无法访问的情况。限流是对服务的保护，避免因瞬间高并发流量而导致服务故障，进而避免雪崩。是一种预防措施。超时处理、线程隔离、降级熔断是在部分服务故障时，将故障控制在一定范围，避免雪崩。是一种补救措施。Sentinel是阿里巴巴开源的一款微服务流量控制组件。流控模式有哪些？直接：对当前资源限流关联：高优先级资源触发阈值，对低优先级资源限流。链路：阈值统计时，只统计从指定资源进入当前资源的请求，是对请求来源的限流流控效果有哪些。
springboot部署项目
2401_83017604的博客
01-20 772
此文章主要讲解springboot项目的打包和本地部署，以及部署过程中遇到的问题，还分享了动态切换JDK的方法、多环境开发-Profiles等
一个面向领域的直播平台开源！
最新发布
一个爱编程的人专栏
01-21 287
这个基于Spring Boot和SRS的在线直播平台具有丰富的功能和良好的扩展性。通过二开和扩展，可以进一步满足教育等领域的需求，为用户提供更加便捷、高效的在线直播和互动体验。如果您有具体的开发需求或问题，欢迎随时提问。面向教育等领域，二开后可以做视频会议等。
spring那些事
2301_79438104的博客
01-20 598
Resource 和@Autowired 都是做 bean 的注入时使用，其实@Resource 并不是Spring的注解，它的 包是 javax.annotation.Resource ，需要导入，但是 Spring 支持该注解的注入。@Resource 有两个重要的属性： name 和 type，而 Spring 将@Resource 注解的name属性解析为 bean 的名字，而 type 属性则解析为 bean 的类型。Spring DAO：对 JDBC 的抽象，简化了数据访问异常的处理；
SpringBoot 整合 Grizzly
曼陀罗的博客
01-19 996
Grizzly 是一个高性能的、异步的、非阻塞的 HTTP 服务器框架，它可以与 Spring Boot 一起提供比传统的 Tomcat 或 Jetty 更高的吞吐量和更低的延迟。通过将 Grizzly 集成到 Spring Boot 中，你可以充分利用 Grizzly 的高性能、异步和非阻塞的特性，突破传统 Servlet 容器的并发瓶颈。Grizzly 特别适合需要高吞吐量和低延迟的 Web 应用，尤其是当面临大量并发请求时，它能够通过优化连接和线程管理，提高响应速度并降低延迟。
使用 Canal 实时从 MySql 向其它库同步数据
m0_74824635的博客
01-21 819
目前绝大多数项目还是采用 mysql 作为数据存储，对于用户访问量较高的网站来说，mysql 读写性能有限，我们通常会把 mysql 中的数据实时同步到 Redis、mongodb、elastic search 等中间件中，应对高并发访问场景，减轻 mysql 压力，防止数据库宕机。在项目开发中，为了不会原有代码进行侵入，采用 canal 中间件实现 mysql 向其它库的实时同步，是一种很不错的方案。
XML映射文件
violinwang
01-18 485
XML映射文件，foreach，抱对的小鸟，可以帮助定位XML的SQL。
Gateway网关
2402_88002981的博客
01-18 1087
RemoveRequestParameter GatewayFilter 工厂是Spring Cloud Gateway提供的一个内置过滤器工厂，它允许你从所有匹配的HTTP请求的查询字符串中移除指定的参数。RedirectTo GatewayFilter 工厂是Spring Cloud Gateway提供的一个内置过滤器工厂，它允许你将匹配的HTTP请求重定向到指定的URL。Path路由谓词工厂允许你定义一系列的路径模式，当请求的URI路径与这些模式中的任何一个匹配时，请求就会被路由到相应的服务。
JMeter 测试Dubbo 接口
木子馋喵的知识杂货铺
01-20 736
自定义 Java 请求：通过编写 Java 类来调用 Dubbo 服务。Dubbo 插件：使用 JMeter 中的 Dubbo 插件来简化 Dubbo 测试配置。HTTP 请求模拟：当 Dubbo 服务暴露 HTTP 或 REST 接口时，可以使用 JMeter 的 HTTP 请求功能进行模拟测试。根据你的实际需求，选择合适的方法进行测试，能够有效验证 Dubbo 服务的功能和性能。
Android SystemUI——快捷面板的创建（十四）
小旭的专栏
01-21 475
上一篇文章介绍了快捷面板界面 QSFragment 的创建流程，这里我们继续介绍快捷按键 QSTile 和管理 QSTile 生命周期和服务注册的 QSTileHost。
Java Web 登录系统示例：过滤器技术与 JDBC 数据库连接
Broken_x的博客
01-18 1005
过滤器（Filter）是JavaWeb开发中的一个强大工具，它可以在请求到达Servlet之前或响应返回客户端之前对请求和响应进行拦截和处理。过滤器可以用来执行诸如字符编码设置、跨域资源共享（CORS）、日志记录、权限检查等任务。JDBC（JavaDatabaseConnectivity）是Java访问数据库的标准API，允许Java程序连接并操作各种数据库。用户交互用户在登录页面输入用户名和密码，点击登录按钮。请求处理前端通过AJAX将用户名和密码发送到。调用进行登录验证。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

i新木优子

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值