首页 > 编程语言 >Java面向对象03——三大特性之继承

Java面向对象03——三大特性之继承

时间：2024-04-27 09:33:23浏览次数：27  
标签：03 Java 构造方法 子类 void 父类 super public 三大

一、继承（extends）

1.1、继承是什么

继承就是 Java 允许我们用 extends 关键字，让一个类与另一个类建立起一种父子关系；

被继承的类称为父类（基类、超类），继承父类的类都称为子类（派生类） ，当子类继承父类后，就可以直接使用父类公共的属性和方法了

当子类继承父类后，就可以直接使用父类公共的属性和方法了

2.2、继承的用处

来看看下面两个类

图片01

  • 可以看到，一个是学生类，一个是老师类；他们之间都有着相同的特征：成员变量、方法；
  • 这样的话，重复代码又多了，是一种很不好的现象。

我们使用继承，来优化代码

图片02

这样减少代码冗余，提高了代码的复用性，增强类的功能扩展性。

2.3、继承的语法

​ 修饰符 class 子类名 extends 父类名


//父类：定义了一个公用方法ports
public class People {
    public void ports(){
        System.out.println("父类方法被调用！");
    }
}
//子类：使用extends继承了来自父类的people类
public class Student extends People{
 
}
public class ExtendsTest01 {
    public static void main(String[] args) {
        //创建student子类对象
        Student s = new Student(); 
        //由于student类继承了people类，所以子类可以调用父类的公用方法
        s.ports();              
    }

2.4、继承的设计规范

子类们相同特征：共性属性，共性方法；都放在父类中定义；

子类独有的属性，方法；应该定义在子类自己里面。

// 人类：父类
// 包含了子类相同的属性和行为
public class People {
//    1.定义需求中子类们相同的属性
    private String name;
    private int age;
//    2.提供属性对应的getter，setter方法，暴露其取值和赋值
    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;
    }
//    3.定义子类们相同的行为方法：查看课表
    public void queryCourse(){
        System.out.println(name+"查看了课表");
    }
}

//学生类：子类继承People02父类得到属性和行为
public class Student extends People{
//    1.定义学生子类自己独有的属性
    private String className;
 
//    2.提供属性的getter和setter方法，暴露其取值和赋值
    public String getClassName() {
        return className;
    } 
    public void setClassName(String className) {
        this.className = className;
    }
//    3.定义子类自己独有的行为方法：填写听课反馈
    public void writeInfo(){
        System.out.println(className+"的"+getName()+"对老师给出极高的评价！");
    }
}
//教师类：子类 继承父类得到属性和行为
public class Teacher extends People{
//    1.定义子类自己的独有属性
    private String departmentName;
 
//    2.提供属性对应的getter，setter方法，暴露其取值和赋值
    public String getDepartmentName() {
        return departmentName;
    }
 
    public void setDepartmentName(String departmentName) {
        this.departmentName = departmentName;
    }
//    3.定义子类自己独有的行为方法：发布问题
    public void problem(){
        System.out.println(departmentName+"的"+getName()+"老师问：这节课教的怎么样？");
    }
}

//继承测试类
public class ExtendsTest {
    public static void main(String[] args) {
//        1.创建学生对象
        Student02 s = new Student02();
//        1.1调用父类行为方法写入学生信息
        s.setName("海绵宝宝");
        s.setAge(36);
//        1.2调用学生类自己的方法写入所在班级
        s.setClassName("19级比奇堡驾校一班");
//        1.3调用父类的行为方法：查看课表
        s.queryCourse();
        System.out.println("---------------");
 
//        2.创建教师对象
        Teacher02 t = new Teacher02();
//        2.1调用父类行为写入教师信息
        t.setName("泡芙");
        t.setAge(55);
//        2.2调用教师类自己的方法写入部门名称
        t.setDepartmentName("比奇堡驾校金牌教练组");
//        2.3调用父类的行为方法：查看课表
        t.queryCourse();
        System.out.println("---------------");
 
//        3.调用教师子类自己独有的方法：problem 发布问题
        t.problem();
//        4.调用学生子类自己独有的方法：writeInfo 填写反馈
        s.writeInfo();
    }
}

控制台输出结果：

图片03

2.5、继承的特点

子类可以继承父类的属性和行为，但是子类不能继承父类的构造器；

java 是单继承模式：一个类 只能继承一个直接父类；

  • 比如你，只能有一个亲爸，不可能隔壁的老王叔、老杨叔 … 都是你的亲爸吧？ 那从伦理角度看，肯定是不支持
  • 从 Java 的角度的角度看，多继承会造成代码二义性，因此不支持

Java 不支持多继承，但是支持多层继承；

  • 就是你 不可以继承多个爸爸；但是你可以继承你爸的，你爸可以继承你爷爷的，多层继承；
  • 子类A 继承父类B；父类B 可以继承父类 C

Java 中所有的类都是 Object 类的子类。

  • java 中所有的类，要么是直接继承了 Object 类，要么默认继承了 Object 类，要么间接继承了 Object 类；

图片04

二、继承中成员访问的特点

2.1、继承中变量访问的特点

在子类方法中访问一个变量，采用的是就近原则。

  1. 子类局部范围找
  2. 子类成员范围找
  3. 父类成员范围找
  4. 如果都没有就报错(不考虑父亲的父亲…)
class Fu {
    int num = 10;
}
class Zi extends Fu{
    //int num = 20;
    public void show(){
        //num = 30;
        System.out.println(num);
    }
}
public class Demo1 {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show(); // 输出10
    }
}

2.2、super

this & super 关键字：

  • this：代表本类对象的引用
  • super：代表父类存储空间的标识(可以理解为父类对象引用)

在子类方法中，如果想要明确访问父类中成员时，借助super关键字即可。

this 和 super 的使用分别

  • 成员变量：
    • this. 成员变量 - 访问本类成员变量
    • super. 成员变量 - 访问父类成员变量
  • 成员方法：
    • this. 成员方法 - 访问本类成员方法
    • super. 成员方法 - 访问父类成员方法
  • 构造方法：
    • this(…) - 访问本类构造方法
    • super(…) - 访问父类构造方法

2.3、继承中构造方法访问的特点

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

子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化。

//父类，Animal类
class Animal {
	//构造函数
	public Animal() {
		System.out.println("Animal类的无参数构造函数执行");
	}
}
//子类，Cat类
class Cat extends Animal{
	//构造函数
	public Cat() {
        // super(); // 注意子类构造方法中默认会调用基类的无参构造方法：super(),
        // 用户没有写时,编译器会自动添加，而且super()必须是子类构造方法中第一条语句，
        // 并且只能出现一次
		System.out.println("Cat类的无参数构造函数执行");
	}
}

//执行代码
public static void main(String[] args) {
	Cat cat = new Cat(); 
}
//输出结果
Animal类的无参数构造函数执行
Cat类的无参数构造函数执行

在子类构造方法中，并没有写任何关于基类构造的代码，但是在构造子类对象时，先执行基类的构造方法，然后执行子类的构造方法，因为：**子类对象中成员是有两部分组成的，基类继承下来的以及子类新增加的部分 。父子父子肯定是先有父再有子，所以在构造子类对象时候 ，先要调用基类的构造方法，将从基类继承下来的成员构造完整，然后再调用子类自己的构造方法，将子类自己新增加的成员初始化完整 **

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

  1. 通过使用 super 关键字去显示的调用父类的带参构造方法
  2. 子类通过 this 去调用本类的其他构造方法,本类其他构造方法再通过 super 去手动调用父类的带参的构造方法

我们看下面这个例子：

public class MyTest {
	
	public static void main(String[] args) {
		Cat c1 = new Cat(3); 
		System.out.println("名字：" + c1.getName());
		System.out.println("年龄：" + c1.getAge());
	}
}

//父类，Animal类
class Animal {
	//私有属性：名字
	private String name;
	
	//setter and getter
	public void setName(String name) {
		this.name = name;
	}
	public String getName() {
		return name;
	}
	
	//构造函数
	public Animal() {
		
	}
	public Animal(String name) {
		this.name = name;
	}
}

//子类，Cat类
class Cat extends Animal{
	//私有字段：年龄
	private int age;
	
	//setter and getter
	public void setAge(int age) {
		this.age = age;
	}
	public int getAge() {
		return age;
	}
	
	//构造函数
	public Cat() {
		
	}
	public Cat(int age) {
		this.age = age;
	}
}

输出结果

名字：null
年龄：3

因为c1对象没有给name赋值，所以是null了

那么我们给Cat加一个构造方法，给name和age都赋值。如下：

public Cat(String name, int age) {
	this.name = name; //报错
	this.age = age
}

显然这样做是会报错的，因为name已经被父类封装成private的了，不能直接访问，可能有的人会这样做：

public Cat(String name, int age) {
	setName(name); // 因为父类的setName()方法是public的
	this.age = age;
}

显然这样做的确可以做到给父类的name赋值，但这样做是不建议的，我们在构造方法中通常只调用构造方法，不会去调用实例方法，况且当不止一个变量时，用set方法时，我们就要调用好多个实例方法去完成多个变量的赋值。这时候为什么不考虑使用super()方法呢？如下：

public Cat(String name, int age) {
   super(name);
   this.age = age;
}

注意: this(…)super(…) 必须放在构造方法的第一行有效语句，并且二者不能共存

2.4、继承中成员方法的特点

成员方法名字不同

public class Base {
	public void methodA(){
	System.out.println("Base中的methodA()");
	}
}
public class Derived extends Base{
	public void methodB(){
		System.out.println("Derived中的methodB()方法");
	}
	public void methodC(){
		methodB(); // 访问子类自己的methodB()
		methodA(); // 访问父类继承的methodA()
		// methodD(); // 编译失败，在整个继承体系中没有发现方法methodD()
	}
}

所以说，成员方法没有同名时，在子类方法中或者通过子类对象访问方法时，则优先访问自己的，自己没有时再到父类中找，如果父类中也没有则报错。

成员方法名字相同

public class Base {
	public void methodA(){
		System.out.println("Base中的methodA()");
	}
	public void methodB(){
		System.out.println("Base中的methodB()");
	}
}
public class Derived extends Base{
	public void methodA(int a) {
		System.out.println("Derived中的method(int)方法");
	}
	public void methodB(){
		System.out.println("Derived中的methodB()方法");
	}
	public void methodC(){
		methodA(); // 没有传参，访问父类中的methodA()
		methodA(20); // 传递int参数，访问子类中的methodA(int)
		methodB(); // 直接访问，则永远访问到的都是子类中的methodB()，基类的无法访问到
	}
}
@Test
public void test() {
    Derived d = new Derived();
    d.methodC();
}

输出结果：

Base中的methodA()
Derived中的method(int)方法
Derived中的methodB()方法

说明：

  • 通过子类对象访问父类与子类中不同名方法时，优先在子类中找，找到则访问，否则在父类中找，找到则访问，否则编译报错。
  • 通过派生类对象访问父类与子类同名方法时，如果父类和子类同名方法的参数列表不同(重载)，根据调用方法适传递的参数选择合适的方法访问，如果没有则报错；

那么问题来了，如果子类中存在与父类中相同的成员时，那如何在子类中访问父类相同名称的成员呢？

使用 super 关键字

由于设计不好，或者因场景需要，子类和父类中可能会存在相同名称的成员，如果要在子类方法中访问父类同名成员时，该如何操作？直接访问是无法做到的，Java 提供了 super 关键字，该关键字主要作用：在子类方法中访问父类的成员。

public class Base {
	int a;
	int b;
	public void methodA(){
		System.out.println("Base中的methodA()");
	}
	public void methodB(){
		System.out.println("Base中的methodB()");
	}
}
public class Derived extends Base{
	int a; // 与父类中成员变量同名且类型相同
	char b; // 与父类中成员变量同名但类型不同
	// 与父类中methodA()构成重载
	public void methodA(int a) {
		System.out.println("Derived中的method()方法");
	}
	// 与基类中methodB()构成重写(即原型一致，重写后序详细介绍)
	public void methodB(){
		System.out.println("Derived中的methodB()方法");
	}
	public void methodC(){
		// 对于同名的成员变量，直接访问时，访问的都是子类的
		a = 100; // 等价于： this.a = 100;
		b = 101; // 等价于： this.b = 101;
		// 注意：this是当前对象的引用
		// 访问父类的成员变量时，需要借助super关键字
		// super是获取到子类对象中从基类继承下来的部分
		super.a = 200;
		super.b = 201;
		// 父类和子类中构成重载的方法，直接可以通过参数列表区分清访问父类还是子类方法
		methodA(); // 没有传参，访问父类中的methodA()
		methodA(20); // 传递int参数，访问子类中的methodA(int)
		// 如果在子类中要访问重写的基类方法，则需要借助super关键字
		methodB(); // 直接访问，则永远访问到的都是子类中的methodA()，基类的无法访问到
		super.methodB(); // 访问基类的methodB()
	}
}

2.5、super和this

super 和this 都可以在成员方法中用来访问：成员变量和调用其他的成员函数，都可以作为构造方法的第一条语句，那他们之间有什么区别呢？

相同点

  • 都是 Java 中的关键字
  • 只能在类的非静态方法中使用，用来访问非静态成员方法和字段
  • 在构造方法中调用时，必须是构造方法中的第一条语句，并且不能同时存在

不同点

  • this是当前对象的引用，当前对象即调用实例方法的对象，super 相当于是子类对象中从父类继承下来部分成员的引用
  • 在非静态成员方法中，this 用来访问本类的方法和属性，super 用来访问父类继承下来的方法和属性
  • 在构造方法中：this(…)用于调用本类构造方法，super(…)用于调用父类构造方法，两种调用不能同时在构造方法中出现
  • 构造方法中一定会存在super(…)的调用，用户没有写编译器也会增加，但是this(…)用户不写则没有

标签：03,Java,构造方法,子类,void,父类,super,public,三大
From： https://www.cnblogs.com/baiye123/p/18161281

相关文章

  • kali 设置 Java 版本，并更换为 1.8 版本
    kali设置Java版本，并更换为1.8版本1.安装JDK1.下载java1.8：https://repo.huaweicloud.com/java/jdk/8u202-b08/jdk-8u202-linux-x64.tar.gz2.建立目录，将下载的jdk的安装包复制过去并进行解压sudomkdir-p/usr/local/javacpjdk-8u202-linux-x64.tar.gz/usr/l......
  • openharmony 多线程的方式有哪些？两个worker线程数据如何通讯、内存如何共享、与Java多
    OpenHarmony操作系统支持多种多线程并发处理策略，以提升应用的响应速度与帧率，以及防止耗时任务对主线程的干扰。以下是OpenHarmony中的多线程方式，以及Worker线程间的数据通讯和内存共享方法，还有它们与Java多线程的区别：OpenHarmony多线程方式Worker线程：OpenHarmony中的Worker是......
  • 7.Java面向对象
    Java面向对象（物以类聚，分类的思维模式；适合处理复杂的问题）什么是面向对象面向对象编程（OOP）本质：以类的方式组织代码，以对象的形式组织（封装）数据抽象三大特性：封装，继承，多态值传递和引用传递//值传递publicclassDemo04{publicstaticvoidmain(String[]args)......
  • 顺序栈十进制转十六进制，还有键盘输入一个包括 '(' 和 ')' 的字符串string ，判断字符串
    设计一个进制转换程序，使用顺序栈设计一个把十进制数转换为十六进制数的接口，实现当通过键盘输入一个非负的十进制数，可以在终端输出对应的十六进制数。*@brief :十进制转十六进制*@param :@Segstackt*Manager:地址* @unsignedintData:转换的值*@re......
  • 哲学家就餐：死锁及解决方案 Java
    本文首发于公众号：腐烂的橘子哲学家就餐问题是计算机科学中的一个经典问题，1971年由荷兰计算机科学家艾兹格·迪科斯彻提出，五台计算机都试图访问五份共享的磁带时会产生问题，后来东尼·霍尔将其重新表述为哲学家就餐问题[1]。问题的详细描述可以参考链接。通俗来讲，就是有五个哲......
  • 一道关于顺序栈的笔试题：判断一个包含'('和')'的字符串是否有效
    若有一个包括'('和')'的字符串string，判断字符串是否有效。要求设计算法实现检查字符串是否有效，有效的字符串需满足以下条件：A.左括号必须用相同类型的右括号闭合。B.左括号必须以正确的顺序闭合。C.每个右括号都有一个对应的相同类型的左括号。思路图：参考代码：boolSeq......
  • Java_web的复习之maven
    Apachemaven是一个项目管理和构建工具，它基于项目对象管理模型的概念，通过一小段描述信息来管理项目的构建2.作用:方便的依赖管理统一的项目结构标准的项目构建流程3.通过maven中的各种各样的插件，我们就可以完成对应的功能例如通过编译插件就可以对项目进行编译，通过测试插件......
  • SpringBoot+MyBatisPlus报错 Invalid value type for attribute 'factoryBeanObjectTy
    依赖版本org.springframework.boot:spring-boot-starter-web:3.2.5com.baomidou:mybatis-plus-boot-starter:3.5.5错误Invalidvaluetypeforattribute'factoryBeanObjectType'问题原因：这个问题是由于依赖传递导致，在MyBatis起步依赖中的myBatis-spring版本过低，导致程......
  • 我刚开始学习java，我什么也不懂，框架到底是什么，没有框架可以使用java吗
    我刚开始学习java，我什么也不懂，框架到底是什么，没有框架可以使用java吗2024/4/1916:00:01当你刚开始学习Java时，"框架"可能是一个比较抽象的概念。简单来说，框架是一组预先编写好的代码结构和库，它们提供了一种组织和设计你的应用程序的方式。框架旨在简化开发过程，提高代码的可重用......
  • Java并发01---JMM模型、Volatile、CAS操作、自旋锁、ABA问题
    @目录JMM（JavaMemoryModel）Volatile修饰CAS（CompareAndSwap）ABA问题JMM（JavaMemoryModel）首先要明确的是JMM与JVM内存结构不是同一个概念，记的时候不要记混。我们先来回顾一下JVM内存结构，其包括了堆、方法区、虚拟机栈、程序计数器、本地方法区，其中前二者为线程共享，后三者为线程......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99