【JAVA入门】Day09 - 继承

2024-06-21 10:20
文章标签 java 入门 继承 day09

本文主要是介绍【JAVA入门】Day09 - 继承，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

【JAVA入门】Day09 - 继承

文章目录

  • 【JAVA入门】Day09 - 继承
    • 一、继承的定义
    • 二、继承的特点
    • 三、继承的内容分析
      • 3.1 构造方法是否可以被继承
      • 3.2 成员变量是否可以被继承
      • 3.3 成员方法是否可以被继承
    • 四、继承中成员的访问特点
      • 4.1 继承中成员变量的访问特点
      • 4.2 继承中成员方法的访问特点
      • 4.3 方法的重写
      • 4.4 继承中构造方法的访问特点
      • 4.5 this、super 的使用总结

        对象代表什么，就得封装对应的数据，并提供数据对应的行为。
        但是，当几个不同的对象拥有相同的行为时，重复定义这些行为会显得代码非常冗余。以学生类和老师类为例子，学生和老师都会“吃喝拉撒”，这些重复的行为没有必要定义在各自的类中，而是可以抽象为一个笼统的“人”类，在它里面进行定义。

一、继承的定义

        Java 中提供一个关键字 extends，用这个关键字，我们可以让一个类和另一个类建立起继承关系。

public class Student extends Person {}

         Student 称为子类（派生类），Person 称为父类（基类或超类）。
        使用继承有诸多好处：

  • 使用继承可以把多个子类中重复的代码抽取父类中，提高了代码的复用性。
  • 子类可以在父类的基础上，增加其他的功能，使得子类更强大。
             什么时候用继承：
             当类与类之间，存在相同（共性）的内容，并满足子类是父类中的一种，就可以考虑使用继承来优化代码。

二、继承的特点

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

  • 只支持单继承：一个子类只能继承一个父类。
  • 不支持多继承：子类不能同时继承多个父类。
  • 支持多层继承：子类 A 继承父类 B，父类 B 可以继承父类 C。子类 A 直接继承于父类 B，间接继承于父类 C。

         其中，多层继承是有一个源头的：每一个类都直接或间接继承于一个叫 Object 的父类。

【例】多层继承。

public class Animal {public void eat() {System.out.println("吃饭");}public void drink() {System.out.println("喝水");}	
}public class Cat extends Animal {public void catchMouse() {System.out.println("猫在抓老鼠");}
}
public class Dog extends Animal {public void lookHome() {System.out.println("狗在看家");}
}public class Ragdoll extends Cat {
}public class LiHua extends Cat {
}public class Husky extends Dog {public void breakHome() {System.out.println("哈士奇在拆家");}
}public class Teddy extends Dog {public void touch() {System.out.println("泰迪在蹭蹭");}
}public class Test {public static void main(String[] args) {//创建对象并调用方法//1.创建布偶猫的对象Ragdoll rd = new Ragdoll();rd.eat();rd.drink();rd.catchMouse();//2.创建哈士奇的对象Husky hsk = new Husky();hsk.eat();hsk.drink();hsk.breakHome();}
}
  • 还有一个非常重要的点：如果你的类中有 private 修饰的成员，那么其子类便无法访问了。所谓私有，是指只能在本类中访问。

三、继承的内容分析

         子类到底能继承父类中的哪些内容？我们需要结合内存来进行分析。

  • 首先父类的构造方法，子类一定不能继承，子类有它自己的构造方法。
  • 成员变量，父类拥有的成员变量，子类也可以继承下来，但是虽然继承了，但是如果父类拥有的成员变量是 private 修饰的私有成员，是无法访问的。
  • 成员方法，父类拥有的成员方法。如果，成员方法是非私有的，那么子类就可以继承下来并且访问；但是，一旦成员方法用 private 修饰，即私有，那么子类是不能继承该方法的。

3.1 构造方法是否可以被继承

         构造方法是不可以被子类继承的。

3.2 成员变量是否可以被继承

         不论父类中的成员变量是私有的还是非私有的，子类都可以把它们继承下来。
         但是，父类中的私有成员变量在子类中，无法被直接调用。如果想要访问这些变量，可以在父类中写下相应的 public 的 get 和 set 函数，继承到子类中调用之。

3.3 成员方法是否可以被继承

         成员方法是否能被继承，关键看其是否能被添加进虚方法表中。如果父类的一个成员方法是 private 的，那他就不能添加进虚方法表，就不可以被子类继承；如果这个成员方法是非私有的，就可以添加进虚方法表，就可以被子类继承。
         所谓虚方法表，其实就是父类将自己可以被继承的方法写进表中，然后将表交给子类，子类根据这个表进行自己的实例化（这个其实是多态的内容，后面会着重讲）。

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

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

public class Fu {String name = "Fu";
}
public class Zi extends Fu {String name = "Zi";public void ziShow() {System.out.println(name);  //Zi}
}

         继承中对成员变量的访问，采用的是就近原则。上面的代码中，父类中的 name 值为 “Fu”，它被子类继承，而子类中也定义了一个 name 变量，值为 “Zi”，此时根据就近原则，sout 输出的内容是 “Zi”。
         在寻找变量时，JVM 会根据就近原则，从近往远处找，直到找到第一个同名变量为止。

public class Fu {String name = "Fu";
}
public class Zi extends Fu {public void ziShow() {System.out.println(name);  //Fu}
}

         如何规避这个同名变量的问题？我们可以采用 this 和 super 关键字的方法。

public class Fu {String name = "Fu";
}
public class Zi extends Fu {String name = "Zi";public void ziShow() {String name = "ziShow";System.out.println(name);	//ziShowSystem.out.println(this.name);	//ZiSystem.out.println(super.name);	//Fu}
}

         上面的代码中，name 指的就是 ziShow() 中的局部变量 name；this.name 指的是当前类（Zi）中的成员变量 name；super.name 指的是当前类的父类（Fu）中的成员变量 name。
         继承中成员变量会根据这些关键字，从不同位置开始往上找，什么都不加，就是从局部位置往上找；加 this，就是从本类成员位置开始往上找；加 super，就是从父类成员位置开始往上找。

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

         成员方法的直接调用也遵循一个就近原则，谁离我近，我就用谁。想要直接访问父类的方法，也可以使用 super 关键字。
         下面的代码中，我们写了一个 Person 类和一个 Student 类，用 Student 类继承 Person 类，并用一个 Test 测试类来测试（注意看：只有 Test 类用 public 修饰了，这是因为它是程序的入口，main 方法的所在，文件的名称也必须和它相同，一个 .java 文件中只能有一个 public 修饰的 class）。

public class Test {public static void main(String[] args) {Student s = new Student();s.lunch();}
}class Person {public void eat() {System.out.println("吃饭");}public void drink() {System.out.println("喝水");}
}class Student extends Person {public void lunch(){eat();drink();}
}

        根据就近原则，这里的 eat() 和 drink() 都会优先从本类中找，但是本类中没有这两个方法，于是又去父类中找，在父类中找到这两个方法，所以调用之。
        如果将代码改成如下所示：

public class Test {public static void main(String[] args) {Student s = new Student();s.lunch();}
}class Person {public void eat() {System.out.println("吃饭");}public void drink() {System.out.println("喝水");}
}class Student extends Person {public void lunch(){//现在本类中找，结果没找到，还去父类找this.eat();this.drink();//直接在父类中找super.eat();super.drink();}
}

        这样写也是一样的，最终还是会去父类中调这两个方法。
        如果子类中也有两个同名方法，还是参考就近原则，输出情况如下：

public class Test {public static void main(String[] args) {Student s = new Student();s.lunch();}
}class Person {public void eat() {System.out.println("吃饭");}public void drink() {System.out.println("喝水");}
}class Student extends Person {public void eat() {System.out.println("吃意大利面");}public void drink() {System.out.println("喝红茶");}public void lunch(){//直接在本类中找，找到了，因此直接用eat();		//吃意大利面drink();	//喝红茶//直接在父类中找，找到了，用的是父类的super.eat();	//吃饭super.drink();	//喝水}
}

4.3 方法的重写

        刚才这种在子类中写同名方法覆盖父类方法的方式，叫做方法的重写。当父类的方法不能满足子类现在的需求时，需要进行方法重写。
        在继承体系中，子类出现了和父类中一模一样的方法声明，我们就称子类这个方法是重写的方法。
        在重写后的方法上方，我们还需要一个重写注解——@Override。

  • @Override 是放在重写后的方法上，校验子类重写时语法是否正确。
  • 加上注解后如果有红色波浪线，表示语法错误。
  • 建议重写方法全都加@Override注解。

        方法的重写过程发生在继承时：父类将自己内部非private、非static、非final的方法填入一个虚方法表中交给子类继承，然后子类会在父类的基础上再添加自己类中的虚方法，如果此时存在重写，则会覆盖父类中同名的虚方法。因此，方法重写的本质是——覆盖虚方法表。

        方法重写有以下注意事项和要求：

  • 重写方法的名称、形参列表必须与父类中的一致。
  • 子类重写父类方法时，访问权限子类必须大于等于父类（空着不写 < protected < public）。
  • 子类重写父类方法时，返回值类型子类必须小于等于父类。
  • 建议：重写的方法尽量和父类保持一致。
  • 私有方法不能被重写（虚方法表中根本没有私有方法）。
  • 子类也不能重写父类的静态方法（因为根本没有继承下来）。
  • 只有被添加到虚方法表中的方法才能被重写。
public class Test {public static void main(String[] args) {Husky hsk = new Husky();hsk.eat();hsk.drink();hsk.breakHome();SharPei sp = new SharPei();sp.eat();sp.drink();sp.lookHome();ChineseDog cd = new ChineseDog();cd.eat();cd.drink();cd.lookHome();}
}class Dog {public void eat() {System.out.println("吃狗粮");}public void drink() {System.out.println("喝水");}public void lookHome() {System.out.println("看家");}
}class Husky extends Dog {public void breakHome() {System.out.println("拆家");}
}class SharPei extends Dog {@Overridepublic void eat() {super.eat();	//调用父类中的方法，输出“吃狗粮”System.out.println("吃骨头");}
}class ChineseDog extends Dog {@Overridepublic void eat() {System.out.println("吃剩饭");}
}

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

        父类中的构造方法不会被子类继承。
        子类当中的所有构造方法都会默认先访问父类中的无参构造，再执行自己。这是因为父类中的成员变量要继承到子类，子类在初始化时，有可能会使用到父类中的数据，如果父类没有完成初始化，子类就无法使用父类中的数据。
        因此，子类在初始化之前，一定要调用父类的构造方法先完成父类数据空间的初始化。
        事实上，子类构造方法的第一行语句默认是：super()，即使你不写它也存在且缺省，且必须在第一行。

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

public class Zi extends Fu {//super();public Zi() { }
}

        因此，我们如果想直接给子类继承的父类成员变量进行初始化，可以利用 super() 方法，直接调用父类的有参构造方法，在父类中完成这些成员变量的初始化。

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

public class Student extends Person {public Student() {super();System.out.println("子类的无参构造");}public Student(String name, int age) {super(name, age);  //调用父类的有参构造初始化成员变量}
}

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

4.5 this、super 的使用总结

  • this：理解为一个变量，表示当前方法调用者的地址值。this 在内存中存储的形式本质就是一个局部变量，其值为当前方法调用者的地址的值。
  • super：代表父类的存储空间。
  • this 和 super 主要有以下几种用途：
关键字访问成员变量访问成员方法访问构造方法
thisthis.成员变量this.成员方法(…)this(…)
supersuper.成员变量super.成员方法(…)super(…)

        其中，this 调用的是本类的，super 调用的是父类的。
        利用 this 调用本类构造方法，可以起到给一些数据默认值的特效。

public class Student {String name;int age;String school;public Student() {this(null, 0, "实验一小");}public Student(String name, int age, String school) {this.name = name;this.age = age;this.school = school;}
}

        如上代码所示，如果直接使用无参构造的方法生成对象 Student s = new Student()，就会直接再次调用本类的有参构造，从而实现默认姓名为 null，默认年龄为0，默认学校为“实验一小”的效果。

【练习】带有继承结构的标准 Javabean 类。
1.经理
成员变量：工号，姓名，工资，管理奖金。
成员方法：工作（管理其他人），吃饭（米饭）。
2.厨师
成员变量：工号，姓名，工资
成员方法：工作（炒菜），吃饭（米饭）。

public class Employee {private String id;private String name;private double salary;public Employee() {}public Employee(String id,String name,double salary) {this.id = id;this.name = name;this.salary = salary;}public void setId(String id) {this.id = id;}public String getId() {return id;}public void setName(String name) {this.name = name;}public String getName() {return name;}public void setSalary(double salary) {this.salary = salary;}public double getSalary() {return salary;}//工作public void work() {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, double salary, double bonus) {super(id, name, salary);this.bonus = bonus;}public void setBonus(double bonus) {this.bonus = bonus;}public double getBonus() {return bonus;}@Overridepublic void work() {System.out.println("经理在管理其他人");}}

public class Cook extends Employee {public Cook() {}public Cook(String id, String name, double salary) {super(id, name, salary);}@Overridepublic void work() {System.out.println("厨师在做饭");}}

public class Test {public static void main(String[] args) {Manager m = new Manager("111", "张三", 8000, 3000);System.out.println(m.getId() + ", " + m.getName() + "," +m.getSalary() + ", " + m.getBonus());m.work();m.eat();Cook c = new Cook();c.setId("222");c.setName("王五");c.setSalary(8000);System.out.println(c.getId() + ", " + c.getName() + ", " + c.getSalary());c.work();c.eat();}
}

这篇关于【JAVA入门】Day09 - 继承的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1080951。

相关文章

JVM 的类初始化机制

JVM 的类初始化机制

前言 当你在 Java 程序中new对象时，有没有考虑过 JVM 是如何把静态的字节码（byte code）转化为运行时对象的呢，这个问题看似简单，但清楚的同学相信也不会太多，这篇文章首先介绍 JVM 类初始化的机制，然后给出几个易出错的实例来分析，帮助大家更好理解这个知识点。 JVM 将字节码转化为运行时对象分为三个阶段，分别是：loading 、Linking、initialization
阅读更多...
Spring Security 基于表达式的权限控制

Spring Security 基于表达式的权限控制

前言 spring security 3.0已经可以使用spring el表达式来控制授权，允许在表达式中使用复杂的布尔逻辑来控制访问的权限。 常见的表达式 Spring Security可用表达式对象的基类是SecurityExpressionRoot。 表达式描述hasRole([role])用户拥有制定的角色时返回true （Spring security默认会带有ROLE_前缀）,去
阅读更多...
浅析Spring Security认证过程

浅析Spring Security认证过程

类图 为了方便理解Spring Security认证流程，特意画了如下的类图，包含相关的核心认证类 概述 核心验证器 AuthenticationManager 该对象提供了认证方法的入口，接收一个Authentiaton对象作为参数; public interface AuthenticationManager {Authentication authenticate(Authenti
阅读更多...
Spring Security--Architecture Overview

Spring Security--Architecture Overview

1 核心组件 这一节主要介绍一些在Spring Security中常见且核心的Java类，它们之间的依赖，构建起了整个框架。想要理解整个架构，最起码得对这些类眼熟。 1.1 SecurityContextHolder SecurityContextHolder用于存储安全上下文（security context）的信息。当前操作的用户是谁，该用户是否已经被认证，他拥有哪些角色权限…这些都被保
阅读更多...
Spring Security基于数据库验证流程详解

Spring Security基于数据库验证流程详解

Spring Security 校验流程图 相关解释说明（认真看哦） AbstractAuthenticationProcessingFilter 抽象类 /*** 调用 #requiresAuthentication(HttpServletRequest, HttpServletResponse) 决定是否需要进行验证操作。* 如果需要验证，则会调用 #attemptAuthentica
阅读更多...
Spring Security 从入门到进阶系列教程

Spring Security 从入门到进阶系列教程

Spring Security 入门系列 《保护 Web 应用的安全》 《Spring-Security-入门（一）：登录与退出》 《Spring-Security-入门（二）：基于数据库验证》 《Spring-Security-入门（三）：密码加密》 《Spring-Security-入门（四）：自定义-Filter》 《Spring-Security-入门（五）：在 Sprin
阅读更多...
Java架构师知识体认识

Java架构师知识体认识

源码分析 常用设计模式 Proxy代理模式Factory工厂模式Singleton单例模式Delegate委派模式Strategy策略模式Prototype原型模式Template模板模式 Spring5 beans 接口实例化代理Bean操作 Context Ioc容器设计原理及高级特性Aop设计原理Factorybean与Beanfactory Transaction 声明式事物
阅读更多...
Java进阶13讲__第12讲_1/2

Java进阶13讲__第12讲_1/2

多线程、线程池 1.  线程概念 1.1  什么是线程 1.2  线程的好处 2.   创建线程的三种方式 注意事项 2.1  继承Thread类 2.1.1 认识  2.1.2  编码实现  package cn.hdc.oop10.Thread;import org.slf4j.Logger;import org.slf4j.LoggerFactory
阅读更多...
JAVA智听未来一站式有声阅读平台听书系统小程序源码

JAVA智听未来一站式有声阅读平台听书系统小程序源码

智听未来，一站式有声阅读平台听书系统 🌟&nbsp;开篇：遇见未来，从“智听”开始 在这个快节奏的时代，你是否渴望在忙碌的间隙，找到一片属于自己的宁静角落？是否梦想着能随时随地，沉浸在知识的海洋，或是故事的奇幻世界里？今天，就让我带你一起探索“智听未来”——这一站式有声阅读平台听书系统，它正悄悄改变着我们的阅读方式，让未来触手可及！ 📚&nbsp;第一站：海量资源，应有尽有 走进“智听
阅读更多...
在cscode中通过maven创建java项目

在cscode中通过maven创建java项目

在cscode中创建java项目 可以通过博客完成maven的导入 建立maven项目 使用快捷键 Ctrl + Shift + P 建立一个 Maven 项目 1 Ctrl + Shift + P 打开输入框2 输入 "> java create"3 选择 maven4 选择 No Archetype5 输入 域名6 输入项目名称7 建立一个文件目录存放项目，文件名一般为项目名8 确定
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2