AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

【Java 继承】了解Java类的继承的特点，继承的关系，继承的使用，到底什么是继承？

2023-12-25 50
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 【Java 继承】了解Java类的继承的特点，继承的关系，继承的使用，到底什么是继承？


继承的特点 \ 介绍 ❓

特点 ♊

  1. 继承发生在多个类之间
  2. Java允许单继承，多层继承(B类继承A类，C类继承B类)
  3. 被继承的叫做父类(基类 、超类)，继承的叫做子类(派生类)
  4. 子类可继承非私有属性和方法
  5. 子类不能继承父类的构造函数,但是可以调用父类的构造函数
  6. 调用带有参数的构造方法时，使用super(n1…)

继承的使用方式 🔞

在Java中可以使用 extends 关键字 来声明，一个类是从另外一个类中继承下来的

如下代码

public class A {
}
// 这段代码说明 B 继承了 A 类
public class B extends A {
}

* 当子类继承了父类之后，子类就可以调用父类中的方法，如下代码所示

public class Demo {
  public static void main(String[] args) {
    // 程序入口函数
    // new 关键字 进行类实例化
    Cat cat = new Cat();
    // 子类调用父类方法
    cat.eat(); // 吃东西
  }
}
// 父类Animal
public class Animal {
  public void eat() {
    System.out.println("吃东西")
  }
}
// 子类Cat继承父类Animal
public Cat extends Animal {
}

避免重复方法

比如说有两个类，其中的方法是相同的功能

定义一个猫类，一个狗类

// 猫类
public class Cat {
  public String name;
  public int age;
  public void say() {
    System.out.println(name + "喵喵叫");
  }
  public void eat() {
    System.out.println(name + "吃东西");
  }
}
// 狗类
public class Dog {
  public String name;
  public int age;
  public void say() {
    System.out.println(name + "汪汪叫");
  }
  public void eat() {
    System.out.println(name + "吃东西");
  }
}

发现 Cat 与 Dog类有相同的成员变量，和相同的成员方法，所以我们提取出一个主类，Animal，避免重复使用代码，Animal父类包含Cat和Dog类中的成员属性

public class Animal {
  public String name;
  public int age;
  // cat 和 dog类中公共的成员方法
  public void say() {
    System.out.println(name + "在叫");
  }
  public void eat() {
    System.out.println(name + "吃东西");
  }
}

现在父类中有两个成员方法，我们可以修改一下cat类和dog类，如下代码所示

// 狗类
public class Dog extends Animal {
  public void say() {
    System.out.println(name + "汪汪叫");
  }
}
// 猫类
public class Cat extends Animal {
  public void eat() {
    System.out.println(name + "吃东西");
  }
}

子类访问父类的成员变量 🈲

子类使用extends将父类的成员变量及方法继承了下来

子类访问父类的成员变量（直接访问）

//父类
public class Animal {
    //Dog类和Cat类公共的属性
    public String name;
    public int age;
    //Dog类和Cat类公共的方法
    public void eat() {
        System.out.println(name + "吃饭");
    }
}
//子类
public class Dog extends Animal {
    //这里的colour就是子类与父类不同名的成员变量
    public String colour;
    //子类Dog独有的方法
    public void dogCall(){
        System.out.println(name + "汪汪汪");
    }
}

访问父类成员的属性被private修饰时，前面介绍过被private修饰的变量只能在同一个包同一个文件的同一个类下使用，那么此时如何访问：可以利用Generate进行封装

在父类中的age属性使用private修饰，即使DOG继承了父类，也不能对这个属性进行访问，解决办法是对这个属性进行封装

private 声明的属性不能直接访问，但可以通过类提供的方法进行访问

//父类
public class Animal {
    //Dog类和Cat类公共的属性
    public String name;
    private int age;
    //右键选择Generate进行封装
    public int getAge() {
        return age;
    }
    //右键选择Generate进行封装
    public void setAge(int age) {
        this.age = age;
    }
    //Dog类和Cat类公共的方法
    public void eat() {
        System.out.println(name + "吃饭");
    }
}

子类： Dog

//子类
public class Dog extends Animal {
    //这里的colour就是子类与父类不同名的成员变量
    public String colour;
    //子类Dog独有的方法
    public void dogCall(){
        //将从父类继承的name属性赋值
        String name = "小黄";
        //通过getAge访问父类的私有属性age
        System.out.println(name + getAge() + "汪汪汪");
    }
}

入口函数

public class Demo {
    public static void main(String[] args) {
        //通过New关键字进行创建dog对象
        Dog dog = new Dog();
        //通过子类对象访问父类的私有属性age并进行赋值
        dog.setAge(1);
        //通过对象dog调用子类方法
        dog.dogCall(); // 小黄1汪汪汪
    }
}

访问父类与子类同名的成员变量

父类

//父类
public class Animal {
    String name = "小黄";
    //Dog类和Cat类公共的方法
    public void eat() {
        System.out.println(name + "吃饭");
    }
}

子类

//子类
public class Dog extends Animal {
    //子类Dog独有的方法
    public void dogCall() {
        //将从父类继承的name属性赋值
        String name = "小黄";
        System.out.println(name  + "汪汪汪");
    }
}

入口函数

//启动项
public class Demo {
    public static void main(String[] args) {
        //通过New关键字进行创建dog对象
        Dog dog = new Dog();
        //通过对象dog调用子类方法
        dog.dogCall(); // 阿福汪汪汪
    }
}

父类中有属性名为name,子类中也有属性名name,且他们的类型相同，我们通过打印可以看到打印输出的为子类name成员变量的值

在子类成员方法中或者通过子类成员对象访问成员变量时:

  1. 如果访问的成员变量子类有，优先访问子类
  2. 如果访问的成员变量子类没有，访问从父类继承下来的成员变量，如果父类也没有，则编译报错
  3. 如果访问的成员变量子类和父类同名，根据就近原则优先访问子类的成员变量
  4. 也可以通过关键字类访问成员变量（访问子类本类的用this,访问父类的用super)

子类访问父类的成员方法（直接访问）

父类

//父类
public class Animal {
    String name = "小黄";
    //父类的方法eat()
    public void eat() {
        System.out.println(name + "吃饭");
    }
}

子类

//子类
public class Dog extends Animal {
    //子类Dog独有的方法dogCall()
    public void dogCall(){
        //将父类的方法一起添加进来，方便调用
        eat();
        //将从父类继承的name属性赋值
        String name = "小黄";
        System.out.println(name  + "汪汪汪");
    }
}

入口函数

//启动项
public class Demo {
    public static void main(String[] args) {
        //通过New关键字进行创建dog对象
        Dog dog = new Dog();
        //通过对象dog调用子类方法
        dog.dogCall(); // 小黄吃饭  小黄汪汪汪
    }
}

访问父类与子类中同名的方法（优先访问子类）

父类

//父类
public class Animal {
    String name = "小黄";
    //父类的方法eat()
    public void eat() {
        System.out.println(name + "吃饭");
    }
}

子类

//子类
public class Dog extends Animal {
    //子类Dog的方法eat()
    public void eat(){
        //将父类的方法一起添加进来，方便调用
        //将从父类继承的name属性赋值
        String name = "小黄";
        System.out.println(name  + "汪汪汪");
    }
}

程序入口函数

//启动项
public class Demo {
    public static void main(String[] args) {
        //通过New关键字进行创建dog对象
        Dog dog = new Dog();
        //通过对象dog调用子类方法
        dog.eat(); // 小黄汪汪汪
    }
}

如果父类和子类的成员变量和成员方法相同，访问时优先级肯定时子类更高，如何通过子类的方法去访问父类的成员变量或者方法?

super 关键字 🔞

💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤

super.成员变量：表示访问父类的成员变量

super.成员方法： 表示访问父类的成员方法

super()： 表示访问父类的构造方法

super关键字只能在非静态方法中使用 ⭕

💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤💤

super关键字：在子类中访问父类的成员方法或者变量

父类

//父类
public class Animal {
    String name = "大黄";
    //父类的方法eat()
    public void eat() {
        System.out.println(name + "吃饭");
    }
}

子类 使用super调用父类的方法

//子类
public class Dog extends Animal {
    //子类Dog的方法eat()
    public void eat(){
        //将从父类继承的name属性赋值
        String name = "小黄";
        //利用super关键字访问父类中同名的成员变量name
        System.out.println(super.name  + "汪汪汪");
    }
}

启动项

public class DemoApplication {
    public static void main(String[] args) {
        //通过New关键字进行创建dog对象
        Dog dog = new Dog();
        //通过对象dog调用子类方法
        dog.eat(); // 子类中使用super调用父类name，打印结果： 大黄汪汪汪
    }
}

子类构造器 🈲

子类之所以叫子类，因为它继承了父类，但子类是不继承父类的构造器的，他只是进行一个调用

* 如果父类的构造器没有参数，则子类的构造器不需要使用super关键字调用父类的构造器，系统会自动调用父类的无参构造

* 如果父类的构造器带有参数，则必须在子类构造器中通过super关键字调用父类构造器并赋予相应的形参列表

* super(实参列表)必须在构造器的第一行

//父类
public class Animal {
    private int age;
    //父类的无参构造
    public Animal() {
        System.out.println("Animal()的无参构造");
    }
    //父类的有参构造
    public Animal(int age) {
        System.out.println("Animal()的有参构造");
        this.age = age;
    }
}

Dog类：利用super调用父类中的有参构造器

//子类
public class Dog extends Animal {
    private int age;
    //自动调用父类的无参构造
    public Dog() {
        System.out.println("Dog的无参构造");
    }
    public Dog(int age) {
        //利用super调用父类中的有参构造器
        super(200);
        System.out.println("Dog的有参构造"+age);
        this.age = age;
    }
}

Cat类：利用super调用父类中的有参构造器

//Cat类通过extends关键字继承父类Animal
public class Cat extends Animal {
    private int age;
    //调用的无参构造
    public Cat() {
        System.out.println("Cat的无参构造");
    }
    public Cat(int age) {
        //利用super调用父类中的有参构造
        super(100);
        System.out.println("Cat的有参构造"+age);
        this.age = age;
    }
}

入口函数

public class DemoApplication {
    public static void main(String[] args) {
        System.out.println("Dog类继承-----------");
        Dog dog = new Dog();
        Dog dog1 = new Dog(300);
        System.out.println("Cat类继承------------");
        Cat cat = new Cat();
        new Cat(400);
    }
}

输出

Dog类继承-----------
Animal()的无参构造
Dog的无参构造
Animal()的有参构造
Dog的有参构造300
Cat类继承------------
Animal()的无参构造
Cat的无参构造
Animal()的有参构造
Cat的有参构造400
文章标签：
Java
关键词：
Java类
Java继承
Java继承类
Java类的继承
東方幻想鄉
目录
相关文章
java的细水长流
|
10天前
|
Java
java的类详解
在 Java 中，类是面向对象编程的核心概念，用于定义具有相似特性和行为的对象模板。以下是类的关键特性：唯一且遵循命名规则的类名；描述对象状态的私有属性；描述对象行为的方法，包括实例方法和静态方法；用于初始化对象的构造方法；通过封装保护内部属性；通过继承扩展其他类的功能；以及通过多态增强代码灵活性。下面是一个简单的 `Person` 类示例，展示了属性、构造方法、getter 和 setter 方法及行为方法的使用。
java的细水长流
194 82
2的n次方_
|
6天前
|
Java 编译器
Java——类与对象（继承和多态）
本文介绍了面向对象编程中的继承概念，包括如何避免重复代码、构造方法的调用规则、成员变量的访问以及权限修饰符的使用。文中详细解释了继承与组合的区别，并探讨了多态的概念，包括向上转型、向下转型和方法的重写。此外，还讨论了静态绑定和动态绑定的区别，以及多态带来的优势和弊端。
2的n次方_
20 9
Java——类与对象（继承和多态）
2的n次方_
|
6天前
|
SQL Java 编译器
Java——类与对象（封装）
封装是面向对象编程中的概念，指将数据（属性）和相关操作（方法）组合成独立单元（类），使外部无法直接访问对象的内部状态，只能通过提供的方法进行交互，从而保护数据安全。例如，手机将各种组件封装起来，只暴露必要的接口供外部使用。实现封装时，使用`private`关键字修饰成员变量，并提供`get`和`set`方法进行访问和修改。此外，介绍了包的概念、导入包的方式及其注意事项，以及`static`关键字的使用，包括静态变量和方法的初始化与代码块的加载顺序。
2的n次方_
18 10
Java——类与对象（封装）
2的n次方_
|
6天前
|
Java C语言
Java——类与对象
这段内容介绍了Java中的类和对象、`this`关键字及构造方法的基本概念。类是对现实世界事物的抽象描述，包含属性和方法；对象是类的实例，通过`new`关键字创建。`this`关键字用于区分成员变量和局部变量，构造方法用于初始化对象。此外，还介绍了标准JavaBean的要求和生成方法。
2的n次方_
18 9
Java——类与对象
2的n次方_
|
5天前
|
存储 安全 Java
Java——String类详解
String 是 Java 中的一个类，用于表示字符串，属于引用数据类型。字符串可以通过多种方式定义，如直接赋值、创建对象、传入 char 或 byte 类型数组。直接赋值会将字符串存储在串池中，复用相同的字符串以节省内存。String 类提供了丰富的方法，如比较（equals() 和 compareTo()）、查找（charAt() 和 indexOf()）、转换（valueOf() 和 format()）、拆分（split()）和截取（substring()）。此外，还介绍了 StringBuilder 和 StringJoiner 类，前者用于高效拼接字符串，后者用于按指定格式拼接字符串
2的n次方_
11 1
Java——String类详解
java的细水长流
|
7天前
|
存储 Java
Java的对象和类的相同之处和不同之处
在 Java 中，对象和类是面向对象编程的核心。
java的细水长流
43 18
java的细水长流
|
1天前
|
Java 开发者
Java Character 类详解
Java中的`Character`类是`java.lang`包的一部分，用于将基本类型`char`封装为对象，并提供了丰富的静态方法来处理字符，如类型判断、大小写转换等。
java的细水长流
19 8
java的细水长流
|
1天前
|
安全 Java
Java StringBuffer 和 StringBuilder 类详解
在 Java 中，`StringBuffer` 和 `StringBuilder` 用于操作可变字符串，支持拼接、插入、删除等功能。两者的主要区别在于线程安全性和性能：`StringBuffer` 线程安全但较慢，适用于多线程环境；`StringBuilder` 非线程安全但更快，适合单线程环境。选择合适的类取决于具体的应用场景和性能需求。通常，在不需要线程安全的情况下，推荐使用 `StringBuilder` 以获得更好的性能。
java的细水长流
14 7
java的细水长流
|
1天前
|
Java 索引
Java String 类详解
Java 中的 `String` 类用于表示不可变的字符序列，是 Java 标准库 `java.lang` 包的一部分。字符串对象一旦创建，其内容不可更改，修改会生成新对象。
java的细水长流
15 7
java的细水长流
|
5天前
|
Java
Java Character 类详解
`Character` 类是 Java 中的一个封装类，位于 `java.lang` 包中，主要用于处理单个字符。它是一个最终类，提供了多种静态方法来检查和操作字符属性，如判断字符是否为字母、数字或空格，以及转换字符的大小写等。此外，`Character` 类还支持自动装箱和拆箱，简化了 `char` 和 `Character` 之间的转换。以下是一些示例代码，展示了如何使用 `Character` 类的方法来检查字符属性和执行字符转换。掌握 `Character` 类的用法有助于更高效地处理字符数据。
java的细水长流
13 2

热门文章

最新文章

  • 1
    Java设计模式(一)----单例模式
  • 2
    Spring框架（SpringBoot）中redis报错（Could not get a resource from the pool、java.net.SocketTimeoutException）
  • 3
    SpringBoot运行出现 Lookup method resolution failed； nested exception is java.lang.IllegalStateException
  • 4
    Java编程(位运算符)
  • 5
    【万字长文】Java面试八股文：深入剖析常见问题与解答
  • 6
    Java编程基础阶段笔记 day01 Java语言概述
  • 7
    JVM深入学习：Java解析Class文件过程解析
  • 8
    Java读取XML与xls文件
  • 9
    Java基础05 实施接口
  • 10
    Java多线程之ReentrantReadWriteLock
  • 1
    Java集合的分类有哪些？
    74
  • 2
    java基于云部署的SaaS医院云HIS系统源码 心理CT、B超 lis、电子病历
    86
  • 3
    Java 并发编程的探索与实践
    48
  • 4
    Maven 构建 Java 项目
    55
  • 5
    18：面向切面编程-Java Spring
    71
  • 6
    17：缓存机制-Java Spring
    82
  • 7
    16：事务-Java Spring
    49
  • 8
    15：MyBatis对象关系与映射结构-Java Spring
    87
  • 9
    Java串口通信：从十六进制字符串到字节数组的正确转换与发送
    210
  • 10
    Java中如何使用Socket类检测端口是否存在
    79

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 基于ECS搭建Java Web开发环境
  • 使用Aliyun Java Intializr进行项目开发
  • 搭建Java Web开发环境
  • 部署基于Dragonwell的Java运行环境
  • 阿里云平台上进行Java程序的编译与运行
  • RocketMQ中使用Java客户端发送消息和消费的应用
    • 下一篇
    基于LNMP搭建WordPress