Java 构造方法

发表于 | 更新于 | 评论数： | 阅读次数：

写在开头

 构造方法，是一种特殊的方法。
 主要用来在创建对象时初始化对象，即为对象成员变量赋初始值，总与new运算符一起使用在创建对象的语句中。
 特别的一个类可以有多个构造函数，可根据其参数个数的不同或参数类型的不同来区分它们即构造函数的重载。
 今天我们说一下Java:构造函数.

构造方法

  • 定义:构造方法是一种特殊的方法，它是一个与类同名且返回值类型为同名类类型的方法。对象的创建就是通过构造方法来完成，其功能主要是完成对象的初始化。当类实例化一个对象时会自动调用构造方法。构造方法和其他方法一样也可以重载。又可以叫构造器 构造函数 constructor

  • 作用:给成员变量进行赋值

  • 定义方法:修饰符 构造方法名(参数列表){主要: 成员变量进行赋值}

说明

  1. 构造方法名: 必须与类名保持一致,严格区分大小写,符号都必须完全一样
  2. 构造方法没有返回值类型,连void都不写
  3. 参数列表,可以有参数,可以没有参数
  4. 构造方法中的内容 : 主要是给成员变量进行赋值

使用方法

当new一个类对象的时候,这个时候,调用构造方法
每次new对象,只调用一次构造方法
JVM虚拟机去调用的构造方法
构造方法,不能主动调用

代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public  class  Person
{
   // 定义一个构造方法,空参数构造方法
   public Person(){
       System.out.println("我是空参数的构造方法");
   }

	public static void main(String[] args) 
	{
		// Person() : 调用了Person类中构造方法,空参数构造方法
		Person p = new Person();// 我是空参数的构造方法
		Person p1 = new Person();// 我是空参数的构造方法
		// p.Person(); 错误代码,构造方法不能主动调用,只能是new对象时,JVM调用,并且只调用一次
	}
}

使用时的注意事项

  1. 默认存在空参数构造,内容为空
  2. 手动添加构造函数,系统不在默认添加空参数构造函数
  3. 进行一次实例化对象,调用一次构造函数,传入参数不同,调用的构造函数不同
  4. 构造函數也有重載

代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class  Student
{
	private String name;
	private int age;
    // 给成员变量进行赋值,有参数的构造方法
	public Student(String name,int age){
//this关键字在下面会说到,这里暂且认为这样使用
	   this.name = name;//为解决变量的命名冲突和不确定性问题，引入关键字this
	   this.age = age;//关键字this代表其所在方法的当前对象的引用
	}
	public static void main(String[] args) 
	{
        //Student s = new Student(); 错误代码,没有定义空参数的构造方法
		Student s = new Student("张三",20);
		System.out.println(s.name + "++++++"+s.age);// 张三 20
	}
}

构造函数和set方法赋值的区别

  1. 构造函数只在new时候调用一次构造函数 ,再次new时候是调用的新对象的构造函数,也就是说不能通过构造函数的方法,对一个对象的成员变量进行两次赋值

  2. set方法,使用灵活,可以给同一个对象里的成员变量进行多次赋值

实际开发过程中,多以set方法进行赋值

代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
// 定义有参数的构造方法
public class  Student
{
	private String name;
	private int age;
    // 给成员变量进行赋值,有参数的构造方法
	public Student(String name,int age){

	   this.name = name;
	   this.age = age;
	}

   //  构造方法的重载
	public Student(){
	   System.out.println(name +"**********"+ age);//null**********0
	}
   //set get方法进行取值赋值
	public void setName(String name){
	  this.name = name ;
	}

	public String getName(){
	   return name;
	}

    public void setAge(int age){
	  this.age = age ;
	}

	public int getAge(){
	   return age;
	}

	public static void main(String[] args) 
	{
        Student s = new Student(); //错误代码,没有定义空参数的构造方法
		Student s1 = new Student("张三",20);
		System.out.println(s1.name + "++++++"+s1.age);// 张三 20,通过构造方法的赋值得到的结果
	}
}

构造方法在内存中的执行过程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
/*Person1 p = new Person1("qq",99);
内存运行过程:
1. Person1.class 字节码文件,进入到方法区中
2. JVM调用main方法,作为程序的执行入口
3. main中的语句Person1 p = new Person1("qq",99);
1) main进入到栈内存中,执行
2) 在栈内存中,有一个引用,p
3) new 关键字,在堆内存中开辟一块空间
4) JVM将Person1中的成员变量,加载进内存中,赋初值
5) 因为成员定义时,有变量值,将初值去掉,换成了给成员变量赋的值  美丽---20
6) 调用构造方法,JVM看你使用的是什么参数的构造方法,执行构造方法中的内容
   ,本次构造方法中,给成员进行赋值, 替换掉 美丽---20 变成 qq--- 99
7) 将Person1在内存中的地址值,转换成16进制数,返回给栈内存中的引用变量p*/


// 构造方法的执行过程
public class  Person1
{
	private String name = "美丽";// 显示赋值
	private int age = 20 ;

	// 给成员变量进行赋值,有参数的构造方法
	public Person1(String name,int age){

	   this.name = name;
	   this.age = age;
	}

	// 给成员变量进行赋值,有参数的构造方法
	// 证明 .成员变量,先进行了美丽和20的赋值,后执行了空参数的构造
	public Person1(){
       System.out.println("空参数构造"+name + "-----" +age);//空参数构造美丽-----20
       
	}

	public static void main(String[] args) 
	{
		Person1 p1 = new Person1(); // 调用空参数

		Person1 p = new Person1("qq",99);// 调用有参数
		System.out.println("有参数的构造"+p.name + "-----" + p.age);//有参数的构造qq-----99

	}
}

this关键字的使用

  • this关键字代表其所在方法的当前对象的引用

  • 为解决变量的命名冲突和不确定性问题，引入关键字this,用来区分局部变量和成员变量的重名问题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
// 构造方法的执行过程
public class  Person1
{
	private String name = "美丽";
	private int age = 20 ;

	// 给成员变量进行赋值,有参数的构造方法
	public Person1(String name,int age){
		// 调用Person1类中的一个参数构造方法
	   this("aa");// 本类对象的引用  : new Person1() //一个参数的构造  aa
       System.out.println(this.name);// aa
	   this.name = name;// qq
	   this.age = age;// 99
	}
	
	// 证明 .成员变量,先进行了美丽和20的赋值,后执行了空参数的构造
	public Person1(){
       System.out.println("空参数构造"+name + "-----" +age);//空参数构造美丽-----20
       
	}
// 给成员变量进行赋值,有参数的构造方法
	public Person1(String name){
	   this();// 调用空参数构造方法
	   this.name = name;   
	}
	public static void main(String[] args) 
	{
		//Person1 p1 = new Person1(); // 调用空参数

		Person1 p = new Person1("qq",99);// 调用有参数
		System.out.println("有参数的构造"+p.name + "-----" + p.age);//有参数的构造qq-----99

	}
}

晚安

 今天就到这里了，明天见，加油！

-------------本文结束感谢您的阅读-------------
0%