继承—JavaSE

文章目录

  • 1.基础知识
    • 1.1继承的概念
    • 1.2语法
  • 2子类对从父类继承下来的成员的访问
    • 2.1对成员变量的访问
    • 2.2对成员方法的访问
  • 3.super关键字
    • 3.1访问父类的成员变量（super.变量）
    • 3.2访问父类的成员方法（super.方法）
    • 3.3调用父类的构造方法（super()）
  • 4.this和super的区别
    • 4.1相同点
    • 4.2不同点
  • 5.代码块的执行顺序问题
  • 6.访问修饰限定符
    • 6.1同一包中的同一类
    • 6.2同一包中的不同类
    • 6.3不同包中的子类
    • 6.4不同包中的非子类
  • 7.java中支持的继承的方式
  • 8.final关键字
    • 8.1修饰变量或字段
    • 8.2修饰类
    • 8.3修饰方法
  • 9.组合

1.基础知识

1.1继承的概念

在保持原有类特性的基础上进行扩展，增加新功能，从而产生新的类，继承主要解决的问题是对共性的抽取，优点是可以实现代码复用

1.2语法

class A extends B{
}

其中：A是子类，也叫派生类；B是父类，也叫基类、超类

class Animal {
    public String name;
    public int age;
    public void eat(){
        System.out.println(this.name + "正在吃");
    }
}
class Dog extends Animal {
    public void swim(){
        System.out.println(this.name + "正在游泳");
    }
}
class Bird extends Animal {
    public String wing;//翅膀
    public void fly() {
        System.out.println(this.name + "正在飞");
    }
}
public class TextDame1 {
    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.name = "可可";
        animal.eat();
        Dog dog = new Dog();
        dog.name = "小小";//继承了父类的成员变量
        dog.swim();
        dog.eat();//继承了父类的方法
        Bird bird = new Bird();
        bird.name = "大大";
        bird.fly();
    }
}

子类会将父类中的成员变量或者成员方法继承到子类中；子类继承父类之后，要新添加自己特有的成员，体现出与基类的不同，否则就没有必要继承
在这里插入图片描述

2子类对从父类继承下来的成员的访问

2.1对成员变量的访问

（1） 子类和父类不存在同名成员变量

class A {
    public int a;
    public int b;
}
class B extends  A {
    public int c;
    public void method(){
        a = 10;//访问从父类继承的
        b = 20;
        c = 30;//访问子类自己的
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
    }
}
public class TextDame2 {
    public static void main(String[] args) {
        B b = new B();
        b.method();
    }
//结果：
//    10
//    20
//    30
}

（2）子类和父类存在同名成员变量时，优先访问子类自己的，自己没有才会访问父类的

class A {
    public int a;
    public int b;
}
class B extends  A {
    public boolean b;
    public int c;
    public void method(){
        a = 10;//访问从父类继承的
        b = false;//同名是优先访问子类自己的
        //b = 10;//会报错，因为是优先访问子类自己的，而子类的b的类型是Boolean，而不是整形
        c = 30;//访问子类自己的
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
    }
}
public class TextDame2 {
    public static void main(String[] args) {
        B b = new B();
        b.method();
    }
//结果：
//    10
//    false
//    30
}

2.2对成员方法的访问

（1）子类和父类不存在同名成员方法

class A {
    public int a;
    public int b;
    public void funcA(){
        System.out.println("父类的funcA()方法");
    }
}
class B extends  A {
    public void funcB(){
        System.out.println("子类的funcB()方法");
    }
    public void method(){
        funcA();//调用父类的成员方法
        funcB();//调用子类自己的成员方法
    }
}
public class TextDame2 {
    public static void main(String[] args) {
        B b = new B();
        b.method();
    }
//结果：
//父类的funcA()方法
//子类的funcB()方法
}

（2）子类和父类存在同名成员方法时，优先访问子类的成员方法，子类没有才到父类去找

class A {
    public void func(){
        System.out.println("父类的fun()方法");
    }
}
class B extends  A {
    public void func(){
        System.out.println("子类的func()方法");
    }
    public void method(){
        func();
    }
}
public class TextDame2 {
    public static void main(String[] args) {
        B b = new B();
        b.method();
    }
//结果:
//    子类的func()方法
}

3.super关键字

super不能使用在静态方法中，super

3.1访问父类的成员变量（super.变量）

class A {
    public int a;
}
class B extends  A {
    public int a;
    public void method(){
        super.a = 10;//此时的a就是访问的父类的成员便量，但是不加super，默认就是子类自己的a
        a = 20;//等价于this.a = 20
        System.out.println(super.a);//10
        System.out.println(a);//20
    }
}
public class TextDame2 {
    public static void main(String[] args) {
        B b = new B();
        b.method();
    }
}

3.2访问父类的成员方法（super.方法）

class A {
    public void func(){
        System.out.println("父类的fun()方法");
    }
}
class B extends  A {
    public void func(){
        System.out.println("子类的func()方法");
    }
    public void method(){
        super.func();//访问父类的func方法
        func();//访问子类的func方法，等价于this.func()
    }
}
public class TextDame2 {
    public static void main(String[] args) {
        B b = new B();
        b.method();
    }
//结果：
//    父类的fun()方法
//    子类的func()方法
}

3.3调用父类的构造方法（super()）

子类继承了父类以后必须先帮助父类进行构造，帮助父类进行构造就是显示调用父类的构造方法，这里此时构造的意义就是分配内存，初始化从父类继承过拉里的父类成员

class A {
    public int a;
    public int b;
    public A(){
        System.out.println("父类不带参数的构造方法");
    }
}
class B extends  A {
    public int c;
    public B(){
        super();//当父类只有一个不带参数的构造方法的时候，子类默认会有super()，帮助父类进行构造
        System.out.println("子类不带参数的构造方法");
    }
}
public class TextDame2 {
    public static void main(String[] args) {
        B b = new B();
    }
//结果：
//    父类不带参数的构造方法
//    子类不带参数的构造方法
}

class A {
    public int a;
    public int b;
    public A(int a, int b) {
        this.a = a;
        this.b = b;
    }
}
class B extends  A {
    public int c;
    //不加这个构造方法会报错，是因为，子类继承了父类以后必须先帮助父类进行构造
    public B(){
        super(30,20);
        System.out.println("B不带参数的构造方法");
    }
}
public class TextDame2 {
    public static void main(String[] args) {
        B b = new B();
    }
}

4.this和super的区别

4.1相同点

（1）都是java的关键字
（2）都只能在非静态方法中调用，用来访问非静态成员方法和变量
（3）在构造方法中调用，都必须放在构造方法的第一条，且不能同时存在

4.2不同点

（1）this是当前对象的引用，即当前实例方法的对象的引用；super是子类对象从父类继承过来的成员的引用
（2）在非静态成员方法中，this用来访问本类的方法和属性；super用来访问父类继承下来的方法和属性
（3）this是非静态成员方法的一个隐藏参数；super不是隐藏的参数
（4）成员方法中直接访问本类成员时，编译之后会将this还原，即本类非静态成员都是通过this来访问的；在子类中如果通过super访问父类成员，编译之后在字节码层面super实际是不存在的
（5） 在构造方法中，this(…)用于调用本类构造方法；super(…)用于调用父类构造方法，两种调用不能同时在构造方法中出现
（6）构造方法中一定会存在super(…)的调用，用户没有写编译器也会增加，但是this(…)用户不写则没有

class A {
    public int a;
    public int b;
    public A(){
        System.out.println("父类不带参数的构造方法");
    }

    public A(int a, int b) {
        this();//调用本类的不带参数的构造方法，这个不写就没有
        this.a = a;
        this.b = b;
        System.out.println("父类带两个参数的构造方法");
    }
}
class B extends  A {
    public int c;
    public B(){
    	//super();//调用父类的不带参数的构造方法，这个不写编译器会自动加上
        super(23,2);//调用父类的带两个参数的构造方法
        System.out.println("父类不带参数的构造方法");
    }
}
public class TextDame2 {
    public static void main(String[] args) {
        B b = new B();
    }
//结果：
//    父类不带参数的构造方法
//    父类带两个参数的构造方法
//    父类不带参数的构造方法
}

在这里插入图片描述

5.代码块的执行顺序问题

（1）父类静态代码块优先于子类静态代码块执行，且是最早执行
（2）父类实例代码块和父类构造方法紧接着执行
（3）子类的实例代码块和子类构造方法紧接着再执行
（4）第二次实例化子类对象时，父类和子类的静态代码块都将不会再执行（静态的只有一份）

class Animal {
    public String name;
    public int age;
    static {
        System.out.println("Animal的静态代码块");
    }
    {
        System.out.println("Animal的实例代码块");
    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("Animal带有两个参数的构造方法");
    }
}
class Dog extends Animal {
    static {
        System.out.println("Dog的静态代码块");
    }
    {
        System.out.println("Dog的实例代码块");
    }

    public Dog() {
        super("小小", 2);
        System.out.println("Dog不带参数的构造方法");
    }
}
public class TextDame1 {
    public static void main(String[] args) {
        Dog dog1 = new Dog();
        System.out.println("============");
        Dog dog2 = new Dog();
    }
//结果：
//    Animal的静态代码块
//    Dog的静态代码块
//    Animal的实例代码块
//    Animal带有两个参数的构造方法
//    Dog的实例代码块
//    Dog不带参数的构造方法
//    ============
//    Animal的实例代码块
//    Animal带有两个参数的构造方法
//    Dog的实例代码块
//    Dog不带参数的构造方法
}

6.访问修饰限定符

在这里插入图片描述

6.1同一包中的同一类

package extendsText;
public class TextDame2 {
    public int a = 10;
    protected int b = 20;
    int c = 30;
    private int d = 40;

    public static void main(String[] args) {
        TextDame2 textDame2 = new TextDame2();
        System.out.println("同一包中的同一类：" + textDame2.a);
        System.out.println("同一包中的同一类：" + textDame2.b);
        System.out.println("同一包中的同一类：" + textDame2.c);
        System.out.println("同一包中的同一类：" + textDame2.d);
    }
//结果：
//    同一包中的同一类：10
//    同一包中的同一类：20
//    同一包中的同一类：30
//    同一包中的同一类：40
}

6.2同一包中的不同类

package extendText;

public class TextDame2 {
    public int a = 10;
    protected int b = 20;
    int c = 30;
    private int d = 40;
}

package extendText;

public class TextDame1 {
    public static void main(String[] args) {
        TextDame2 textDame2 = new TextDame2();
        System.out.println("同一包中的不同类：" + textDame2.a);
        System.out.println("同一包中的不同类：" + textDame2.b);
        System.out.println("同一包中的不同类：" + textDame2.c);
//        System.out.println("同一包中的不同类：" + textDame2.d);报错，被private修饰的只能在当前类被访问，不同类中使不能访问的
    }
//结果：
//    同一包中的不同类：10
//    同一包中的不同类：20
//    同一包中的不同类：30
}

6.3不同包中的子类

package extendText;

public class TextDame2 {
    public int a = 10;
    protected int b = 20;
    int c = 30;
    private int d = 40;
}

package childText;

import extendText.TextDame2;

public class TextDame3 extends TextDame2 {
    public void method(){
        super.a = 50;
        super.b = 60;
//        super.c = 70;报错，没有写就就是包访问权限，只能在同一个包中访问
//        super.d = 80;报错，被private修饰的只能在当前类被访问
    }
}

6.4不同包中的非子类

package extendText;

public class TextDame2 {
    public int a = 10;
    protected int b = 20;
    int c = 30;
    private int d = 40;
}

package childText;

import extendText.TextDame2;

public class TextDame4 {
    public static void main(String[] args) {
        TextDame2 textDame2 = new TextDame2();
        System.out.println("不一包中的非子类：" + textDame2.a);
//        System.out.println("不一包中的非子类：" + textDame2.b);报错，protected修饰的再不同包中的非子类是不能被访问到的
//        System.out.println("不一包中的非子类：" + textDame2.c);报错，没有写就就是包访问权限，只能在同一个包中访问
//        System.out.println("不一包中的非子类：" + textDame2.d);报错，被private修饰的只能在当前类被访问
    }
}

7.java中支持的继承的方式

（1）单继承
（2）多层继承
（3）不同类继承同一个类
（4）java不支持多继承

8.final关键字

8.1修饰变量或字段

表示该字段或变量为常量

public class TextDame1 {
    public static void main(String[] args) {
        final int a = 10;
//        a = 20;报错，a被final修饰就是常量了，不能被修改
    }
}

8.2修饰类

该类不能被继承

final class A {

}
//报错，被final修饰的类不能被继承
//class B extends A{
//
//}

8.3修饰方法

该方法不能被重写

class A {
    public final void func(){
        System.out.println();
    }
}
class B extends A{
//    被final修饰的方法不能被重写
//    @Override
//    public void func() {
//    
//    }
}

9.组合

（1）继承是is-a的关系
（2）组合是has-a的关系，和继承类似，组合也是一种表达类之间关系的方式，也是能够达到代码重用的效果，组合仅仅是将一个类的实例作为另外一个类的字段

class A{

}
class B{

}
//组合
class  C{
    private A a;
    private B b;
}

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

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

相关文章

估计一个点云的表面法线

估计一个点云的表面法线

包含相关头文件 #include <pcl/io/pcd_io.h> #include <pcl/point_types.h> #include <pcl/features/normal_3d.h> #include <pcl/visualization/pcl_visualizer.h> 定义了两个类型别名 PointT 和 PointNT&#xff0c;用于表示输入点云和输出点云中各…
阅读更多...
第14届蓝桥杯国赛真题剖析-2023年5月28日Scratch编程初中级组

第14届蓝桥杯国赛真题剖析-2023年5月28日Scratch编程初中级组

[导读]&#xff1a;超平老师的《Scratch蓝桥杯真题解析100讲》已经全部完成&#xff0c;后续会不定期解读蓝桥杯真题&#xff0c;这是Scratch蓝桥杯真题解析第149讲。 第14届蓝桥杯Scratch国赛真题&#xff0c;这是2023年5月28日上午举办的全国总决赛&#xff0c;比赛仍然采取…
阅读更多...
进程管道：popen函数实例

进程管道：popen函数实例

基础知识 可能最简单的在两个程序之间传递数据的方法就是使用popen和pclose函数了。它们的原型如下所示&#xff1a; #include <stdio.h>FILE *popen(const char *command, const char *type);int pclose(FILE *stream); 1&#xff0e;popen函数 popen函数允许一个程…
阅读更多...
FTL没有映射，跟发工资没有钱有什么区别

FTL没有映射，跟发工资没有钱有什么区别

大家好&#xff0c;我是五月。 前言 FTL&#xff08;Flash Translation Layer&#xff09;&#xff0c;即闪存转换层&#xff0c;是各种存储设备的核心算法&#xff0c;作用是将Host传下来的逻辑地址转换成物理地址&#xff0c;也就是映射。 地址映射是FTL最原始最基本的功能…
阅读更多...
苹果手机之间如何互传照片？批量传输操作指南

苹果手机之间如何互传照片？批量传输操作指南

很多时候&#xff0c;我们用手机拍摄了好看的照片或者收藏了一些有趣的图片&#xff0c;想要分享给朋友&#xff0c;却不知道苹果手机之间如何互传照片&#xff1f;在分享大量照片的时候不清楚如何批量操作&#xff1f;别担心&#xff0c;下面小编就来分享一下苹果手机照片传输…
阅读更多...
海思3559万能平台搭建：SPI输出h264码流

海思3559万能平台搭建：SPI输出h264码流

前言 面对各种各样的客户需求&#xff0c;spi接口也是一种传码流的形式&#xff0c;spi同步422可以保证抗干扰能力强的同时传输距离也很长&#xff0c;本文会介绍海思平台spi作为主机的发送功能以及发送码流的处理方式 1. 管脚复用&#xff1a; 首先需要配置的肯定是管脚复用&…
阅读更多...
Linux进程间通信【共享内存】

Linux进程间通信【共享内存】

✨个人主页&#xff1a; 北 海 &#x1f389;所属专栏&#xff1a; Linux学习之旅 &#x1f383;操作环境&#xff1a; CentOS 7.6 阿里云远程服务器 文章目录 &#x1f307;前言&#x1f3d9;️正文1、什么是共享内存&#xff1f;2、共享内存的相关知识2.1、共享内存的数据结构…
阅读更多...
load_dataset加载huggingface数据集失败

load_dataset加载huggingface数据集失败

1. 一般的加载方式 from datasets import load_dataset dataset_dict load_dataset(cmrc2018)这种加载方式可能会显示因为连接问题导致失败&#xff0c;此时可以在hugging face里面找到对应的页面下载下来 然后改一下代码&#xff1a; from datasets import load_dataset d…
阅读更多...
springmvc整合thymeleaf

springmvc整合thymeleaf

概述 Thymeleaf提供了一组Spring集成&#xff0c;使您可以将其用作Spring MVC应用程序中JSP的全功能替代品。 这些集成将使您能够&#xff1a; Controller像使用JSP一样&#xff0c;将Spring MVC 对象中的映射方法转发到Thymeleaf管理的模板。在模板中使用Spring表达式语言&…
阅读更多...
罗马不是一天建成的，那为什么建了那么多罗马？

罗马不是一天建成的，那为什么建了那么多罗马？

这一个罗马&#xff0c;那一个罗马&#xff0c;东一个罗马&#xff0c;西一个罗马&#xff0c;世界历史的大半部分都在跟罗马打交道。更要命的是四大文明古国还没有古代罗马。 存在感这么强&#xff0c;还不是四大文明古国&#xff0c;名字还难记&#xff0c;公元前居然就有共…
阅读更多...
【C++】在线编译器推荐，让你随时随地编写代码

【C++】在线编译器推荐，让你随时随地编写代码

▒ 目录 ▒ &#x1f6eb; 问题描述环境 1️⃣ 支持调试网站Repl.itOnlineGDB 2️⃣ 不支持调试网站Wandboxjson.cnjdoodletutorialspointcppshellideonecoliruonline-ide 3️⃣ 性能分析网站Quick C BenchmarkCompare C Builds 4️⃣ 其它C Insights&#xff08;学习模板、C11…
阅读更多...
Hightopo 使用心得（3）- 吸附与锚点

Hightopo 使用心得（3）- 吸附与锚点

吸附与锚点是 HT for Web 中两个比较重要的概念。这两个概念在执行交互和动画时会经常被用到。 吸附&#xff0c;顾名思义&#xff0c;是一个节点吸附到另一个节点上。就像船底的贝类一样&#xff0c;通过吸附到船身&#xff0c;在船移动的时候自己也会跟着移动&#xff1b;而…
阅读更多...
pandas---缺失值的处理

pandas---缺失值的处理

1. 处理缺失值 判断数据中是否包含NaN&#xff1a; pd.isnull(df)&#xff1b;pd.notnull(df) 存在缺失值nan: 删除存在缺失值的:dropna(axisrows) 不会修改原数据&#xff0c;需要接受返回值&#xff1b; 替换缺失值:fillna(value, inplaceTrue) value:替换成的值&#…
阅读更多...
JavaScript数学对象-数字进制转换

JavaScript数学对象-数字进制转换

关注“大前端私房菜”微信公众号&#xff0c;输入暗号【面试宝典】即可免费领取107页前端面试题。 什么是进制 进制就是达到指定位置时候进一位 常见的进制 十进制: 0 1 2 3 4 5 6 7 8 9 10 11 12 ... 99 100 101 二进制: 0 1 10 11 100 101 110 111 1000 八进制: 0 1 2 3 4 …
阅读更多...
走进人工智能|GANs AI时代下的前卫艺术

走进人工智能|GANs AI时代下的前卫艺术

前言&#xff1a; GANs的作用是以生成模型的形式学习数据分布&#xff0c;从而产生逼真的样本数据&#xff0c;可以应用于图像合成、风格转换、视频生成等领域。 文章目录 序言背景适用领域技术支持应用领域程序员如何学总结 序言 GANs&#xff08;生成对抗网络&#xff09;是…
阅读更多...
ASEMI代理台湾光宝LTV-3120光耦合器中文资料

ASEMI代理台湾光宝LTV-3120光耦合器中文资料

编辑-Z LTV-3120是一种高性能光耦&#xff0c;由于其可靠性、效率和多功能性&#xff0c;在各种应用中都很受欢迎。本文将全面了解LTV-3120其功能、应用以及它如何改进您的电子设计。 什么是光电耦合器&#xff1f; 光耦&#xff0c;也称为光隔离器&#xff0c;是一种利用光在…
阅读更多...
Mediapipe实时3D目标检测和跟踪（自动驾驶实现）

Mediapipe实时3D目标检测和跟踪（自动驾驶实现）

&#x1f680; 导语 3D目标检测是根据物体的形状、位置和方向来识别和定位物体的任务。在2D目标检测中&#xff0c;被检测到的物体仅表示为矩形边界框。3D目标检测任务通过预测物体周围的包围框&#xff0c;可以获取物体的三维位置信息。 3D目标检测在各行各业都有广泛的应用。…
阅读更多...
Flink 系列二 Flink 状态化流处理概述

Flink 系列二 Flink 状态化流处理概述

本篇作为Flink系列的第二篇&#xff0c;第一篇是环境准备&#xff0c;需要的同学可以看&#xff1a;https://blog.csdn.net/lly576403061/article/details/130358449?spm1001.2014.3001.5501。希望可以通过系统的学习巩固该方面的知识&#xff0c;丰富自己的技能树。废话不多说…
阅读更多...
jmeter模拟多用户并发

jmeter模拟多用户并发

目录 前言&#xff1a; 一、100个真实的用户 二、100个用户同时登录 前言&#xff1a; JMeter可以轻松地模拟多用户并发&#xff0c;从而测试Web应用程序的性能和稳定性。 一、100个真实的用户 1、一个账号模拟100虚拟用户同时登录和100账号同时登录 区别 &#xff08;…
阅读更多...
运维圣经：Webshell应急响应指南

运维圣经：Webshell应急响应指南

目录 Webshell简介 Webshell检测手段 Webshell应急响应指南 一. Webshell排查 二. 确定入侵时间 三. Web日志分析 四. 漏洞分析 五. 漏洞复现 六. 清除Webshell并修复漏洞 七. Webshell防御方法 Webshell简介 Webshell通常指以JSP、ASP、 PHP等网页脚本文件形式存在…
阅读更多...
最新文章

Copyright @ 2022~2023