面向对象进阶7---继承

最新推荐文章于 2024-09-14 18:46:05 发布
最新推荐文章于 2024-09-14 18:46:05 发布
阅读量353 收藏
点赞数 1
分类专栏： java学习 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45522528/article/details/122800097
版权

继承

什么是继承

在这里插入图片描述

案例分析

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

小结

在这里插入图片描述

代码说明

package StaticDemo2;

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

    public people() {
    }

    public people(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 StaticDemo2;

public class Teacher extends people{

    // 独有的功能
    public void teacher(){
        System.out.println("老师教书育人。");
    }
}


package StaticDemo2;

public class Student extends people{

    public void student(){
        System.out.println("学生再学习");
    }



}


package StaticDemo2;

public class test {
    public static void main(String[] args) {
        //  创建子类对象看一下是否可以使用父类的属性和行为
        Student s = new Student();
        s.setName("小明");
        s.setAge(25);

        System.out.println(s.getName());
    }
}

在这里插入图片描述

继承设计规范

在这里插入图片描述

设计案例

在这里插入图片描述
代码演示

package StaticDemo3;

public class student207 extends people207 {
    private String className;

    public void student(){
        System.out.println(getClassName()+"的"+getName()+"学生再快乐的学习");
    }

    public void writerinfo(){
        System.out.println("填写课程评价");
    }



    public String getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className;
    }
}


package StaticDemo3;

public class teacher207 extends people207 {

    private String part;

    // 独有属性
    public void teacher(){
        System.out.println(getName()+"老师再教书");
    }


    public String getPart() {
        return part;
    }

    public void setPart(String part) {
        this.part = part;
    }
}


package StaticDemo3;

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

    // 共同行为
    public void queryCourse(){
        System.out.println(name+"开始查看课表信息");
    }

    public people207() {
    }

    public people207(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 StaticDemo3;

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

        // 创建子对象，可以使用父类的属性和行为
        student207 s = new student207();

        s.setAge(25);
        s.setName("小明");
        s.setClassName("通信工程");

        System.out.println(s.getName());
        System.out.println(s.getAge());

        s.student();
    }
}

运行结果
在这里插入图片描述

程序运行原理

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

小结

在这里插入图片描述

继承的特点

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

小结、

在这里插入图片描述

继承后成员变量成员方法的访问特点

就近原则

在这里插入图片描述

代码说明

package StaticDemo3;

public class extendsdemo{
    public static void main(String[] args) {
        wolf w = new wolf();
        System.out.println(w.name);  // 子类的

    }
}

class animal{
    public String name="父类动物";
}

class wolf extends animal{
    public String name="子类动物";
}

结果演示
在这里插入图片描述

this与super访问

关键字的就近原则

package StaticDemo3;

public class extendsdemo{
    public static void main(String[] args) {
        wolf w = new wolf();
        System.out.println(w.name);  // 子类的
        w.showname();


    }
}

class animal{
    public String name="父类动物";
}

class wolf extends animal{
    public String name="子类动物";

    public void showname(){
        String name = "局部名称";
        System.out.println(this.name); // 子类名称
        System.out.println(super.name); // 父类名称
    }
}

结果演示
在这里插入图片描述
方法的就近原则

package StaticDemo3;

public class extenddemo2 {
    public static void main(String[] args) {
        son s = new son();
        s.run();
        System.out.println("==============================");
        s.go();
    }
}

class people{
    public void run(){
        System.out.println("父类run方法");

    }
}

class son extends people{
    public void run(){
        System.out.println("子类的run方法");
    }

    public void go(){
        run();// 子类
        this.run();//子类
        super.run();//父类
    }
}

在这里插入图片描述

小结

在这里插入图片描述

方法重写

什么是方法重写

在这里插入图片描述

代码演示

父类

package StaticDemo4;

public class phone {
    public void call(){
        System.out.println("打电话开始");
    }

    public void sendmessage(){
        System.out.println("发送短信");
    }
}

子类

package StaticDemo4;

public class newphone extends phone {
    /*
    * 方法重写
    * */
    public void call(){
        // 声明继承父类方法
        super.call();
        System.out.println("支持视频通话");
    }

    public void sendmessage(){
        super.sendmessage();
        System.out.println("可以发送彩信和图片");
    }
}

测试

package StaticDemo4;

public class test {
    public static void main(String[] args) {
        newphone n = new newphone();
        n.call();
        n.sendmessage();

    }
}

运行结果
在这里插入图片描述

重写注意事项

在这里插入图片描述
案例分析----私有方法不能重写
在这里插入图片描述
案例分析—重写的优先级
在这里插入图片描述
在这里插入图片描述
子类无法重写父类的静态方法
在这里插入图片描述

小结

在这里插入图片描述

子类构造器的特点

子类构造器继承父类后的构造器特点

在这里插入图片描述

程序演示

父类

package StaticDemo4;

public class Animals {
    public Animals(){
        System.out.println("=======父类Animals无参数构造器被执行======");
    }
}

子类

package StaticDemo4;

public class Cat extends Animals {
    public Cat(){
        System.out.println("====子类Cat无参数构造器被触发执行=====");
    }
}

测试

package StaticDemo4;

public class test2 {
    public static void main(String[] args) {
        Cat c = new Cat();
    }
}

结果
在这里插入图片描述
程序改进我们来观察有参数构造器是否和无参数构造器一样，我们不改变父类构造器，仅改变子类构造添加一个有参数构造器功能，其他功能不变

package StaticDemo4;

public class Cat extends Animals {
    public Cat(){
        System.out.println("====子类Cat无参数构造器被触发执行=====");
    }

    public Cat(String n){
        System.out.println("=====子类有参数构造器被触发执行=========");
    }
}


package StaticDemo4;

public class test2 {
    public static void main(String[] args) {
        Cat c = new Cat();
        System.out.println("===================");
        Cat c1 = new Cat("小叮当");
    }
}

在这里插入图片描述

小结

在这里插入图片描述

子类构造器访问父类有参数构造器

Super调用

在这里插入图片描述

代码演示

父类

package StaticDemo5;

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

    public People() {
    }

    public People(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 StaticDemo5;

public class Student extends People{

    private String calssName;
    // 先整一个无参数构造器
    public Student(){

    }


    public Student(String name,int age,String calssName){
        // 一定要访问父类的无参数构造器
        super(name,age);
        this.calssName = calssName;
    }


    public String getCalssName() {
        return calssName;
    }

    public void setCalssName(String calssName) {
        this.calssName = calssName;
    }
}

测试类

package StaticDemo5;

public class test {
    public static void main(String[] args) {
        Student s = new Student("张三",25,"通信工程");
        System.out.println(s.getCalssName());
        System.out.println(s.getAge());
        System.out.println(s.getName());

    }
}

运行结果
在这里插入图片描述

小结

在这里插入图片描述

this，super使用小结

this&super详情

在这里插入图片描述

案例演示

在这里插入图片描述
主代码

package StaticDemo6;

public class Student {
    private String name;
    private String schoolName;

    public Student() {
    }

    // this调用本类构造器，这里并没有用继承
    public Student(String name){
        this(name,"学校未知");
    }

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

    public String getName() {
        return name;
    }

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

    public String getSchoolName() {
        return schoolName;
    }

    public void setSchoolName(String schoolName) {
        this.schoolName = schoolName;
    }
}

测试

package StaticDemo6;

public class Test {
    public static void main(String[] args) {
        Student s = new Student("乔巴","java培训");
        System.out.println(s.getName());
        System.out.println(s.getSchoolName());

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

        Student s1 = new Student("小王");
        System.out.println(s1.getName());
        System.out.println(s1.getSchoolName());
    }
}

运行结果
在这里插入图片描述

参考

黑马程序员

Peihj2021
关注
专栏目录
实验报告5——C#面向对象进阶（继承与多态）
易道
12-01 3337
课程名称：嵌入式系统应用开发 (WinCE版)                        开课机房：钱江学院六号楼（603）2008年12月2日星期二专业班级电子060学号 姓名 成绩 实验项目名称实验报告5——C#面向对象进阶（继承与多态）指导教师陈玮 一、实验任务与实验目的实验目的理解继承性，掌握base,virtual,abstract,protected,interal
Java面向对象（进阶）- Object类的详细概述
11-14
在Java编程语言中，面向对象是其核心特性之一。Object类是所有Java类的根父类，无论何时我们创建一个新的类，除非明确指定其他父类，否则它都会默认继承Object类。这使得Object类中的方法对所有Java类都可用，体现了...
2021.07.09 Java学习笔记
Mxxxxxx_的博客
07-10 144
关于packeage 的一些说明 包package与导入import 1.包机制: 文件夹 1) 便于管理众多的资源 2) 提供了多重的命名空间 命名规范: 公司域名倒着写 com.xxxx.xxxx 包信息存在与java文件的首行 2.导包 : 指明要使用的类的位置 import 包名.类名; 位置: 类对的上面,包信息的下面 1)使用的时候指明类的权限定名,完整路径 只能在当前只一次使用有效 ja...
继承
qQe32的博客
04-06 251
构造方法 1.在一个类中方法名与类名相同 2.方法名的前面没有返回值类型的声明，如return语句返回一个值       构造方法的重载 一个类中可以定义很多个构造方法，通过每个构造方法的参数类型，参数的个数，参数的顺序不同来区别。 public class Student {  public String name;  public int age;
【Java】带你从零到一系列11 面向对象编程1 （包和继承）
恒等于C的博客欢迎您
11-21 409
来找个对象编程吧！！【doge】
java基础：继承的使用
ACBYCL的博客
08-07 348
java基础：继承的是使用
面向对象进阶--继承(Java继承（超详解）)
weixin_65752158的博客
06-18 1155
1.构造方法的类名和子类的类名不一样,违背了构造方法的特征,所以父类的构造方法不能被子类继承，不管是public修饰还是private修饰都不能被子类继承2.成员变量不管是private修饰还是public修饰都能继承 ，但是private修饰的成员变量只能继承不能直接调用3. 只有public修饰的成员方法才能继承，private修饰的成员方法不能继承4.只有非static修饰 非private修饰非final修饰的方法是虚方法。
java面向对象进阶进阶篇--《包和final》
2302_80329073的博客
07-23 1559
在类级别定义常量时，通常使用关键字组合。这种方式定义的常量在整个类的生命周期内只有一个副本，所有实例共享。这样定义的常量可以通过和访问。
java面向对象进阶--常见名词解释
两点
08-09 343
java面向对象进阶--常见名词解释（包、权限修饰符、final、常量、枚举、抽象类、面向对象三大特征之三：多态）
java面向对象进阶篇--《继承》（万字总结，建议收藏）
2302_80329073的博客
07-21 1309
this和super在Java中是两个关键的引用，分别用于引用当前对象和父类对象。它们的使用方式和场景不同，但都能帮助开发者处理对象和类之间的关系以及解决同名成员的访问问题。
Python进阶---面向对象 继承
木易巷的小博客
08-15 299
Python进阶---面向对象 继承
Java面向对象（进阶）- super关键字的使用与子类对象实例化全过程
11-05
在Java编程语言中，面向对象编程是核心特性之一。当我们涉及到类的继承时，`super`关键字扮演着重要的角色。本篇文章将深入探讨`super`关键字的使用以及子类对象实例化的全过程。 一、super关键字的使用 1. **为...
Java面向对象（进阶）- 四种权限测试与方法的重写（override-overwrite）
11-02
Java面向对象编程是Java语言的...它们不仅关乎代码的可读性和安全性，也是实现面向对象设计原则，如封装、继承和多态的关键工具。在实际项目中，合理地选择权限修饰符和适时地重写方法，能提高代码的灵活性和可维护性。
30天p小白学python-第三天（面向对象编程基础-进阶）-小白学python 16-20内容
07-31
在"30天p小白学python-第三天（面向对象编程基础-进阶）"的学习计划中，你将深入探索Python中的类（Class）、对象（Object）、继承（Inheritance）、封装（Encapsulation）和多态（Polymorphism）等面向对象编程的...
Python计划. 面向对象语法精讲面. 面向对象进阶-时类运算操作实践.pdf
05-19
面向对象编程（Object-Oriented Programming，简称OOP）是Python编程的核心概念之一，它允许我们以更加符合现实世界的方式组织代码，通过类（Class）和对象（Object）的概念来抽象和封装数据与行为。本篇文档将深入...
Java-网络
最新发布
2301_81543552的博客
09-14 698
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
Android Studio 2024与2022 解决Read timed out和connect timed out的问题
2301_80035882的博客
09-14 608
如果在新建Android项目时报错：Read timed out或者connect timed out。
自动生成不重复的订单id
ClaireCheney的博客
09-13 284
【代码】自动生成不重复的订单id。
【学习笔记】手写 Tomcat 三
LearnTech_123的博客
09-12 1141
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
Java面向对象进阶：类的继承与访问控制
"面向对象进阶的Java基础知识，包括访问控制、super与this、类的继承、方法的重写与重载等内容。" 在Java编程语言中，面向对象编程（Object-Oriented Programming, OOP）是核心特性之一，它允许我们以更符合现实...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Peihj2021

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

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

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

打赏作者

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

抵扣说明：

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

余额充值