1. Toy模板网首页
  2. > Toy博客

学习JavaEE的日子 day14 继承，super()，this()，重写

9月前 作者：牛马程序员‍ 分类：Toy博客 阅读(52) 违法举报

这篇具有很好参考价值的文章主要介绍了学习JavaEE的日子 day14 继承，super()，this()，重写。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

Day14

1.继承的使用

理解：子类继承父类所有的属性和方法

使用场景：多个类似的类，有相同的属性和方法，就可以把相同属性和方法抽取到父类

优点：减少代码的冗余； 使类与类之间产生了关系(多态的前提)

缺点：继承会增加类与类之间的关系，会增加代码的维护难度

需求：编写中国人和日本人的类，创建各自的对象

分析：

  人类：

  	属性：姓名、性别、年龄

  	方法：吃饭饭、睡觉觉

  中国人的类 继承 人类 ：

  	属性：身份证

  	方法：打太极

  日本人的类 继承 人类：

  	属性：年号

​ 方法：拍电影

//父类
public class Person {
	
	String name;
	char sex;
	int age;
	
	public void eat(){
		System.out.println(this.name + "吃饭饭");
	}
	
	public void sleep(){
		System.out.println(this.name + "睡觉觉");
	}
}

//            子类           继承        父类
public class Chinese extends Person{

	String id;
	
	public void playTaiJi(){
		System.out.println("中国人打太极");
	}
}

//			     子类           继承        父类
public class Japanese extends Person{

	String yearNum;
	
	public void playVideo(){
		System.out.println("日本人拍电影");
	}
}

//测试类
public class Test01 {
	public static void main(String[] args) {
		
		//创建对象
		Chinese c = new Chinese();
		
		//操作父类属性
		c.name = "小彭";
		c.sex = '男';
		c.age = 21;
		
		//操作子类属性
		c.id = "1234567890";
		
		//调用父类方法
		c.eat();
		c.sleep();
		
		//调用子类方法
		c.playTaiJi();
		
		System.out.println("-----------------------------");
		
		//创建对象
		Japanese j = new Japanese();
		
		//操作父类属性
		j.name = "波多野结衣";
		j.sex = '女';
		j.age = 18;
		
		//操作子类属性
		j.yearNum = "令和";
		
		//调用父类方法
		j.eat();
		j.sleep();
		
		//调用子类方法
		j.playVideo();
		
	}
}

继承内存图：

学习JavaEE的日子 day14 继承，super()，this()，重写,学习JavaEE,学习,java-ee,继承,super（）,this（）,重写

父类空间优先于子类对象产生

在每次创建子类对象时，先初始化父类空间，再创建其子类对象本身。目的在于子类对象中包含了其对应的父类空间，便可以包含其父类的成员，如果父类成员非private修饰，则子类可以随意使用父类成员。代码体现在子类的构造方法调用时，一定先调用父类的构造方法

小结

1.继承实际上是子类相同的属性和行为可以定义在父类中，子类特有的属性和行为由自己定义，这样就实现了相同属性和行为的重复利用，从而提高了代码复用。

2.继承是在多个类中之间的，使用关键字extends，在父类的非私有属性和方法可以被子类继承

3.java是单继承的

2.继承的深入

面试题

1.创建子类对象，会调用父类的构造方法吗？

会

2.创建子类对象，为什么会调用父类构造方法？

因为会在子类对象中开辟空间，用于存储父类的成员属性

3.创建子类对象，先调用父类构造方法还是子类构造方法？

先调用子类的构造方法

4.创建子类对象，先完成父类构造方法还是子类构造方法？

先完成父类的构造方法

5.子类对象是否能继承父类所有的属性和方法？

Java官网上，明确表示子类不能继承父类私有化的属性和方法，这是站在使用的角度

实际上，子类能继承父类私有化的属性方法，但是不能直接使用，可以在父类中编写公有方法去调用私有的属性和方法

*值得注意的是子类可以继承父类的私有成员（成员变量，方法），只是子类无法直接访问而已，可以通过在父类中设置get/set方法访问父类的private成员变量。*

public class Father {
private String fatherAttr = "父类私有化属性";

public Father() {
	System.out.println("调用父类的构造方法");
}

public String getFatherAttr() {
	return fatherAttr;
}

public void setFatherAttr(String fatherAttr) {
	this.fatherAttr = fatherAttr;
}

private void method01(){
	System.out.println("父类私有化方法");
}

public void method02(){
	method01();
}
}

public class Son extends Father{

	public Son() {
		//super();//默认实现：调用父类的构造方法,所以首先完成父类构造方法，再执行下一句
		System.out.println("调用子类的构造方法");
	}
}

//测试类
public class Test01 {
  public static void main(String[] args) {
	
	Son son = new Son();
	
	System.out.println(son.getFatherAttr());
	
	son.method02();
  }
}

3.super

理解：super表示父类

super代表的是父类对象的引用，this代表的是当前对象的引用。*

作用：

1.super.属性：在子类中，调用父类的非私有化的成员属性（不常用，因为属性已经私有化了）

2.super.方法：在子类中，调用父类的非私有化的成员方法

3.super()：在子类构造方法中的第一句调用父类的非私有化的构造方法

需求：编写中国人和日本人的类，创建各自的对象

public class Person {
	
	private String name;
	
	public Person() {
	}
	
	public Person(String name) {
		this.name = name;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public void eat(){
		System.out.println(this.name + "吃饭饭");//name这个属性是本类的，所以使用this，而不是super
	}
}

public class Chinese extends Person{

	private String id;
	
	public Chinese() {
	}
	
	public Chinese(String name,String id) {
		super(name);//子类中把父类的成员变量一起有参构造出来，方便使用
		this.id = id;
	}

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}

	public void playTaiJi(){
		
		System.out.println(super.getName() + "打太极");//super.属性：用的是分类的成员变量，子类中没有名字这个属性
	}
}

public class Japanese extends Person{

	private String yearNum;
	
	public Japanese() {
	}
	
	public Japanese(String name,String yearNum) {
		super(name);
		this.yearNum = yearNum;
	}

	public String getYearNum() {
		return yearNum;
	}

	public void setYearNum(String yearNum) {
		this.yearNum = yearNum;
	}

	public void playVideo(){
		System.out.println(super.getName() + "拍电影");//super.属性：用的是分类的成员变量，子类中没有名字这个属性
	}
}

public class Test01 {
	public static void main(String[] args) {
	
	//创建对象
	Chinese c = new Chinese("小彭", "1234567890");
	
	//调用父类方法
	c.eat();
	
	//调用子类方法
	c.playTaiJi();
	
	System.out.println("-----------------------------");
	
	//创建对象
	Japanese j = new Japanese("波多野结衣",  "令和");
	
	//调用父类方法
	j.eat();
	
	//调用子类方法
	j.playVideo();
	
}
}

小结 - 编写一个类的步骤：

1.属性

2.私有化属性

3.无参构造

4.有参构造

5.get/set方法

6.其他的方法

3.1 继承后的特点——构造方法

构造方法的名字是与类名一致的。

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

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

子类构造方法的第一行都隐含了一个super()调用父类无参数构造方法，super()可以省略不写。

3.2 super和this的用法格式

this.成员变量 – 本类的

this.成员方法名() – 本类的

super.成员变量 – 父类的

super.成员方法名() – 父类的

接下来我们使用调用构造方法格式：

this(…) – 调用本类的其他构造方法，根据参数匹配确认

super(…) – 调用父类的构造方法，根据参数匹配确认

注意：

*子类的每个构造方法中均有默认的super()，调用父类的空参构造。手动调用父类构造会覆盖默认的super()。*

*super() 和 this() 都必须是在构造方法的第一行，所以不能同时出现。*

4.重写/复写

理解：在子类中，将父类的方法重新写一遍

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

应用场景：父类方法不能被改动时，在子类中重新写一遍

条件：

1.在子类中重写父类的方法

2.返回值、方法名、参数列表必须跟父类重写的方法一致

3.访问修饰符不能比父类更严格

面试题：重写(overriding)与重载(overloading)的区别？

重写是发生在子父类继承关系中方法名相同，参数列表相同，返回值相同，子类访问修饰符要大于等于父类的修饰符，子类的异常声明必须小于等于父类的异常声明；

方法重载发生在同一个类中,方法名相同，参数列表不同，返回值无关。

需求：编写中国人和日本人的类，创建各自的对象

public class Test01 {	
	public static void main(String[] args) {
	//创建对象
	Chinese c = new Chinese("小彭", "1234567890");
	
	c.eat();//调用子类重写后的方法
	
	System.out.println("-----------------------------");
	
	//创建对象
	Japanese j = new Japanese("波多野结衣","令和");
	
	j.eat();//调用子类重写后的方法
	
}
}

public class Person {
	
	private String name;
	
	public Person() {
	}
	
	public Person(String name) {
		this.name = name;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public void eat(){
		System.out.println(this.name + "吃饭饭");
	}
}

public class Chinese extends Person{

	private String id;
	
	public Chinese() {
	}
	
	public Chinese(String name, String id) {
		super(name);
		this.id = id;
	}

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}
	
	//@Override -- 重写的注解
	//注解：给程序员和系统解释代码信息
	@Override
	public void eat(){
		System.out.println(super.getName() + "吃山珍海味");
	}
}

public class Japanese extends Person{

	private String yearNum;
	
	public Japanese() {
	}
	
	public Japanese(String name,String yearNum) {
		super(name);
		this.yearNum = yearNum;
	}

	public String getYearNum() {
		return yearNum;
	}

	public void setYearNum(String yearNum) {
		this.yearNum = yearNum;
	}

	@Override
	public void eat() {
		System.out.println(super.getName() + "吃生鱼片");
	}
}

4.1 @Override重写注解

@Override:注解，重写注解校验！

这个注解标记的方法，就说明这个方法必须是重写父类的方法，否则编译阶段报错。

建议重写都加上这个注解，一方面可以提高代码的可读性，一方面可以防止重写出错！

4.2 注意事项

1.方法重写是发生在子父类之间的关系。

2.子类方法覆盖父类方法，必须要保证权限大于等于父类权限。

3.子类方法覆盖父类方法，返回值类型、函数名和参数列表都要一模一样。

4.父类中的方法使用private，static，final任意修饰符，那么，不能被子类重写。

5.总结

1.继承的使用

2.继承的深入 — 重要

3.super

4.重写文章来源地址https://www.toymoban.com/news/detail-811322.html

到了这里，关于学习JavaEE的日子 day14 继承，super()，this()，重写的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 学习JavaEE的日子 day12 构造方法 类的制作

    学习JavaEE的日子 day12 构造方法 类的制作

    需求：创建人类的对象，并操作对象 分析： 人类 - Person 属性：name、sex、age 方法：eat、sleep 场景：创建多个对象，去操作对象 面向对象内存图： 注意： 1.class文件只加载一次 2.class文件中包含了该类中的所有信息(包含方法等) 3.new对象会在堆中开辟空间，存储成员变量 4.成员

    2024年01月17日
    浏览(52)
  • 学习JavaEE的日子 Day33 File类，IO流

    学习JavaEE的日子 Day33 File类，IO流

    File是文件和目录路径名的抽象表示 File类的对象可以表示文件：C:UsersDesktophhy.txt File类的对象可以表示目录路径名：C:UsersDesktop File只关注文件本身的信息（文件名、是否可读、是否可写…），而不能操作文件里面的内容 对文件里的数据进行操作的是：IO流 需求1：通过程序

    2024年04月12日
    浏览(40)
  • 学习JavaEE的日子 day13补 深入类加载机制及底层

    学习JavaEE的日子 day13补 深入类加载机制及底层

    初识类加载过程 使用某个类时，如果该类的class文件没有加载到内存时，则系统会通过以下三个步骤来对该类进行初始化 1.类的加载（Load） → 2.类的连接（Link） → 3.类的初始化（Initialize） 类的加载（Load）：将类的class文件读入内存，并为之创建一个java.lang.Class的对象，此

    2024年01月18日
    浏览(50)

  • Java 继承、super() 关键字使用、super 和 this的区别

    2024年02月15日
    浏览(37)
  • java面向对象——继承以及super关键字

    java面向对象——继承以及super关键字

    在 同⼀类 中，存在⽅法名相同，参数列表不同（个数、类型或顺序不同）的⽅法互为重载。 在 继承关系 中，⼦类声明⼀个继承⾃⽗类的⽅法名相同、参数列表相同，返回值类型⼀致，访问修饰符相同或 变⼤，抛出异常相同或缩⼩的⽅法称为重写。 重载是编译时多态，重写

    2024年02月12日
    浏览(39)

  • JavaSE基础(19) super，this 关键字

    子类对象的创建过程： 子类的构造方法中，默认先调用父类的无参构造方法。如果没有显示的调用，那么隐含着super()。         可以访问父类的属性         可以访问父类的方法         指代父类的构造方法， 如果有多个，靠参数来区分。要在第一行。      

    2023年04月10日
    浏览(37)
  • 类的继承和super关键字的使用（JAVA）

    类的继承和super关键字的使用（JAVA）

    目录 继承 super   子类的构造方法 final 所有的OOP语言都会有三个特征： 封装（点击可跳转） 继承 多态（点击可跳转） 为什么会有继承呢？可以先看下面的例子：         上面这两个类中的代码很相似因为它们只有最后一个方法不同其它的都相同，这样定义不但导致代码

    2024年02月14日
    浏览(41)

  • JavaScript的static、this、super关键字介绍

    static： ☆ static用于定义类的静态方法和静态属性。 ☆ 静态方法是直接与类相关联的方法，不需要实例化类即可调用。 ☆ 静态属性是类本身的属性，而不是实例的属性。 ☆ 在静态方法内部，不能使用this来引用实例，因为静态方法与特定实例无关。 th

    2024年02月16日
    浏览(37)
  • 【Java 基础】引用型数组、Java 继承、super 关键字详解

    【Java 基础】引用型数组、Java 继承、super 关键字详解

    《 Java 零基础入门到精通 》 专栏持续更新中。通过本专栏你将学习到 Java 从 入门 到 进阶 再到 实战 的全套完整内容，所有内容均将集中于此专栏。无论是初学者还是有经验的开发人员，都可从本专栏获益。 订阅专栏后添加我微信或者进交流群，进群可找我领取 前端/Java

    2024年02月03日
    浏览(47)
  • C++学习Day08之类模板碰到继承的问题以及解决

    C++学习Day08之类模板碰到继承的问题以及解决

    必须要指定出父类中的T数据类型，才能给子类分配内存 正确使用 ： 输出： 输出： 在类模板碰到继承的问题时，要指定出父类中的T数据类型，才能给子类分配内存

    2024年02月22日
    浏览(32)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包