JAVA基础之构造函数

class Person //构造函数。
{
public static void main(String[] args)
{
/*构造函数：
特点：函数名与类名相同
不用定义返回值类型。
没有具体的返回值
作用：给对象进行初始化
*/
people p =new people();//构造函数：构建创造对象时调用的函数。作用就是给对象初始化。
//在创建对象的时候，构建函数就会运行。也就是会执行函数里的执行语句。
p.speak();//这个P叫类类型变量，和类变量是两回事。
people p1=new people("Jack",18);
p1.speak();
System.out.println(people.age);//定义了静态成员变量，不用创建对象都可以调用。
}
}

我们定义一个构造函数，还是以人举例。

class	People
{
static  int age=18;//被static修饰过的变量不能叫成员变量。叫静态变量，也叫类变量。
private String name;//成员变量，也叫实例变量。
People()//这就是一个构造函数，而且是空参数。
{
System.out.println("people run");
}
//people {}  这就是默认的构造函数，如果类中没有定义的话，它会默认初始化。
People(String n,int a)//这也是构造函数。
{
name=n;
age=a;
}
public void speak()
{
System.out.println(name+":"+age);
}
/*创建对象都必须要通过构造函数初始化。

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

构造函数和一般函数的区别：
构造函数：对象创建时，就会调用与之对应的构造函数，对对象进行初始化。
对象创建时，只会被调用一次。
一般函数：对象创建后，需要函数功能时才调用。
对象创建后，可以被多次调用。

什么时候定义构造函数呢?
在描述事物时，该事物已存在具备的一些内容，这些内容都定义在构造函数中。*/
}

构造函数中的一个关键字：this。

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

比如上面的对象people。

class	people
{
private	int age;
private String name;
people(String n,int a)
{
name=n;
age=a;
}
public void speak()
{
System.out.println(name+":"+age);
}
}

这是对象在类中的描述，我们注意构造函数部分，也就是

people(String n,int a)
{
name=n;
age=a;
}

构造函数中，我们将n赋值给name，a赋值给age。但是定义成n和a的阅读性不强，在代码很多的时候会给我们造成障碍。

为了增强阅读性，我们将n和a改会原来的变量名，但是这样就会造成局部变量和成员变量重名

也就是这种情况。

people(String name,int age)
{
name=name;
age=age;
}

这样就会导致：函数定义的局部变量在栈内存中，而赋值的时候底层还是会使用栈内存中的局部变量，而不是堆内存

中的成员变量，输出的结果就会是错误的，或者不是我们所需要的。

这时候我们就需要用到this关键字。将构造函数改为：

people(String name,int age)
{
this.name=name;
this.age=age;
}

这里的this代表当前对象，this.name就是代表当前对象的name，这样就能够区分局部变量和成员变量。

所以this的作用就是：

所在函数所属对象的调用。通俗的意思就是哪个对象调用了this所在的函数

this就代表哪个对象。

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

注意：只能定义在构造函数的第一行，因为初始化动作要先执行。

比如

class	people
{
private	int age;
private String name;
people()
{
System.out.println("people run");
}
people(String n,int a)
{
name=n;
age=a;
}
public void speak()
{
System.out.println(name+":"+age);
}

我们想在people(String n,int a)构造函数中调用people()构造函数。

可直接写为：

people()
{
System.out.println("people run");
}
people(String n,int a)
{
this();//这就是调用上面的构造函数，如果构造函数是空参数则只带上空括号即可，
//如果有参数，则跟上参数。
//我们调用上面的构造函数不能写成people()因为这时对象还没被初始化是不能调用方法的。
//写为this，含义就是给当前对象中空参数的构造函数进行初始化。
name=n;
age=a;
}

static关键字：意为静态。特点是：

1.是一个修饰符，用于修饰成员。

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

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

4.static修饰的成员多了一种调用方式，就可以直接被类名调用。

格式为：类名.静态成员。

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

比如：

还是上面的对象描述类举例。

class	people
{
int age;
private String name;
}

上面两个成员变量，name和age。我们假使要多次创建对象时，年龄也就是age都是18，只有name的不同。

一个个的去赋值既占用空间代码复用性也不强，这时我们就需要static关键字来修饰age成员变量。

修饰完毕后这个变量的数据就是共享数据，可以被所有对象调用。

所以我们就可以写成这样

class	people
{
static	int age=18;
private String name;
}

成员变量和静态变量的区别：

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

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

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

2.调用方式不同。

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

静态变量不仅可以被对象调用，还可以被类名调用。（即不创建对象也可调用静态变量）

3.别名不同。

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

静态变量也称为类变量。

4.数据存储位置不同。

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

静态变量的数据存储在方法区（共享数据区）的静态区中，所以也叫对象的共享数据。

静态的用途：（即static关键词在什么时候修饰成员变量和成员函数）

1.静态变量

当分析对象中所具备的成员变量的值是相同的，这个成员就可以被静态修饰。

只要数据在对象中是不同的，就是对象的特有数据，必须存储在对象中，是非静态的。

如果是相同的数据，对象不需要做修改，只需要使用即可，不需要存储在对象中，就定义成静态的。

2.静态函数。

函数是否用静态修饰，就参考一点，就是该函数功能是否有访问到对象中的特有数据。

简单点说，从源代码看，该功能是否需要访问非静态的成员变量，如果需要，该功能就是非静态的。

如果不需要，就可以定义成静态的。（定义成非静态也可以。）

（但是此时定义非静态是没有意义的，因为函数都没有访问到对象的特有数据，就不需要创建对象

，函数却要定义成非静态的就没有必要，非静态还要创建对象，是浪费内存空间的行为。

为了严谨，我们还是得定义成静态的。）

静态代码块：

static

{

}

这个静态代码块没有名字（static不是名字，是修饰符，修饰这个代码块。）

它是随着类的加载而执行，而且只执行一次。（创建多个对象时，类其实只加载了一次。）

它的作用：

用于给类进行初始化（和构造函数类似，构造函数是给对象进行初始化的。）

静态使用的注意事项：

1.静态方法只能访问静态成员。（非静态既可以访问静态，又可以访问非静态。）

2.静态方法中不可以使用this或super关键字。

3.主函数是静态的。

主函数的意思：

public static void main(String[] args)

主函数的特殊之处：

1.格式是固定的。

2.被jvm所识别和调用。

public：权限必须是最大的。

static：不需要对象，直接用主函数所属类名调用即可。

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

main：函数名。不是关键字，只是jvm识别的固定名字。

String[] args：这是主函数的参数列表，是一个数组类型的参数，而且元素都是字符串类型。

其中只有args是可以随意更改的，因为他只是一个数组名而已。但是现在已经被潜移默化成了规范。

函数在主函数中用函数名调用。同样的原理，

主函数在虚拟机中，用主函数名调用，只是这一步执行我们是在控制台（DOS命令行）进行的。

说白了主函数实际上就是一个没有具体返回值的类型的方法，我们同样可以在控制台上给主函数的数组

赋予数据。

{

执行语句；

}

以上叫构造代码块，既没有名字，也没有修饰符。

它是随着对象的创建而执行的，创建几次对象就执行几次。

构造代码块，静态代码块，构造函数，在同一个类中，他们的运行顺序是

先执行静态代码块。

如果创建了对象就依次执行构造代码块，最后才是构造函数。

如果没有创建对象，则后两个不执行。