Java面向对象（十二）——构造方法（方法调用、内存图解）、this关键字（调用构造方法、原理图）、super关键字

最新推荐文章于 2022-11-13 12:13:39 发布

kww_

最新推荐文章于 2022-11-13 12:13:39 发布

阅读量2.2k

点赞数 2

分类专栏： java

本文链接：https://blog.csdn.net/qq_40243295/article/details/111935391

版权

java 专栏收录该内容

44 篇文章 7 订阅

订阅专栏

第一章构造方法

1.1构造方法介绍

那什么是构造方法呢？从字面上理解即为构建创造时用的方法，即就是对象创建时要执行的方法。

既然是对象创建时要执行的方法，那么只要在new对象时，知道其执行的构造方法是什么，就可以在执行这个方法的时候给对象进行属性赋值。

构造方法的格式：

修饰符构造方法名(参数列表)

{

}

构造方法的体现：

构造方法没有返回值类型。也不需要写返回值。因为它是为构建对象的，对象创建完，方法就执行结束。

构造方法名称必须和类名保持一致。

构造方法没有具体的返回值。

自动生成get与set方法：alt+shift+s

package cn.itcast.demo01;
/*
 *  自定义的Person类.成员变量,name age
 *  要求在 new Person的同时,就指定好name,age的值
 *  实现功能,利用方法去实现, 构造方法,构造器 Constructor
 *  作用: 在new 的同时对成员变量赋值, 给对象的属性初始化赋值  new Person 对属性 name,age赋值
 *  
 *  构造方法的定义格式
 *    权限  方法名(参数列表){
 *    }
 *    方法的名字,必须和类的名字完全一致
 *    构造方法不允许写返回值类型  , void 也不能写
 *    
 *    构造方法在什么时候,运行呢, 在new 的时候,自动执行
 *    只运行一次,仅此而已
 *    
 *    每个class必须拥有构造方法,构造方法不写也有
 *    编译的时候,javac, 会自动检查类中是否有构造方法
 *    如果有,就这样的
 *    如果没有,编译器就会自动添加一个构造方法
 *      编译器自动添加的构造方法: public Person(){}
 *    自己手写了构造方法,编译的时候,不会自动添加构造方法!
 */
public class Person {
	private String name;
	private int age;
	
	//定义出Person类的构造方法
	public  Person(String name,int age){
		this.name = name;
		this.age = age;
		//System.out.println("我是一个空参数构造方法");
	}
	
	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;
	}
	
	
}

package cn.itcast.demo01;
/*
 *  new 对象的时候,就是在调用对象的构造方法
 *   new Person(); 调用的是类中的空参数构造方法
 *   new Person("张三",20); 调用类中的有参数构造方法
 */
public class Test {
	public static void main(String[] args) {
		Person p = new Person("张三",20);		
		//对象p 调用方法getName,getAge
		System.out.println(p.getName());
		System.out.println(p.getAge());
		
	}
}

1.2构造方法调用和内存图解

new对象的时候，就是在调用对象的构造方法。

如果自己未定义构造方法，编译器会自动添加一个构造方法。若自己手动写了构造方法，编译时不会自动添加构造方法。

内存图解：

main函数进栈，Person p = new Person("张三",20);进入堆内存，并为其成员变量初始化为空， Person对象调用自己的构造方法，构造方法进栈内存运行。

Person对象将内存地址传递给this关键字。构造方法运行结束了，整个对象才算建立完成。

1.3默认构造方法和细节

在之前学习的过程中，描述事物时，并没有显示指定构造方法，当在编译Java文件时，编译器会自动给class文件中添加默认的构造方法。如果在描述类时，我们显示指定了构造方法，那么，当在编译Java源文件时，编译器就不会再给class文件中添加默认构造方法。

class  Person {

    //如果没有显示指定构造方法，编译会在编译时自动添加默认的构造方法

    //Person(){}  //空参数的默认构造方法

}

当描述的事物在创建其对象时就要明确属性的值，这时就需要在定义类的时候书写带参数的构造方法。

若创建对象时不需要明确具体的数据，这时可以不用书写构造方法（不书写也有默认的构造方法）。

构造方法的细节：

一个类中可以有多个构造方法，多个构造方法是以重载的形式存在的

构造方法是可以被private修饰的，作用：其他程序无法创建该类的对象。

1.4构造方法和一般方法区别

到目前为止，学习两种方法，分别为构造方法和一般方法（get、set方法），那么他们之间有什么异同呢？

构造方法在对象创建时就执行了，而且只执行一次。

一般方法是在对象创建后，需要使用时才被对象调用，并可以被多次调用。

有了构造方法之后可以对对象的属性进行初始化，那么还需要对应的set和get方法吗？

需要相应的set和get方法，因为对象在创建之后需要修改和访问相应的属性值时，在这时只能通过set或者get方法来操作。

package cn.itcast.demo02;
/*
 *   构造方法的重载特性
 *     参数列表不同
 */
public class Person {
	private String name;
	private int age;
	
	//写空参数构造方法
	public Person(){
		
	}
	
	//写带有两个参数的构造方法
	public Person(String name,int age){
		this.name = name;
		this.age = age;
	}
	
	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;
	}
	
	
}

package cn.itcast.demo02;

public class Test {
	public static void main(String[] args) {
		//创建Person类的对象
		//就是在调用他的构造方法
		
		//1. 调用空参数构造方法,创建对象
		Person p1 = new Person();
		p1.setAge(18);
		p1.setName("旺财");
		System.out.println(p1.getName()); 
		System.out.println(p1.getAge()); 
		
		//2. 调用有2个参数的构造方法,创建对象
		Person p2 = new Person("小强", 17);
		System.out.println(p2.getName());
		System.out.println(p2.getAge());
		
	}
}

1.5总结

继承中的构造方法注意事项：

    1.如果我们手动给出了构造方法，编译器不会在给我们提供默认的空参数构造方法

           如果我们没写任何的构造方法，编译器提供给我们一个空参数构造方法

    2.在构造方法中，默认的第一条语句为 super();

       它是用来访问父类中的空参数构造方法，进行父类成员的初始化操作

    3.当父类中没有空参数构造方法的时候，怎么办？

            a: 通过 super(参数) 访问父类有参数的构造方法

            b: 通过 this(参数) 访问本类中其他构造方法

               注意:[本类中的其他构造方法已经能够正常访问父类构造方法]

     4.super(参数) 与 this(参数) 不能同时在构造方法中存在

第二章 this关键字

方法之间是可以通过方法名相互调用的，那么构造方法之间能不能相互调用呢？若可以，怎么调用呢？

2.1this调用构造方法

构造方法之间的调用，可以通过this关键字来完成。

构造方法调用格式：

this(参数列表);
且this()必须放在构造方法的第一行

package cn.itcast.demo03;
/*
 *   this可以在构造方法之间进行调用
 *   this.的方式,区分局部变量和成员变量同名情况
 *   this在构造方法之间的调用,语法 this()
 */
public class Person {
	private String name;
	private int age;
	
	public Person(){
		//调用了有参数的构造方法
		//参数李四,20传递给了变量name,age
		this("李四",20);
	}
	/*
	 *  构造方法,传递String,int
	 *  在创建对象的同时为成员变量赋值
	 */
	public Person(String name,int age){
		this.name = name;
		this.age = age;
	}
	
	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;
	}
	
	
}

package cn.itcast.demo03;

public class Test {
	public static void main(String[] args) {
		//创建Person的对象,调用的是空参数的构造方法
		//运行的结果 null 0
		Person p = new Person();
		
		System.out.println(p.getName());
		System.out.println(p.getAge());
	}
}

2.2 this的原理图解

内存图解释：

main方法先入栈，执行new Person(),new Person()进入堆内存，并为其分配内存地址，随后为成员变量赋默认值，调用无参的构造方法。

此时Person（）入栈，执行其内部语句，调用this（“李四”，20），此时含参数的构造方法入栈执行。

赋值结束后，含参数的构造方法出栈，随后无参的构造方法出栈。执行结束。

第三章 super关键字

3.1 子父类中构造方法的调用

public class Test {
	public static void main(String[] args) {
		new Zi();
	}
	
}
class Fu{
	int num ;
	Fu(){
		System.out.println("Fu构造方法"+num);
		num = 4;
	}
}
class Zi extends Fu{
	Zi(){
         //super(); 调用父类空参数构造方法
		System.out.println("Zi构造方法"+num);
	}
}

执行结果：

　　 Fu构造方法0

　　 Zi构造方法4

通过结果发现，子类构造方法执行时中，调用了父类构造方法，这说明，子类构造方法中有一句隐式的super()。

那么，子类中的构造方法为什么会有一句隐式的super()呢？

原因：子类会继承父类中的内容，所以子类在初始化时，必须先到父类中去执行父类的初始化动作。这样，才可以使用父类中的内容。

当父类中没有空参数构造方法时，子类的构造方法必须有显示的super语句，指定要访问的父类有参数构造方法。

内存图解释：

父类先进方法区，子类再进方法区，并且子类通过super找到父类的存储地址。

super为父类存储的内存地址。

先有子类的堆内存空间，将其划分为两部分，一部分留给父类，另一部分留给自己。父类的成员变量，跟随子类的对象进入堆内存。

3.2 子类对象创建过程的细节

super（）也必须为构造方法的第一行（this()也必须是第一行）

如果父类的构造方法有参，则子类的构造函数中必须super()显示调用,否则会报错。

因为编译器默认添加的是无参的super()

如果子类的构造方法第一行写了this调用了本类其他构造方法，那么super调用父类的语句还有吗？

这时是没有的，因为this()或者super(),只能定义在构造方法的第一行，因为初始化动作要先执行。

父类构造方法中是否有隐式的super呢？

也是有的。记住：只要是构造方法默认第一行都是super();

父类的父类是谁呢？super调用的到底是谁的构造方法呢？

Java体系在设计，定义了一个所有对象的父类Object

注意：

类中的构造方法默认第一行都有隐式的super()语句，在访问父类中的空参数构造方法。所以父类的构造方法既可以给自己的对象初始化，也可以给自己的子类对象初始化。

如果默认的隐式super()语句在父类中没有对应的构造方法，那么必须在构造方法中通过this或者super的形式明确要调用的构造方法。

package day12.demo2;
/*
 *   手动写一个父类Person类的构造方法,加入int类型参数
 *   保存,子类就报错
 */
public class Person {
	public Person(int a) {
		
	}
	public Person(double d) {
		
	}
}

package day12.demo2;
/*
*  子类构造方法的报错原因: 找不到父类的空参数构造器
*  子类中,没有手写构造,编译器添加默认的空参数
*  public Student(){
*     super();
*  }
*  编译成功,必须手动编写构造方法,请你在super中加入参数
*  
*  注意: 子类中所有的构造方法,无论重载多少个,第一行必须是super()
*  如果父类有多个构造方法,子类任意调用一个就可以
*  super()语句必须是构造方法第一行代码
*/
public class Student extends Person{
	public Student() {
		super(0.1);
	}
	public Student(String s) {
		super(1);
	}
}

package day12.demo2;

public class Test {
	public static void main(String[] args) {
		new Student();
	}
}

构造方法第一行,写this()还是super()？
两者不能同时存在,任选其一,要保证子类的所有构造方法调用到父类的构造方法即可。
小结论: 无论如何,子类的所有构造方法,都要直接或者间接调用到父类构造方法。
子类的构造方法,什么都不写时，默认的构造方法第一行为super();

public class Person {
	public Person(int a) {
		
	}
	
}

/*
	构造方法第一行,写this()还是super()
	不能同时存在,任选其一,保证子类的所有构造方法调用到父类的构造方法即可
	
	小结论: 无论如何,子类的所有构造方法,直接,间接必须调用到父类构造方法
	子类的构造方法,什么都不写,默认的构造方法第一行 super();
*/
public class Student extends Person{
	public Student() {
		this("lalala");
	}
	public Student(String s) {
		super(1);
	}
}


public class Test {
	public static void main(String[] args) {
		new Student();
	}
}

3.3 super应用

练习：描述学生和工人这两个类，将他们的共性name和age抽取出来存放在父类中，并提供相应的get和set方法，同时需要在创建学生和工人对象就必须明确姓名和年龄。

package day12.demo4;
/*
 *  Student类和Worker有相同成员变量,name age
 *  继承的思想,共性抽取,形成父类
 *  Person,抽取出来父类
 *  成员变量,私有修饰
 *  同时需要在创建学生和工人对象就必须明确姓名和年龄
 *  new Student, new Worker 姓名,年龄明确了
 */
public class Person {
	private String name;
	private int age;
	public Person(String name, int age) {
		this.name= name;
		this.age = age;
		
	}
	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;
	}
	
}

package day12.demo4;

public class Student extends Person{
	public Student(String name, int age) {
		super(name,age);
		
	}
}

package day12.demo4;

public class Worker extends Person{
public Worker(String name, int age) {
	super(name,age);
	
}
}

package day12.demo4;

public class Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Worker w = new Worker("光头强",20);
		System.out.println(w.getName());
		System.out.println(w.getAge());
		
		Student s = new Student("肥波",10);
		System.out.println(s.getName());
		System.out.println(s.getAge());
	}

}

第四章综合案例---完整的员工类

4.1 案例介绍

某IT公司有多名员工，按照员工负责的工作不同，进行了部门的划分（研发部员工、维护部员工）。研发部根据所需研发的内容不同，又分为JavaEE工程师、Android工程师；维护部根据所需维护的内容不同，又分为网络维护工程师、硬件维护工程师。

公司的每名员工都有他们自己的员工编号、姓名，并要做它们所负责的工作。

工作内容

JavaEE工程师：员工号为xxx的 xxx员工，正在研发淘宝网站
Android工程师：员工号为xxx的 xxx员工，正在研发淘宝手机客户端软件
网络维护工程师：员工号为xxx的 xxx员工，正在检查网络是否畅通
硬件维护工程师：员工号为xxx的 xxx员工，正在修复打印机

请根据描述，完成员工体系中所有类的定义，并指定类之间的继承关系。进行XX工程师类的对象创建，完成工作方法的调用。

4.2 代码实现

package day12.demo5;
/*
 *  员工类:
 *    共性的抽取
 *    姓名,编号,工作方法(抽象)
 */
public abstract class Employee {
	private String name;
	private String id;
	public Employee(String name, String id) {
		this.name = name;
		this.id = id;
	}
	public abstract void work();
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	

}

public abstract class Developer extends Employee{
	public Developer(String name, String id) {
		super(name,id);

}
}

public class JavaEE extends Developer{
	public JavaEE(String name, String id) {
		super(name,id);
	}
	public void work() {
		System.out.println(super.getName()+"..."+super.getId()+"在开发淘宝");
		
		
	}
}

package day12.demo5;

public abstract class Maintainer extends Employee{
	public Maintainer(String name, String id) {
		super(name,id);
	}
	

}

package day12.demo5;

public class Net extends Maintainer{
	public Net(String name, String id) {
		super(name,id);
	}
	public void work() {
		System.out.println(super.getName()+"..."+super.getId()+"正在检测网络是否畅通");
		
		
	}
}

package day12.demo5;

public class Test {
	public static void main(String[] args) {
		
	JavaEE ee = new JavaEE("张三","开发部001");
	ee.work();
	
	Net net = new Net("李四","维护部001");
	net.work();
	
	}
}

kww_

关注

2
点赞
踩
23

收藏

觉得还不错? 一键收藏
0
评论
Java面向对象（十二）——构造方法（方法调用、内存图解）、this关键字（调用构造方法、原理图）、super关键字

第一章构造方法1.1构造方法介绍那什么是构造方法呢？从字面上理解即为构建创造时用的方法，即就是对象创建时要执行的方法。既然是对象创建时要执行的方法，那么只要在new对象时，知道其执行的构造方法是什么，就可以在执行这个方法的时候给对象进行属性赋值。构造方法的格式：修饰符构造方法名(参数列表){}构造方法的体现：构造方法没有返回值类型。也不需要写返回值。因为它是为构建对象的，对象创建完，方法就执行结束。构造方法名称必须和类名保持一致。构造方法没有具体的.
复制链接

扫一扫