面向对象进阶--继承(Java继承（超详解）)

目录

1. 继承

1.1 继承概述

1.2 继承特点

1.3练习

1.4继承父类的内容

构造方法是否被子类继承

成员变量是否被子类继承

成员方法是否被子类继承

1.5总结

继承中：成员变量的访问特点

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

方法重写概述

方法重写的本质

继承中：构造方法的特点

this,super使用总结

1. 继承

1.1 继承概述

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

继承是指在原有类的基础上，进行功能扩展，创建新的类型。

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
JAVA中类只有单继承，没有多继承!
继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等。
继承关系的两个类，一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示。
子类和父类之间,从意义上讲应该具有"is a"的关系。
extends的意思是“扩展”，子类是父类的扩展。

继承的格式：

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

继承中子类的特点:

子类可以有父类的内容，子类还可以有自己特有的内容。

1.2 继承特点

Object类是所有子类的父类 如果你没有写父类 默认父类就是Object类

1.3练习

如果父类加了private私有关键字 ,子类就不能使用父类的特性了

测试类

package comitheima.a01oopextendsdemo01;

public class Test {
    public static void main(String[] args) {
        //1.创建布偶猫对象
        Ragdoll r1 = new Ragdoll();
        r1.eat();
        r1.drink();
        r1.catchMouse();
        System.out.println("----------------");
        //2.创建哈士奇对象
        Husky h=new Husky();
        h.eat();
        h.drink();
        h.DownHome();

    }

}

package comitheima.a01oopextendsdemo01;

public class animal {
    public  void eat(){
        System.out.println("吃饭");
    }
    public  void drink (){
        System.out.println("喝水");

    }
}

package comitheima.a01oopextendsdemo01;

public class cat extends  animal {
    public void catchMouse(){
        System.out.println("猫在抓老鼠");
    }
}

package comitheima.a01oopextendsdemo01;

public class dog extends  animal {
    public void watchhose(){
        System.out.println("狗在看家");
    }
}

package comitheima.a01oopextendsdemo01;

public class Husky extends dog {
    public void DownHome(){
        System.out.println("哈士奇拆家");
    }

}


package comitheima.a01oopextendsdemo01;

public class LiHua extends cat {
}

package comitheima.a01oopextendsdemo01;

public class Ragdoll extends cat {

}

package comitheima.a01oopextendsdemo01;

public class Teddy extends dog {
    public void touch(){
        System.out.println("泰迪蹭一蹭");
    }
}

1.4继承父类的内容

构造方法是否被子类继承

构造方法的类名和子类的类名不一样,违背了构造方法的特征,所以父类的构造方法不能被子类继承

package comitheima.a01oopextendsdemo02;

public class Test {
    public static void main(String[] args) {
       Zi zi = new Zi();
       //Zi zi1 = new Zi("zhasa",18);
    }
}

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

    }
}
class Zi extends Fu{
   //如果一个类没有构造方法,虚拟机会自动给你添加一个默认的空参的构造方法
}

说明了子类没有继承父类的构造方法,空参构造也是虚拟机给的

成员变量是否被子类继承

public修饰的成员变量

对象先找子类再找父类

private修饰的成员变量

private修饰的变量 子类调用不了方法 只能继承不能直接使用

成员方法是否被子类继承

只有非static修饰 非private修饰非final修饰的方法是虚方法
虚方法就可以继承给子类，子类就会加载方法，每次子类调用方法的时候就可以从自己的虚方法里面去调用

1.5总结

1.构造方法的类名和子类的类名不一样,违背了构造方法的特征,所以父类的构造方法不能被子类继承，不管是public修饰还是private修饰都不能被子类继承
2.成员变量不管是private修饰还是public修饰都能继承 ，但是private修饰的成员变量只能继承不能直接调用
3. 只有public修饰的成员方法才能继承，private修饰的成员方法不能继承
4.只有非static修饰 非private修饰非final修饰的方法是虚方法
虚方法就可以继承给子类，子类就会加载方法，每次子类调用方法的时候就可以从自己的虚方法里面去调用
 

继承中：成员变量的访问特点

遵循就近原则

在子类方法中访问一个变量

最先在子类局部范围找，如果没有就在子类成员范围找，最后在父类成员范围找，如果都没有就报错(不考虑父亲的父亲...)。

name先在局部位置找，然后再到本类的成员位置找，然后在到父类找，一级一级往上找

this访问的是本类的成员变量 ，super是访问父类的成员变量

 例如：创建一个父类Fu

public class Fu {
	public int age = 10;
}

创建一个子类Z

public class Zi extends Fu {
	public int heigth = 180;
	public int age = 20;// 若果没有这句，和下面那句，输入的是10
	public void show() {
		int age = 30;// 若果没有这句，输入的是20
		System.out.println(age);
		System.out.println(heigth);
	}
}

创建一个测试类Test

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

结果：

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

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

先子类成员范围找，如果找不到就在父类成员范围找，如果都没有就报错(不考虑父亲的父亲...)


 

方法重写概述

方法重写概述：子类中出现了和父类中一模一样的方法声明
方法重写的应用：当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容

@Override
是一个注解可以帮助我们检查重写方法的方法声明的正确性

方法重写的本质

只有被添加到虚方法中的方法才能被重写

package comitheima.a01oopextendsdemo04;

import java.util.SimpleTimeZone;

public class Dog {
    public void eat() {
        System.out.println("狗在吃狗粮");
    }
    public void drink()
    {
        System.out.println("狗在喝水");
    }
    public void lookhome(){
        System.out.println("狗在看家");
    }
}

package comitheima.a01oopextendsdemo04;

public class Husky extends  Dog {
    public void downhome(){
        System.out.println("哈士奇在拆家");
    }
}

package comitheima.a01oopextendsdemo04;

public class Chinesedog extends  Dog {
    public void eat(){
         //父类的方法不能满足我们的需求，所以进行了重写，且父类的方法我根本用不到
        System.out.println("中化田园犬在吃剩饭");
    }
}

package comitheima.a01oopextendsdemo04;

public class sharper extends Dog {
    //因为沙皮狗吃的是狗粮和骨头
    //父类的方法不能满足我们的需求，所以进行了重写
    //方法重写
    @Override
    public void eat(){
       super.eat();
        System.out.println("沙皮狗在吃骨头");
    }
}

package comitheima.a01oopextendsdemo04;

public class Test {
    public static void main(String[] args) {
        Husky h= new Husky();
        h.eat();
        h.drink();
        h.lookhome();
        h.downhome();
        System.out.println("----------");
        sharper sh=new sharper();
        sh.eat();
        sh.drink();
        sh.lookhome();
        System.out.println("----------");
        Chinesedog Ch=new Chinesedog();
        Ch.eat();
        Ch.drink();
        Ch.lookhome();


    }

继承中：构造方法的特点

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

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

 例如：创建一个父类Fu

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

创建一个子类Zi

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

测试：Test

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

子类的初始化之前,要调用父类的构造方法先完成父类的数据初始化
如果想要调用父类的有参构造 ,必须手动加上super.
我还想强调的是父类的构造方法,子类是不能继承,但是子类可以去调用父类的方法,继承不了不代表调用不了,不管是private修饰还是public修饰的构造方法,子类都继承不了父类的构造方法

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

  1. 通过使用super关键字去显示的调用父类的带参构造方法
  2. 在父类中自己提供一个无参构造方法
  3. 推荐: 自己给出无参构造方法

例如：创建一个父类Fu

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

创建一个子类Zi

public class Zi extends Fu {
	public Zi() {
		super(18);
		System.out.println("Zi中无参构造方法被调用");
	}
 
	public Zi(int age) {
		super(18);
		System.out.println("Zi中带参构造方法被调用");
	}
}

测试：Test

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

super访问父类的构造方法

package comitheima.a05oopextendsdemo05;

public class Student  extends  Person{
    public  Student(){
        //子类构造方法中隐藏的super（）去访问父类的无参构造
        super();
        System.out.println("子类的无参构造");
    }
    public  Student(String name,int age){
        //子类构造方法中手动去在super方法中传参数 就可以去调用带参构造
        super(name,age);
        System.out.println("子类的无参构造");
    }
}


package comitheima.a05oopextendsdemo05;

public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("zhangsa",18);
        System.out.println(s1.name+" "+s1.age);
    }
}

package comitheima.a05oopextendsdemo05;

public class Person {
    String name;
    int age;
    public Person() {
        System.out.println("父类的无参构造");
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

      


this,super使用总结

例如：定义一个父类Fu

public class Fu {
	public int age = 10;
 
}

定义一个子类Zi

 
public class Zi extends Fu {
	public int age = 20;
 
	public void show() {
		int age = 30;
		System.out.println(age); // 30
		// 访问本类中的成员变量age
		System.out.println(this.age);
		// 访问Fu类中的成员变量age
		System.out.println(super.age);
	}
}

测试：Test

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

this访问本类的构造方法

测试类

package comitheima.a06oopextendsdemo06;

import com.sun.tools.javac.Main;

public class Test {
    public static void main(String[] args) {
      Manager m=new Manager("001","zhangsan",6666,1000.0);
        System.out.println(m.getId()+" "+m.getName()+" "+m.getSalary()+" "+m.getBonus());
        m.word();
        m.eat();
        System.out.println("--------------");
        Cook c=new Cook("002","lisi",1111);
        System.out.println( c.getId()+" "+c.getName()+" "+c.getSalary());

        c.word();
        c.eat();

    }
}

父类

public class Employee {
    private String id;
    private String name;
    private int salary;

    public Employee() {
    }

    public Employee(String id, String name, int salary) {
        this.id = id;
        this.name = name;
        this.salary = salary;
    }


    public String getId() {
        return id;
    }


    public void setId(String id) {
        this.id = id;
    }


    public String getName() {
        return name;
    }


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


    public int getSalary() {
        return salary;
    }


    public void setSalary(int salary) {
        this.salary = salary;
    }
   public void word(){
       System.out.println("员工在工作");
   }
    public void eat(){
        System.out.println("在吃米饭");
    }
}

子类经理类

public class Manager extends Employee {
    private double bonus;

    public Manager() {

    }

    //带全部的构造方法
    //父类+子类的构造方法
    public Manager(String id, String name, int salary, double bonus) {
        super(id, name, salary);//调用父类的有参构造,把id,name,salary,bonus的值给父类
        this.bonus = bonus;//子类的特有的奖金在本类赋值
    }

    public double getBonus() {
        return bonus;
    }

    public void setBonus(double bonus) {
        this.bonus = bonus;
    }

    @Override
    public void word() {
        System.out.println("经理在管理其他人");
    }


}

子类厨师类

package comitheima.a06oopextendsdemo06;

public class Cook extends  Employee {
    public Cook() {
    }

    public Cook(String id, String name, int salary) {
        super(id, name, salary);
    }

    @Override
    public void word() {
        System.out.println("厨师在炒菜");
    }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/719806.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

什么是浅拷贝和深拷贝，如何用 js 代码实现？

什么是浅拷贝和深拷贝，如何用 js 代码实现？

〇、简介和对比 简介 浅拷贝：只复制原始对象的第一层属性值。 如果属性值是值类型，将直接复制值，本值和副本变更互不影响； 如果是引用数据类型，则复制内存地址，因此原始对象和新对象的属性指向相同的内存地…
阅读更多...
小规模自建 Elasticsearch 的部署及优化

小规模自建 Elasticsearch 的部署及优化

本文将详细介绍如何在 CentOS 7 操作系统上部署并优化 Elasticsearch 5.3.0，以承载千万级后端服务的数据采集。要使用Elasticsearch至少需要三台独立的服务器，本文所用服务器配置为4核8G的ECS云服务器，其中一台作为 master + data 节点、一台作为 client + data 节点、最后一…
阅读更多...
【学习Docker】

【学习Docker】

学习Docker可以分为几个步骤和阶段，以下是一个建议的学习路径，适合初学者到进阶用户： ### 1. 理解基本概念 - **容器化与虚拟化**：了解容器化与传统虚拟化之间的区别，容器的轻量级和效率。 - **Docker组件**&#xff…
阅读更多...
基于EXCEL数据表格创建省份专题地图

基于EXCEL数据表格创建省份专题地图

1 数据源 随着西藏于5月1日发布2022年一季度经济运行情况，31省份一季度GDP数据已全部出炉。 总量方面，粤苏鲁稳居前三；增速方面，23省份高于“全国线”，新疆表现最佳，增速达到7.0%。 表格表现数据不够直观…
阅读更多...
使用 Dapper 创建 Blazor Server SPA

使用 Dapper 创建 Blazor Server SPA

介绍 Blazor 是 Microsoft 构建的一个新框架，用于使用 .NET 代码库创建交互式客户端 Web UI。 Dapper 是一个微型 ORM（对象关系映射器），可帮助将本机查询输出映射到领域类。它是由 StackOverflow 团队构建并作为开源发布的高性能…
阅读更多...
Ubuntu 使用Vscode的一些技巧 ROS

Ubuntu 使用Vscode的一些技巧 ROS

Ubuntu VSCode的一些设置（ROS） 导入工作空间 推荐只导入工作空间下的src目录 如果将整个工作空间导入VSCode，那么这个src就变成了次级目录，容易在写程序的时候把本应该添加到具体工程src目录里的代码文件给误添加到这个catkin_w…
阅读更多...
如何使用Gitmails在版本控制主机中收集Git提交邮件

如何使用Gitmails在版本控制主机中收集Git提交邮件

关于Gitmails Gitmails是一款能够在Git版本控制主机服务中收集Git提交电子邮件的信息收集工具，该工具可以帮助广大研究人员扫描和识别Git提交中包含的作者名称、电子邮件配置和版本控制主机服务是否存储了多个项目。 想要了解网络安全，学习网络安全知识…
阅读更多...
SpringMVC系列九: 数据格式化与验证及国际化

SpringMVC系列九: 数据格式化与验证及国际化

SpringMVC 数据格式化基本介绍基本数据类型和字符串自动转换应用实例-页面演示方式Postman完成测试 特殊数据类型和字符串自动转换应用实例-页面演示方式Postman完成测试 验证及国际化概述应用实例代码实现注意事项和使用细节 注解的结合使用先看一个问题解决问题 数据类型转换…
阅读更多...
数据中心分类和类别综合指南

数据中心分类和类别综合指南

数据中心可根据其规模、功能、所有权、层级和部署方法进行分类。以下是一些典型的数据中心类别和分类。 数据中心的分类和分级 根据尺寸 1. 小型数据中心：通常是为了满足对IT基础设施需求较少的组织或小型企业的需求而创建的。与大型数据中心相比，小型…
阅读更多...
【Java学习笔记】枚举类与泛型

【Java学习笔记】枚举类与泛型

枚举类型是一种特殊的数据类型，之所以特殊，是因为它既是一种类(Class)类型，却又比类类型多了一些特殊的约束，但正是因为这些约束的存在，也造就了枚举类型的简洁性、安全性、便捷性。 泛型，即“参数化类型”…
阅读更多...
【SPIE独立出版 | 往届均已完成EI检索】2024云计算、性能计算与深度学习国际学术会议(CCPCDL 2024)

【SPIE独立出版 | 往届均已完成EI检索】2024云计算、性能计算与深度学习国际学术会议(CCPCDL 2024)

2024云计算、性能计算与深度学习国际学术会议(CCPCDL 2024) 2024 International conference on Cloud Computing, Performance Computing and Deep Learning *CCPCDL往届均已完成EI检索，最快会后4个半月完成！ 一、重要信息 大会官网：www…
阅读更多...
python-开学?

python-开学?

[题目描述] 小执：终于可以开学啦！好开心啊！ 小理：你没看新闻吗，开学日期又延后了。 小执：𝑁𝑂𝑂𝑂𝑂𝑂𝑂𝑂&am…
阅读更多...
Vue01-前端概述

Vue01-前端概述

一、前端核心分析 1.1、概述 Soc原则：关注点分离原则 Vue 的核心库只关注视图层，方便与第三方库或既有项目整合。 HTML CSS JS : 视图 ： 给用户看，刷新后台给的数据 网络通信 ： axios 页面跳转 ： v…
阅读更多...
Java聚合快递系统对接云洋系统快递小程序APP公众号系统源码

Java聚合快递系统对接云洋系统快递小程序APP公众号系统源码

快递小程序的深度解析与未来展望 🚚 引言：快递行业的变革与挑战 在数字化浪潮的推动下，快递行业正经历着前所未有的变革。随着电商的蓬勃发展，快递业务量呈爆发式增长，而传统的快递管理方式已难以满足日益增长的需求。…
阅读更多...
我用chatgpt写了一款程序

我用chatgpt写了一款程序

众所周知，Chatgpt能够帮助人们写代码，前几天苏音试着完全用Chatgpt写一款Python程序 有一句话我很赞同，未来能代替人的不是AI，是会使用AI的人。 最终，写下来效果还不错，完全提升了我的办公效率。 开发前…
阅读更多...
计算机跨考现状，两极分化现象很严重

计算机跨考现状，两极分化现象很严重

其实我觉得跨考计算机对于一些本科学过高数的同学来说有天然的优势 只要高数能学会，那计算机那几本专业课，也能很轻松的拿下，而对于本科是文科类的专业，如果想跨考计算机，难度就不是一般的大了。 现在跨考计算机呈现…
阅读更多...
了解Java的LinkedBlockingQueue

了解Java的LinkedBlockingQueue

了解Java的LinkedBlockingQueue LinkedBlockingQueue是一个基于链接节点的有界阻塞队列。它实现了BlockingQueue接口，可以在多线程环境中安全地进行插入、移除和检查操作。LinkedBlockingQueue的容量可以在创建时指定，如果未指定，则默认容量…
阅读更多...
AI绘画stable diffusion 模型介绍及下载、使用方法，超全的新手入门教程建议收藏！

AI绘画stable diffusion 模型介绍及下载、使用方法，超全的新手入门教程建议收藏！

大家好，我是画画的小强 今天我将继续分享AI绘画Stable Diffusion的模型、参数含义等，分享给各位朋友一起学习。 一、模型 Stable difusion 模型就是所谓的大模型，用来控制整个画面的风格走势的。 打开webui页面，可以看到大模型…
阅读更多...
安卓实现圆形按钮轮廓以及解决无法更改按钮颜色的问题

安卓实现圆形按钮轮廓以及解决无法更改按钮颜色的问题

1.实现按钮轮廓 在drawable文件新建xml文件 <shape xmlns:android"http://schemas.android.com/apk/res/android"<!--实现圆形-->android:shape"oval"><!--指定内部的填充色--><solid android:color"#FFFFFF"/><!-…
阅读更多...
Mongodb介绍及window环境安装

Mongodb介绍及window环境安装

本文主要内容为nosql数据库-MongoDB介绍及window环境安装。 目录 什么是MongoDB&#xff1f; 主要特点 MongoDB 与Mysql对应 安装MongoDB 下载MongoDB 自定义安装 创建目录 配置环境变量 配置MongoDB服务 服务改为手动 启动与关闭 安装MongoDB Shell 下载安装包 …
阅读更多...
最新文章

Copyright @ 2022~2023