Java基础7--构造函数--this--static内存详解

7-1，构造函数-概述

1，特点：

(1)函数名与类名相同。

(2)不用定义返回值类型。

(3)没有具体的返回值。

2，构造函数

构造函数就是构建创造对象是调用的函数。

3，作用

可以给对象进行初始化，即对象一创建里面就包含一些内容。

4，示例：

class Person{
	private String name;
	private int age;
	Person(){	//定义一个空参构造函数
		Sop("Person run ...");
	}
	public void speak(){
		Sop(name+"::"+age)
	}
}
class Demo {
	public static void main(String[] args) {
		Person p = new Person();
	}
}

7-2，默认构造函数

1，创建对象都必须通过构造函数初始化。

2，一个类中如果没有定义过构造函数，那么该类中一定会有一个默认的空参构造函数，如果在类中定义指定的构造函数，那么类中的默认的构造函数就没有了。

3，构造函数是用来给对象初始化的，没有初始化的对象绝对不能用。

 

7-3，一般函数和构造函数的区别

区别：

(1)构造函数：对象创建时，就会调用与之对应的构造函数，对对象进行初始化。

一般函数：对象创建后，需要函数功能时才使用。

(2)构造函数：对象创建时会调用，只调用一次。

一般函数：对象创建后，可以被调用多次。

 

7-4，构造函数-重载

1，什么时候定义构造函数？

在描述事物时，该事物已存在就具备一些内容，这些内容都定义在构造函数中。

2，重载：函数名相同，参数列表不同。

示例：

class Person {
	private String name;
	private int age;
	Person() {		//函数1
		name = "baby";
		age = 1;
	}
	Person(String n) {	//函数2
		name = n;
	}
	Person(String n,int a) {//函数3
		name = n;
		age = a;
	}
	public static void main(String[] args) {
		Person p1 = new Person();		//调用函数1
		Person p2 = new Person("zhangsan");	//调用函数2
		Person p3 = new Person("lisi",20);	//调用函数3
	}
}

3，注意，形如：

Person(int a,String n);

Person(String n,int a);

的两个函数是重载形式。

 

7-5，构造函数-内存图解

Person p = newPerson("lisi",20);

p.speak();

以上两句在内存中表示为：

步骤：

(1)从main函数开始，main函数进栈，局部变量p进栈。

(2)在堆中建立p的实体，分配地址，给变量默认初始化。

(3) new Person("lisi",20);调用了Person的构造函数，把实参传入，Person(String,int)函数进栈。

(4)把传入的参数赋值。

(5) Person p = newPerson("lisi",20);执行完毕，把地址值赋给栈中的p，p指向堆中的实体。

(6)Person(String,int)执行完毕，弹栈。

(7)p.speak();调用speak方法，speak()进栈。

(8)执行speak中的输出语句。

(9)speak()执行完毕，弹栈。

 

7-6，构造函数-细节

1，构造函数：Person(String n){name=n;}

与一般函数public void setName(String n){name= n;}

不冲突，构造函数在创建对象的一开始的时候就赋值，只调用一次，值不能再改，一般函数可以调用多次，可以在后期对值进行改变。

2，构造函数中可以调用一般函数，一般函数中一般不调用构造函数，构造函数是用来初始化对象的，若非要在一般函数中调用构造函数，需要新创建一个对象。

3，Person(){}与voidPerson(){}不一样，前者为构造函数，后者为一般函数，构造函数加上修饰符就变成了一般函数，一般函数可以与类名相同。

4，若Person类中已经定义了构造函数，这时默认构造函数已经被覆盖，若只有一个void Person(){}，而main中有Person p = new Person();则编译失败，因为voidPerson(){}是一个一般函数主函数无法找到Person(){}给对象初始化，所以报错误。

5，构造函数中是有return语句的，return语句是用来结束函数用的，若return后面还有语句，则编译报错，因为return后面的语句不会被执行到。

 

7-7，关键字-this使用场景-内存图解

1，this表示这个对象的***，比如this.name表示这个对象的name属性。

2，场景：当成员变量和局部变量重名，可以用关键字this来区分。

3，this：代表对象，代表当前对象。

This就是所在函数所属对象的引用。

简单说：哪个对象调用了this所在的函数，this就代表哪个对象。

例如：

class Person {
	private String name;
	Person(String name) {
		this.name = name;
	}
	public static void main(String[] args) {
		Person p = new Person("zhangsan");
	}
}

上例中的this指代的就是p对象，this.name指向的是堆内存中这个对象的name属性。

 

4，内存图解：

class Person{
	private String name;
	private int age;
	Person(String name) {
		this.name = name;
	}
	public void speak() {
		sop(name + ":" + age);
	}
}
class ThisDemo {
	public static void main(String[] args) {
		Person p = new Person("zhangsan");
		p.speak();
	}
}

步骤：

(1)从main函数开始，main函数进栈，局部变量p进栈。

(2) new Person("zhangsan");在堆内存中开辟空间，分配地址，name和age变量进入堆中的对象，默认初始化为null和0。

(3)Person(name)构造函数进栈。

(4)把"zhangsan"传入，赋给局部变量name。

(5)函数进入栈会自动带有一个this引用，因为是p调用Person()，所以this的值为新创建对象的地址0X0078。

(6)Person中的this指向堆中的0X0078。

(7)this.name指向的是0X0078中的name，给此name赋值为"zhangsan"。

(8)Person(name)执行完毕，弹栈。

(9)p = newPerson("zhangsan");把0X0078赋给main中的p。

(10)speak()函数进栈，并自带一个this引用。

(11)p.speak();p调用speak，把p的地址给this。

(12)执行完输出弹栈。

说明：其实每个函数中都自带一个this，只不过不重名时不用区分，重名时用this区分开来，this都指代当前对象的地址。

如：sop(name + age);的标准写法是:sop(this.name + this.age);

 

7-8，this关键字使用场景及细节

1，在构造函数中调用构造函数

Person(String name) {
	this.name = name;
}
Person(String name,int age) {
	this(name);	//this代表对象，给对象初始化，调用的是同类中上面的那个构造函数
	this.age = age;
}

this也可以用于在构造函数中调用其他构造函数。

注意：只能定义在构造函数的第一行，因为初始化动作要先执行。这说Java的语法，不这样写会报错。

2，示例代码内存图解：

class Person{
	private String name;
	private int age;
	Person() {
		name = "baby";
		age = 1;
		sop("Person run...");
	}
	Person(String name) {
		this.name = name;
	}
	Person(String name,int age) {
		this(name);
		this.age = age;
	}
	public void speak() {
		sop(this.name + "-" + this.age);
	}
}
class ThisDemo {
	public static void main(String[] args) {
		Person p = new Person("zhangsan",30);
		p.speak();
	}
}

步骤：

(1)从main函数开始，main函数进栈，局部变量p进栈。

(2) newPerson("zhangsan",30);在堆中开辟内存空间，分配地址，name和age默认初始化为null和0。

(3)传参数，Person(name,age)进栈，自带this引用，指向堆内存0X0067，局部变量name,age传参数赋值。

(4)this(name)调用Person(name)，自带this引用，指向堆内存0X0067，局部变量name赋值。

(5)this.name = name;指Person(name)中的name赋给堆中实体的成员变量name。

(6)Person(name)运行完弹栈。

(7)执行Person(name,age)中的this.age=age;给堆中的成员变量赋值。

(8)Person(name,age)运行完弹栈。

(9)把0X0067赋给main中的p。

 

3，避免程序出现以下情况：

class Person{
	private String name;
	private int age;
	Person() {
		this("haha");//2.调用Person(name)   4.调用Person(name)....
		name = "baby";
		age = 1;
		sop("Person run...");
	}
	Person(String name) {
		this();//3.调用Person()    5.调用Person()....
		this.name = name;
	}
	public static void main(String[] args) {
		new Person();  //1.给Person初始化，调用Person()
	}
}

上述代码是Person()和Person(name)之间的来回调用，导致栈内存溢出。

 

7-9，this应用

程序：判断是否是同龄人

public Person {
	private String name;
	private int age;
	Person(){}
	Person(String name,int age) {
		this.name = name;
		this.age = age;
	}
	public static void main(String[] args) {
		Person p1 = new Person("aa",20);
		Person p2 = new Person("bb",30);
		boolean b = p1.compare(p2);
		System.out.println(b);
	}
	public static boolean compare(Person p) {
		/*方法一
		if(this.age == p.age) {
			return true;
		} else {
			return false;
		}
		*/
		//方法二
		return this.age == p.age;
	}
}

7-10，static关键字-数据共享

用static修饰的数据是可以被共享的数据。

如：String name;

    staticString country = “cn”;

由于每个人的name是不一样的，但是country一样，都是cn，如果不将cn定义为static的，当每创建一个对象，每个对象中都会有cn，浪费内存空间。

可以把country定义为static的，这样所有的对象都可以共享这个数据，哪个对象需要，调用即可。

 

7-11，static的特点

1，用static修饰的成员先于对象存在，存在于类中，可以用类名直接调用。例如Person.country;

2，不能所有都定义成static的，有些可以被共享，但是有一些是每个对象特有的，不能被共享。

3，特点：

(1)static是一个修饰符，用于修饰成员。

(2)static修饰的成员被所有的对象所共享。

(3)static优先于对象存在，因为static修饰的成员随着类的加载就已经存在了。

(4)static修饰的成员多了一种调用方式，可以直接被类名调用，格式：类名.静态成员。

(5)static修饰的数据是共享数据，对象中存储的是特有数据。

 

7-12，成员变量和静态变量的区别

class person{
	String name; //成员变量，实例变量
	static String country = "cn"; //静态变量，类变量
	......
}

区别：

(1)两个变量的生命周期不同。

成员变量：随着对象的创建而存在，随着对象的被回收而释放。

静态变量：随着类的加载而存在，随着类的消失而消失。

(2)调用方式不同。

成员变量：只能被对象调用。

静态变量：可以被对象调用，也可以被类名调用。

(3)别名不同。

成员变量：也成为实例变量。

静态变量：也成为类变量。

(4)数据存储位置不同。

成员变量：数据存储在堆内存的对象中，所以也叫对象的特有数据。

静态变量：数据存放在方法区(共享数据区)的静态区，所以也叫对象的共享数据。

 

7-13，static的注意事项

1，注意事项：

(1)静态方法只能访问静态成员。(非静态既可以访问静态，又可以访问非静态)。

(2)静态方法中不可以使用this或者super关键字。(因为静态先加载，没有对象，不可以用this)

(3)主函数是静态的。

2，main()是静态的，不可以直接调用非静态的方法，可以通过创建对象调用。

非静态变量在使用的时候前面省略了this，静态变量在使用时前面省略的是类名。

class Person{
	public static void main(String[] args) {
		run();//run必须是静态的，否则报错
	}
	public static void run() {
		System.out.println("run...");
	}
}

7-14，main函数详解

1，public static void main(String[] args)

主函数的特殊之处：

(1)格式是固定的。

(2)被JVM识别和调用。

public : 因为权限必须最大。

static : 程序从main函数开始执行，不需要对象调用main函数，其实是直接被主函数的类名调用的，所以必须是静态

例如要运行Person类，一般我们在命令行输入java Person执行，其实JVM调用的是java Person.main。

void : 主函数没有具体的返回值。

main : 函数名，不是关键字，只是一个JVM识别的固定的名称。

String[] args : 这是主函数的参数列表，是一个字符串数组类型的参数。

 

2，调用main函数的时候也要向String[]args传递实参，是由JVM传递的。

可以使用System.out.println(args);验证，结果为：

[Ljava.lang.String@c17164

可以说明是一个String的数组。

默认这个数组的长度是0。

JVM向String[] args传递的是newString[0]。

 

3，我们在运行程序的时候，可以给main函数传递参数，程序中的任何结果最终都要转成字符串显示在屏幕上。

 

4，运行程序时传值，命令行中，在使用java命令时传递。

java Person haha hehe xixi 用空格分隔，作为数组中的元素传递给args。

 

5，String[] 中的args可以变化，不是固定的，args是arguments的简写。

 

6，public static void main(String[] args)

 

    publicstatic void main(int[] x)

二者不冲突，是重载的形式。

如果将后面的int[] x变为String[]x，则冲突。

 

7-15，static关键字-程序内存详解

以下面程序为例：

class Person{
	private String name;
	private int age;
	static String country = "cn";
	public Person(String name,int age) {
		this.name = name;
		this.age = age;
	}
	public void show() {
		System.out.println(Person.country + ":" + this.name + ":" + this.age);
	}
	public static void method() {
		System.out.println(Person.country);
	}
}
class StaticDemo{
	public static void main(String[] args) {
		Person.method();
		Person p = new Person("Java",20);
		p.show();
	}
}

当在命令行用java StaticDemo运行这个程序时，这个类就会被加载进内存，需要进行空间的开辟，进入方法区，方法区分为静态区和非静态区两个区域。

步骤：

(1)当执行StaticDemo时，StaticDemo类就加载进内存，并开辟空间，默认构造函数StaticDemo()也加载进内存，加载进内存的方法区的非静态区。

(2)接着main函数也进入内存，进入内存方法区的静态区(静态区的方法和非静态区的方法都是被共享的，唯一的不同是封装的数据不同)，非静态区的所有成员都有一个this所属，因为非静态区的方法都被对象调用，而静态区的方法都是所属自己的类名。

(3)当java StaticDemo，回车时，函数加载完毕，StaticDemo直接用类名调用主函数，这时main函数进栈，main函数中的所有代码都在静态区的static main()中。

(4)运行Person.method();时用到了Person类，这时Person加载，这时JVM会在classpath下找是否有Person.class文件，若没有则在当前默认目录下找，找到后就会将Person.class加载进内存，Person类中的构造函数Person(name,age)以及其中的代码和void show()方法以及其中的代码都加载进非静态区；Person中的静态方法method()和静态变量country加载进静态区，country默认初始化为null，因为给他赋值为”cn”，所以马上显示初始化为cn，现在country=cn。

(5)Person.method();是用类名调用，说明method()是static的，调用时直接在静态区的Person类中找method方法，找到后，method方法进栈，注意此方法是没有this所属的，只有非静态区持有this。

说明：method方法在方法区，为何进栈执行？

因为方法区是方法的存放区，也叫方法表，所有的方法都在这里。而栈是运行区，因为方法内可能会有局部变量，局部变量是需要在栈内存中开辟空间存储的，而且运行完局部变量要释放，所以要到栈中运行。但System.out.println()方法不会进栈执行，这个方法是用于输出的，没有局部变量。栈中只存放方法的局部变量，进栈后method方法开始执行，由于只有一个System.out.println()方法，所以直接到静态区的method中找到System.out.println()执行，有局部变量时才在栈中开辟空间。

method方法的sop中有Person.country，这时直接从静态区的Person类中找到country，并且输出对应的值。

(6)method方法运行完毕，弹栈。

(7)执行Person p = new Person("Java",20);局部变量p进栈。

(8)在堆中为p对象开辟空间，分配地址，成员变量name,age进入内存，并默认初始化为null和0，然后执行构造函数初始化，此时构造函数Person(name,age)进栈，给对象中的数据初始化，函数中持有一个this引用，并且值为0X0078，因为0X0078的对象在调用它，局部变量name被赋值为Java，age被赋值为20，因为Person(name,age)进栈并且初始化完毕，就开始执行方法区中的代码(Person(name,age)方法的代码)，因此this代表0X0078，所以通过这个地址找到堆中的name并赋值为Java，将20赋值给age。

(9)Person(name,age)运行完毕，弹栈。

(10)new Person("Java",20);初始化完毕，把地址0X0078赋给p，p指向堆内存。

(11)p.show();show方法进栈，因为show是非静态的，自带一个this引用，this指向0X0078。show中有一个sop，sop中的country在编译完后已经有类名所属，直接在静态区中的Person类中调用，name和age前边都省略了this，this是show中的this，代表0X0078，所以打印0X0078中的name和age，即Java和20，然后输出。

(12)输出完毕，show方法执行完毕，弹栈。

(13)执行到main函数中的return语句，main函数结束，main函数弹栈，程序执行结束，JVM结束。

7-16，static关键字什么时候用？

静态什么时候用？

1，静态变量

当分析对象中所具备的成员变量的值都是相同的，这时这个成员就可以被静态修饰。只要数据在对象中都是不同的，就是对象的特有数据，必须存储在对象中，是非静态的。如果是相同的数据，对象不需要做修改，只需要使用即可，不需要存储在对象中，定义成静态的。

2，静态函数

函数是否用静态修饰，就参考一点，就是该函数的功能是否有访问到对象中的特有数据。简单点说，从源代码看，该功能是否需要访问到非静态的成员变量，如果需要，该功能就是非静态的，如果不需要，就可以将该功能定义成静态的。当然，也可以定义成非静态的，但是非静态需要被对象调用，而创建对象调用非静态的没有访问特有数据的方法，该对象的创建是没有意义的。

 

7-17，static静态代码块

静态代码块是随着类的加载而执行的，而且从这个类加载到消亡，只执行一次。

作用：可以给类进行初始化。

格式：

class Person {
	static {
		...
	}
}

应用：不是所有的类都是通过构造函数初始化的，如果一个类中的方法全是静态的，那就不需要创建对象，不创建对象就没有new的过程，不new就无法对构造函数初始化，而这时就可以用静态代码块对类进行初始化。

 

7-18，构造代码块

1，构造代码块定义在类中，它可以给所有对象进行初始化，也就是说，每次new一个对象的时候，它都会执行。

2，构造代码块与局部代码块的区别

构造代码块定义在类中，局部代码块定义在方法体中。

3，格式：

class Person {
	{
		//构造代码块...
		//抽取出所有对象共性的初始化内容，定义在这里。
		//每次创建一个Person对象，这个代码块都会执行。
	}
	...
}

4，程序执行顺序

静态代码块-->构造代码块-->构造函数

 

7-19，总结

1，被static修饰的成员具备以下特点：

(1)随着类的加载而加载。

(2)优先于对象而存在。

(3)被所有对象共享。

(4)可以直接被类名调用。

 

2，static使用时注意：

(1)静态方法只能访问静态成员。

(2)静态方法中不可以写this,super关键字。

(3)主函数是静态的。