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

相关文章

Java实现检查多个时间段是否有重合

Java实现检查多个时间段是否有重合

《Java实现检查多个时间段是否有重合》这篇文章主要为大家详细介绍了如何使用Java实现检查多个时间段是否有重合,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下... 目录流程概述步骤详解China编程步骤1：定义时间段类步骤2：添加时间段步骤3：检查时间段是否有重合步骤4：输出结果示例代码结语作
阅读更多...
Java中String字符串使用避坑指南

Java中String字符串使用避坑指南

《Java中String字符串使用避坑指南》Java中的String字符串是我们日常编程中用得最多的类之一,看似简单的String使用,却隐藏着不少“坑”,如果不注意,可能会导致性能问题、意外的错误容... 目录8个避坑点如下：1. 字符串的不可变性：每次修改都创建新对象2. 使用 == 比较字符串，陷阱满
阅读更多...
Java判断多个时间段是否重合的方法小结

Java判断多个时间段是否重合的方法小结

《Java判断多个时间段是否重合的方法小结》这篇文章主要为大家详细介绍了Java中判断多个时间段是否重合的方法,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下... 目录判断多个时间段是否有间隔判断时间段集合是否与某时间段重合判断多个时间段是否有间隔实体类内容public class D
阅读更多...
IDEA编译报错“java: 常量字符串过长”的原因及解决方法

IDEA编译报错“java: 常量字符串过长”的原因及解决方法

《IDEA编译报错“java:常量字符串过长”的原因及解决方法》今天在开发过程中,由于尝试将一个文件的Base64字符串设置为常量,结果导致IDEA编译的时候出现了如下报错java:常量字符串过长,... 目录一、问题描述二、问题原因2.1 理论角度2.2 源码角度三、解决方案解决方案①：StringBui
阅读更多...
Java覆盖第三方jar包中的某一个类的实现方法

Java覆盖第三方jar包中的某一个类的实现方法

《Java覆盖第三方jar包中的某一个类的实现方法》在我们日常的开发中,经常需要使用第三方的jar包,有时候我们会发现第三方的jar包中的某一个类有问题,或者我们需要定制化修改其中的逻辑,那么应该如何... 目录一、需求描述二、示例描述三、操作步骤四、验证结果五、实现原理一、需求描述需求描述如下：需要在
阅读更多...
Java中ArrayList和LinkedList有什么区别举例详解

Java中ArrayList和LinkedList有什么区别举例详解

《Java中ArrayList和LinkedList有什么区别举例详解》：本文主要介绍Java中ArrayList和LinkedList区别的相关资料,包括数据结构特性、核心操作性能、内存与GC影... 目录一、底层数据结构二、核心操作性能对比三、内存与 GC 影响四、扩容机制五、线程安全与并发方案六、工程
阅读更多...
JavaScript中的reduce方法执行过程、使用场景及进阶用法

JavaScript中的reduce方法执行过程、使用场景及进阶用法

《JavaScript中的reduce方法执行过程、使用场景及进阶用法》：本文主要介绍JavaScript中的reduce方法执行过程、使用场景及进阶用法的相关资料,reduce是JavaScri... 目录1. 什么是reduce2. reduce语法2.1 语法2.2 参数说明3. reduce执行过程
阅读更多...
如何使用Java实现请求deepseek

如何使用Java实现请求deepseek

《如何使用Java实现请求deepseek》这篇文章主要为大家详细介绍了如何使用Java实现请求deepseek功能,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下... 目录1.deepseek的api创建2.Java实现请求deepseek2.1 pom文件2.2 json转化文件2.2
阅读更多...
Java调用DeepSeek API的最佳实践及详细代码示例

Java调用DeepSeek API的最佳实践及详细代码示例

《Java调用DeepSeekAPI的最佳实践及详细代码示例》：本文主要介绍如何使用Java调用DeepSeekAPI,包括获取API密钥、添加HTTP客户端依赖、创建HTTP请求、处理响应、... 目录1. 获取API密钥2. 添加HTTP客户端依赖3. 创建HTTP请求4. 处理响应5. 错误处理6.
阅读更多...
Spring AI集成DeepSeek的详细步骤

Spring AI集成DeepSeek的详细步骤

《SpringAI集成DeepSeek的详细步骤》DeepSeek作为一款卓越的国产AI模型,越来越多的公司考虑在自己的应用中集成,对于Java应用来说,我们可以借助SpringAI集成DeepSe... 目录DeepSeek 介绍Spring AI 是什么？1、环境准备2、构建项目2.1、pom依赖2.2
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2