Java SE——面向对象继承

已于 2023-11-25 13:20:45 修改
阅读量126 收藏
点赞数 1
分类专栏： # Java SE 文章标签： java 开发语言
于 2023-08-16 15:35:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Sakurapaid/article/details/132320938
版权

 前言

本博客文章已收录至专栏Java SE，阅读其他有关博客笔记请转至该专栏下查阅

传送门 -->程序员雨空集_Java SE专栏

继承定义

在Java中，类的继承是指一个现有类的基础上去构建一个新的类

构建出来的新类称为子类（派生类），现有类称为父类（基类或超类）

子类继承父类的属性和方法，使得子类对象（实例）具有父类特征与行为

可以将类的继承比喻为家族的传承关系

假设有一个家族，家族的祖先是父类，后代是子类。父类拥有一些特征和行为，比如有一定的财产、姓氏、家族传统等。子类是基于父类的基础上构建出来的，子类继承了父类的特征和行为，比如继承了财产、姓氏、家族传统等

在这个家族中，每个子类对象（家族成员）都具有父类的特征和行为，比如他们都有一定的财产、姓氏和遵循家族传统。同时，子类也可以拥有自己独有的特征和行为，比如子类可以在父类的基础上增加一些新的财产、姓氏和家族传统

这样，通过继承，子类对象既具有了父类的特征和行为，也可以拥有自己独有的特征和行为，实现了特征和行为的传承和扩展

类的继承关系可以帮助我们在编程中实现代码的重用和扩展。通过继承，我们可以定义一个通用的父类，然后在子类中根据具体需求进行扩展和定制，使得代码更加灵活和可维护

继承格式

当定义一个子类时，可以使用 extends关键字来指定它所继承的父类下

class 父类{
    ...
}
class 子类 extends 父类{
    ...
}
class Animal {
    String name;
    
    public void eat() {
        System.out.println("Animal is eating");
    }
}

class Dog extends Animal {
    public void bark() {
        System.out.println("Dog is barking");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.name = "Tom";
        dog.eat(); // 继承自父类Animal的方法
        dog.bark(); // 子类Dog自己定义的方法
    }
}

在这个示例中，Animal类是父类，Dog类是子类。子类Dog使用extends关键字继承了父类Animal。子类Dog继承了父类Animal的属性和方法，包括name属性和eat()方法。子类Dog还可以定义自己独有的属性和方法，比如bark()方法

在Main类的main()方法中，我们创建了一个Dog对象dog，并对其进行操作。我们可以看到，dog对象既可以调用继承自父类Animal的eat()方法，也可以调用子类Dog自己定义的bark()方法

继承特点

  1. Java只支持单继承，不支持多继承，但支持多层继承

单继承：一个子类只能继承一个父类

多继承：一个子类只能继承一个父类（这是C++的特性）

多层继承：子类 A 继承父类 B，父类B 可以 继承父类 C

就像爷、父、孙关系

  1. 每一个类都直接或者间接的继承于 Object类

当一个类没有显式地指定它的父类时，它默认继承自Object类

如果一个类显式地指定了它的父类，那么它将直接继承自指定的父类，而间接地继承自Object类（因为它的父类继承 Object类）

使用继承的好处

  • 可以把多个子类中重复的代码抽取到父类中了，提高代码的复用性

通过继承，可以将多个子类中共有的属性和方法抽取到父类中，避免了在每个子类中重复编写相同的代码。这样一来，代码的复用性大大提高，减少了代码的冗余，同时也方便了代码的维护和修改。如果需要修改共有的属性或方法，只需要在父类中进行修改，所有子类都会受到影响

  • 子类可以在父类的基础上，增加其他的功能，使子类更强大

通过继承，子类可以继承父类的属性和方法，并在此基础上增加自己特有的属性和方法。这样一来，子类不仅具有了父类的特征和行为，还可以扩展自己的功能，使子类更加强大和灵活。子类可以根据自己的需求进行定制，实现了代码的扩展性

何时用到继承

  • 当类与类之间，存在相同(共性)的内容，并满足子类是父类中的一种，就可以考虑使用继承，来优化代码

假设我们要定义一个动物类，并且有不同种类的动物，比如狗、猫、鸟等。这些动物都有一些共同的属性和行为，比如都有名字和年龄的属性，都可以吃饭和睡觉

在这个场景下，我们可以定义一个父类Animal，包含名字和年龄属性，以及吃饭和睡觉的方法。然后，我们可以定义子类Dog、Cat、Bird等，它们继承了Animal类的属性和方法

这样，我们就可以在子类中添加特有的属性和方法。比如，Dog类可以添加一个属性来表示品种，Cat类可以添加一个属性来表示是否喵喵叫，Bird类可以添加一个属性来表示是否会飞

// Animal类定义
public class Animal {
    private String name;
    private int age;

    // 构造方法
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 吃饭方法
    public void eat() {
        System.out.println(name + " is eating.");
    }

    // 睡觉方法
    public void sleep() {
        System.out.println(name + " is sleeping.");
    }
}

// Dog类定义，继承自Animal类
public class Dog extends Animal {
    private String breed;

    // 构造方法
    public Dog(String name, int age, String breed) {
        super(name, age);
        this.breed = breed;
    }

    // 特有方法
    public void bark() {
        System.out.println(getName() + " is barking.");
    }
}

// Cat类定义，继承自Animal类
public class Cat extends Animal {
    private boolean meow;

    // 构造方法
    public Cat(String name, int age, boolean meow) {
        super(name, age);
        this.meow = meow;
    }

    // 特有方法
    public void meow() {
        if (meow) {
            System.out.println(getName() + " is meowing.");
        } else {
            System.out.println(getName() + " is not meowing.");
        }
    }
}

// Bird类定义，继承自Animal类
public class Bird extends Animal {
    private boolean canFly;

    // 构造方法
    public Bird(String name, int age, boolean canFly) {
        super(name, age);
        this.canFly = canFly;
    }

    // 特有方法
    public void fly() {
        if (canFly) {
            System.out.println(getName() + " is flying.");
        } else {
            System.out.println(getName() + " cannot fly.");
        }
    }
}

// 测试代码
public class AnimalTest {
    public static void main(String[] args) {
        Dog dog = new Dog("Buddy", 3, "Golden Retriever");
        dog.eat();
        dog.sleep();
        dog.bark();

        Cat cat = new Cat("Tom", 5, true);
        cat.eat();
        cat.sleep();
        cat.meow();

        Bird bird = new Bird("Polly", 2, true);
        bird.eat();
        bird.sleep();
        bird.fly();
    }
}

通过使用继承，我们可以避免在每个子类中重复定义共有的属性和方法，提高了代码的复用性。同时，子类可以根据自己的特点进行扩展，实现了代码的灵活性和可扩展性

总结起来，当类与类之间存在共同的属性和行为，并且子类是父类的一种特殊情况时，可以考虑使用继承来优化代码。通过继承，可以提高代码的复用性和可维护性，同时也可以实现代码的扩展和定制

子类能继承父类的哪些内容

  1. 子类不能继承父类的构造方法

如果子类继承了父类的构造方法，将不符合构造方法的定义规则，构造方法名必须和类名一致

构造方法特点:

方法名与类名一致，大小写也要一样

没有返回值类型，void 都没有

没有具体的返回值(不能由return带回结果)

  1. 子类可以继承父类的成员变量
  • 如果是公共的成员变量，则没什么问题
  • 如果成员变量时私用的，则子类无法直接访问，须通过getter/setter方法访问父类的私有成员变量
  1. 子类可以继承父类的成员方法

仅限于父类的符合虚方法表定义的成员方法

虚方法表：不被static、final、private修饰的方法

在继承关系中，从最顶级的父类开始，从高往低依次继承父级的虚方法表

继承后的成员特点

继承后的成员变量特点

  • 就近原则：谁离我近，我就用谁
  • 先局部、再本类（子类）、再父类

就近原则情况针对于变量名重名情况：

public class Fu {
    String name = "123"; //父类成员变量name
}
class Zi extends Fu{
    String name = "12";	//本类（子类）成员变量name
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.method();
    }
    public void method(){
        String name = "1";	//局部变量name
        System.out.println("输出：" + name);
    }
}
输出：1
public class Fu {
    String name = "123"; //父类成员变量name
}
class Zi extends Fu{
    String name = "12";	//本类（子类）成员变量name
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.method();
    }
    public void method(){
        //String name = "1";	//局部变量name
        System.out.println("输出：" + name);
    }
}
输出：12
public class Fu {
    String name = "123"; //父类成员变量name
}
class Zi extends Fu{
    //String name = "12";	//本类（子类）成员变量name
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.method();
    }
    public void method(){
        //String name = "1";	//局部变量name
        System.out.println("输出：" + name);
    }
}
输出：123

如果变量名不重名则无影响：

class Fu {
	// Fu中的成员变量
	int num = 5;
}
class Zi extends Fu {
	// Zi中的成员变量
	int num2 = 6;
  
	// Zi中的成员方法
	public void show() {
		// 访问父类中的num
		System.out.println("Fu num="+num); // 继承而来，所以直接访问。
		// 访问子类中的num2
		System.out.println("Zi num2="+num2);
	}
}
class Demo04 {
	public static void main(String[] args) {
        // 创建子类对象
		Zi z = new Zi(); 
      	// 调用子类中的show方法
		z.show();  
	}
}

演示结果：
Fu num = 5
Zi num2 = 6

super 关键字

子父类中出现了同名的成员变量时，在子类中需要访问父类中非私有成员变量时，需要使用super 关键字，修饰父类成员变量，类似于之前学过的 this

需要注意的是：super代表的是父类对象的引用，this代表的是当前对象的引用

使用格式：

super.父类成员变量名
class Fu {
	// Fu中的成员变量。
	int num = 5;
}

class Zi extends Fu {
	// Zi中的成员变量
	int num = 6;
  
	public void show() {
        int num = 1;
      
        // 访问方法中的num
        System.out.println("method num=" + num);
        // 访问子类中的num
        System.out.println("Zi num=" + this.num);
        // 访问父类中的num
        System.out.println("Fu num=" + super.num);
	}
}

class Demo04 {
	public static void main(String[] args) {
      	// 创建子类对象
		Zi1 z = new Zi1(); 
      	// 调用子类中的show方法
		z1.show(); 
	}
}

演示结果：
method num=1
Zi num=6
Fu num=5

继承后的成员方法特点

  • 成员方法不重名

如果子类父类中出现不重名的成员方法，这时的调用是没有影响的。对象调用方法时，会先在子类中查找有没有对应的方法，若子类中存在就会执行子类中的方法，若子类中不存在就会执行父类中相应的方法

class Fu {
	public void show() {
		System.out.println("Fu类中的show方法执行");
	}
}
class Zi extends Fu {
	public void show2() {
		System.out.println("Zi类中的show2方法执行");
	}
}
public  class Demo05 {
	public static void main(String[] args) {
		Zi z = new Zi();
     	//子类中没有show方法，但是可以找到父类方法去执行
		z.show(); 
		z.show2();
	}
}
  • 成员方法重名

如果子类父类中出现重名的成员方法，则创建子类对象调用该方法的时候，子类对象会优先调用自己的方法（就近原则）

class Fu {
	public void show() {
		System.out.println("Fu show");
	}
}
class Zi extends Fu {
	//子类重写了父类的show方法
	public void show() {
		System.out.println("Zi show");
	}
}
public class ExtendsDemo05{
	public static void main(String[] args) {
		Zi z = new Zi();
     	// 子类中有show方法，只执行重写后的show方法
		z.show();  // Zi show
	}
}

方法重写

方法重写 ：子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现覆盖效果，子类的方法把父类的方法覆盖掉了，也称为重写或者复写。声明不变，重新实现

例如：我们定义了一个动物类代码如下：

public class Animal  {
    public void run(){
        System.out.println("动物跑的很快！");
    }
    public void cry(){
        System.out.println("动物都可以叫~~~");
    }
}

然后定义一个猫类，猫可能认为父类cry()方法不能满足自己的需求

代码如下：

public class Cat extends Animal {
    public void cry(){
        System.out.println("我们一起学猫叫，喵喵喵！喵的非常好听！");
    }
}

public class Test {
	public static void main(String[] args) {
      	// 创建子类对象
      	Cat ddm = new Cat()；
        // 调用父类继承而来的方法
        ddm.run();
      	// 调用子类重写的方法
      	ddm.cry();
	}
}

@Override 重写注解

  • @Override:注解，重写注解校验！
  • 这个注解标记的方法，就说明这个方法必须是重写父类的方法，否则编译阶段报错
  • 建议重写都加上这个注解，一方面可以提高代码的可读性，一方面可以防止重写出错！
    加上后的子类代码形式如下：
public class Cat extends Animal {
     // 声明不变，重新实现
    // 方法名称与父类全部一样，只是方法体中的功能重写写了！
    @Override
    public void cry(){
        System.out.println("我们一起学猫叫，喵喵喵！喵的非常好听！");
    }
}

注意点：

  1. 方法重写是发生在子父类之间的关系
  2. 子类方法覆盖父类方法，必须要保证权限大于等于父类权限
  3. 子类方法覆盖父类方法，返回值类型、函数名和参数列表都要一模一样

继承后的构造方法特点

这里考虑的是继承后对构造方法产生的影响：当类之间产生了关系，其中各类中的构造方法，又产生了哪些影响呢？
首先我们要回忆两个事情，构造方法的定义格式和作用。

  1. 构造方法的名字是与类名一致的。所以子类是无法继承父类构造方法的。
  2. 构造方法的作用是初始化对象成员变量数据的。所以子类的初始化过程中，必须先执行父类的初始化动作。子类的构造方法中默认有一个super() ，表示调用父类的构造方法，父类成员变量初始化后，才可以给子类使用。（先有爸爸，才能有儿子）

继承后子类构方法器特点:子类所有构造方法的第一行都会默认先调用父类的无参构造方法

class Person {
    private String name;
    private int age;

    public Person() {
        System.out.println("父类无参");
    }

    // getter/setter省略
}

class Student extends Person {
    private double score;

    public Student() {
        //super(); // 调用父类无参,默认就存在，可以不写，必须再第一行
        System.out.println("子类无参");
    }
    
     public Student(double score) {
        //super();  // 调用父类无参,默认就存在，可以不写，必须再第一行
        this.score = score;    
        System.out.println("子类有参");
     }

}

public class Demo07 {
    public static void main(String[] args) {
        Student s1 = new Student();
        System.out.println("----------");
        Student s2 = new Student(99.9);
    }
}

输出结果：
父类无参
子类无参
----------
父类无参
子类有参
  • 子类构造方法执行的时候，都会在第一行默认先调用父类无参数构造方法一次。
  • 子类构造方法的第一行都隐含了一个super()去调用父类无参数构造方法，super()可以省略不写。
雨空集
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
java面向对象程序综合设计课程设计
01-10
在这个“Java面向对象程序综合设计课程设计”中，我们将关注Java语言的面向对象特性，包括封装、继承和多态，以及如何在实际项目中运用这些概念。 1. 封装：封装是面向对象三大特性之一，它将数据和操作数据的方法...
个人学习的java笔记——思维导图
01-25
Java是一种广泛使用的面向对象的编程语言，尤其在后端开发领域有着重要的地位。这份"个人学习的java笔记——思维导图"是作者学习Java过程中的总结，通过思维导图的形式，将复杂的概念和知识结构化，便于理解和记忆。...
JAVA面向对象之继承
weixin_34392435的博客
12-24 117
继承是指通过某种机制使得当前定义的类可以使用现有类的所有可以继承的功能（属性和方法）而不用重新编写原来的类，从而简化类的定义，实现代码的复用。通过继承创建的新类称为“子类”或“派生类”，被继承的类称为“基类”、“父类”或“超类”。所以继承的另一种表述为：子类可以继承父类的属性和方法，以实现代码复用。 JAVA只支持单继承，不允许多重继...
黑马程序员_JAVA_面向对象（二）
tang667788的专栏
11-25 240
----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------   java中有23种设计模式： 单例设计模式：★★★★★ 解决的问题：保证一个类在内存中的对象唯一性。 比如：多个程序读取一个配置文件时，建议配置文件封装成对象。会方便操作其中数据，又要保证多个程序读到的是同一个配置文件对象，就需要该配置文件对象在内存中是唯一的。
Java中对象的继承
花遇和风的博客
12-26 177
对象的继承 1. 重载（Overload） 方法名相同，参数列表不同，和返回值类型无关。 2. 重写（Override） 也称为覆盖。方法名、参数列表、返回值类型全相同（或者是父类方法中参数列表、返回值的子类）。 3. 一道面试题 重写时： 1.子类的参数类型或返回值 <= 父类的参数类型或返回值； 2.子类中的方法的访问级别 >= 父类相应方法的访问级别。 ...
java对象的继承_JAVA面向对象 - 继承
weixin_39955233的博客
02-20 82
继承可以解决代码的复用，让我们的编程更加靠近人类思维，当多个类存在相同的属性和方法时，可以从这些类中抽象出父类，在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过extends语句来声明继承。注意事项Ⅰ.java 中支持单继承，不直接支持多继承，但对c++中的多继承机制进行改良。Ⅱ.ava支持多层(多重)继承Ⅲ.Java所有类都是Object类的子类Ⅳ.JDK中有...
java之对象继承性
qq_41534929的博客
01-02 744
面对对象的继承性 1.为什么要设计继承性？2.通过“class A extends B”类实现类的继承。 子类：A 父类（或基类 SuperClass）: B 子类继承父类以后，父类中声明的属性、方法，子类就可以获取到。 明确：当父类中有私有的属性或方法时，子类同样可以获取得到，只是由于封装性 的设计，使得子类不可以直接调用罢了。子类除了通过继承，获取父类的结构之外，还可以定义自己的持有
java面向对象编程指南
04-08
在Java中，面向对象编程（OOP）主要包含三个核心原则：封装、继承和多态。 1. 封装：这是面向对象编程的基础，它允许我们将数据和操作这些数据的方法绑定在一个单元——对象中。在Java中，我们通过定义类来实现封装...
Java面向对象第2版代码.zip
07-03
《Java面向对象编程第二版》是一本深入探讨Java编程中面向对象特性的教材。这个压缩包包含了一系列章节的源代码示例，旨在帮助学习者更好地理解和应用Java的面向对象概念。下面将对这些章节涉及的知识点进行详细阐述...
java SE 例子
07-27
此外，面向对象编程的概念——类、对象、继承、封装和多态性也是Java SE的基础内容。通过例子，我们可以更直观地看到这些概念如何在实际代码中应用。 在Java中，类库提供了丰富的功能，比如集合框架（ArrayList、...
java面向对象之java继承
最新发布
weixin_51884452的博客
06-30 251
java继承
java面向对象之继承
qq56hm的博客
04-20 358
文章目录java面向对象之继承面向对象的三大特性之二 继承 java面向对象之继承 面向对象的三大特性之二 继承
JAVA面向对象（继承）
2987345656@qq.com的博客
08-01 1260
继承 在Java中，类的继承是指在一个现有类的基础上构建一个新的类，构建出来的新类被称作子类，现有的类被称作父类，子类会自动地拥有父类所有可继承的属性和方法。 子类继承自父类，父类派生子类。 class Person { String name; // 声明一个Person类,有成员方法speak()和walk() public void speak() { S...
java对象继承对象_Java继承，第2部分：对象及其方法
cxu0262的博客
06-30 477
java对象继承对象 Java提供了一个由数千个类和其他引用类型组成的标准类库。 尽管它们的功能存在差异，但这些类型通过直接或间接扩展Object类来形成一个庞大的继承层次结构。 对于您创建的任何类和其他引用类型，也是如此。 关于Java继承的本教程的前半部分向您展示了继承的基础知识，特别是如何使用Java的extends和super关键字从父类派生子类，调用父类的构造函数和方法，覆盖方法等...
Java面向对象：继承
Stardust_fantasy的博客
04-17 2655
Java中的继承是一个对象获取父对象的所有属性和行为的机制
Java面向对象-继承（知识点总结）
liuyi13220377309的博客
04-25 455
Java面向对象-继承（知识点总结） 继承是通过关键字extends实现的 格式：class 子类 extends 父类{} 1.在Java中，被继承的类被称为父类，基类或超类，与之对应的类称为子类或派生类。父类是子类的一般化，子类是父类的特化（具体化)。 2.（Java不支持多继承——即：只能单继承，一个子类只能继承一个父类；但支持多重继承——例如：A类继承B类，B类继承C类，A是B的子类，B是C的子类） 继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和...
Java基础学习第十讲：Java面向对象---继承
跟着老高学Java
01-16 536
Java面向对象—继承 面向对象简称 OO（Object Oriented），20 世纪 80 年代以后，有了面向对象分析（OOA）、 面向对象设计（OOD）、面向对象程序设计（OOP）等新的系统开发方式模型的研究。对 Java 语言来说，一切皆是对象。把现实世界中的对象抽象地体现在编程世界中，一个对象代表了某个具体的操作。一个个对象最终组成了完整的程序设计，这些对象可以是独立存在的，也可以是从别的对象继承过来的。对象之间通过相互作用传递信息，实现程序开发。 面向对象的三大核心特性： 封装性 继承性 多态
Java面向对象之：继承，全是你要的干货
Java Punk
02-18 522
继承是java语言的三大特征之一。
【JavaSE】继承（子类中访问父类成员变量 子类中访问父类成员方法 super关键字 子类构造方法 super和this 再谈初始化 proteced关键字 final关键字 继承与组合）
m0_68800221的博客
05-11 2440
假如我们能将目前这两个类当中共同的属性进行抽取，放到一个类当中，需要的时候去那个类拿就可以了。super和this都可以在成员方法中用来访问：成员变量和调用其他的成员函数，都可以作为构造方法的第一条语句。super和this都可以在成员方法中用来访问：成员变量和调用其他的成员函数，都可以作为构造方法的第一条语句。这里就体现在了继承上了。如果子类中存在与父类中相同的成员时，在子类中访问父类相同名称的成员要用super。观察我们写的代码，写了一个狗类，一个猫类，不管是狗还是猫，它都有很多共同的属性。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

雨空集

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

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

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

打赏作者

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

抵扣说明：

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

余额充值