【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。

相关文章

关于C++中的虚拟继承的一些总结（虚拟继承，覆盖，派生，隐藏）

关于C++中的虚拟继承的一些总结（虚拟继承，覆盖，派生，隐藏）

1.为什么要引入虚拟继承 虚拟继承是多重继承中特有的概念。虚拟基类是为解决多重继承而出现的。如:类D继承自类B1、B2，而类B1、B2都继承自类A，因此在类D中两次出现类A中的变量和函数。为了节省内存空间，可以将B1、B2对A的继承定义为虚拟继承，而A就成了虚拟基类。实现的代码如下： class A class B1:public virtual A; class B2:pu
阅读更多...
Java五子棋之坐标校正

Java五子棋之坐标校正

上篇针对了Java项目中的解构思维，在这篇内容中我们不妨从整体项目中拆解拿出一个非常重要的五子棋逻辑实现：坐标校正，我们如何使漫无目的鼠标点击变得有序化和可控化呢？ 目录 一、从鼠标监听到获取坐标 1.MouseListener和MouseAdapter 2.mousePressed方法 二、坐标校正的具体实现方法 1.关于fillOval方法 2.坐标获取 3.坐标转换 4.坐
阅读更多...
Spring Cloud：构建分布式系统的利器

Spring Cloud：构建分布式系统的利器

引言 在当今的云计算和微服务架构时代，构建高效、可靠的分布式系统成为软件开发的重要任务。Spring Cloud 提供了一套完整的解决方案，帮助开发者快速构建分布式系统中的一些常见模式（例如配置管理、服务发现、断路器等）。本文将探讨 Spring Cloud 的定义、核心组件、应用场景以及未来的发展趋势。 什么是 Spring Cloud Spring Cloud 是一个基于 Spring
阅读更多...
Javascript高级程序设计(第四版)--学习记录之变量、内存

Javascript高级程序设计(第四版)--学习记录之变量、内存

原始值与引用值 原始值：简单的数据即基础数据类型，按值访问。 引用值：由多个值构成的对象即复杂数据类型，按引用访问。 动态属性 对于引用值而言，可以随时添加、修改和删除其属性和方法。 let person = new Object();person.name = 'Jason';person.age = 42;console.log(person.name,person.age);//'J
阅读更多...
java8的新特性之一（Java Lambda表达式）

java8的新特性之一（Java Lambda表达式）

1：Java8的新特性 Lambda 表达式： 允许以更简洁的方式表示匿名函数（或称为闭包）。可以将Lambda表达式作为参数传递给方法或赋值给函数式接口类型的变量。 Stream API： 提供了一种处理集合数据的流式处理方式，支持函数式编程风格。 允许以声明性方式处理数据集合（如List、Set等）。提供了一系列操作，如map、filter、reduce等，以支持复杂的查询和转
阅读更多...
C++必修：模版的入门到实践

C++必修：模版的入门到实践

✨✨ 欢迎大家来到贝蒂大讲堂✨✨ 🎈🎈养成好习惯，先赞后看哦~🎈🎈 所属专栏：C++学习 贝蒂的主页：Betty’s blog 1. 泛型编程 首先让我们来思考一个问题，如何实现一个交换函数？ void swap(int& x, int& y){int tmp = x;x = y;y = tmp;} 相信大家很快就能写出上面这段代码，但是如果要求这个交换函数支持字符型
阅读更多...
Java面试八股之怎么通过Java程序判断JVM是32位还是64位

Java面试八股之怎么通过Java程序判断JVM是32位还是64位

怎么通过Java程序判断JVM是32位还是64位 可以通过Java程序内部检查系统属性来判断当前运行的JVM是32位还是64位。以下是一个简单的方法： public class JvmBitCheck {public static void main(String[] args) {String arch = System.getProperty("os.arch");String dataM
阅读更多...
详细分析Springmvc中的@ModelAttribute基本知识（附Demo）

详细分析Springmvc中的@ModelAttribute基本知识（附Demo）

目录 前言1. 注解用法1.1 方法参数1.2 方法1.3 类 2. 注解场景2.1 表单参数2.2 AJAX请求2.3 文件上传 3. 实战4. 总结 前言 将请求参数绑定到模型对象上，或者在请求处理之前添加模型属性 可以在方法参数、方法或者类上使用 一般适用这几种场景： 表单处理：通过 @ModelAttribute 将表单数据绑定到模型对象上预处理逻辑：在请求处理之前
阅读更多...
eclipse运行springboot项目，找不到主类

eclipse运行springboot项目，找不到主类

解决办法尝试了很多种，下载sts压缩包行不通。最后解决办法如图： help--->Eclipse Marketplace--->Popular--->找到Spring Tools 3---->Installed。
阅读更多...
JAVA读取MongoDB中的二进制图片并显示在页面上

JAVA读取MongoDB中的二进制图片并显示在页面上

1：Jsp页面： <td><img src="${ctx}/mongoImg/show"></td> 2：xml配置： <?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2