构造函数，静态关键字，静态代码块，构造代码块，局部代码块

构造函数

一般函数：用于描述事物应该具备的功能
构造函数：也是描述功能，不过比较特殊，是专门用于给对象进行初始化的

示例：在我们创建类Person时，设置姓名需要用到set,get方法，但就像人一样，在我们上户口之前，我们是没有自己的姓名的，但没有自己的姓名不代表没有自己的昵称，我们每个人在出生时，都会喜提昵称“小宝贝”一枚~。那么在Java中如何实现呢------使用构造函数

class Person{
	private String name;
	//set,get方法
	public void setName(String n){
		name = n;	
	}
	public String getName(){
		return name;
	}
	public void show(){
		System.out.print("name="+name);
	}	
}	
public class PersonDemo{
	public static void main(String args[]){
		Person p = new Person();
		p.setName("vincy");
		p.show();
	}
}

定义一个构造函数，给Person对象初始化

class Person{
	private String name;
	//定义一个构造函数，给Person对象初始化
	Person(String name){
		this.name = name;
	}

	/*public void setName(String n){
		name = n;	
	}
	public String getName(){
		return name;
	}
	*/
	public void show(){
		System.out.print("name="+this.name);
	}
		
}	
public class PersonDemo{
	public static void main(String args[]){
		//Person对象一开始就有姓名
		Person p = new Person("litter baby");
		//p.setName("vincy");
		p.show();
	}
}

构造函数的格式：
函数名与类名相同
没有返回值类型
没有具体的返回值
注意：一般函数可以和类名相同，但不规范，所以一般首字母都小写

构造函数与一般函数的区别：
运行上的区别
构造函数在对象创建时就已经执行了，而且只执行一次
一般函数是在对象创建后，需要时被对象调用，可以调用多次

对象是如何初始化的？
定义的每一个类中，都有一个默认的空参数构造函数。而一旦在类中自定义了构造函数后，默认的构造函数就不存在了。

/*
class 类名{
	//类中默认的空参构造函数，专门用于对象初始化
	类名() {}
}
*/

构造函数中有return语句吗？
有，作用是用来结束初始化。

构造函数可以私有化吗？
构造函数可以私有化，只在本类中使用。且构造函数一旦私有化，其他程序就无法创建该类的对象。因为无法对创建的对象初始化。

构造函数私有化如何访问？
首先需要清楚的是，构造函数只能被构造函数调用，不能被一般方法调用。而构造函数之间的访问是通过this关键字实现的
且当成员变量和局部变量同名时，可通过this关键字区分

class Person{
	private String name;
	private int age;
	//构造函数私有化
	private Person(String name){
		this.name = name;
	}
	//this关键字调用
	Person(String name,int age){
		this(name);
		this.age = age;//this关键字区分成员变量局部变量
	}
	public void show(){
		//this关键字区分成员变量局部变量
		System.out.println("name="+this.name+",age="+this.age);
	}		
}	
public class PersonThis{
	public static void main(String args[]){
		Person p = new Person("litter baby",2);
		p.show();
	}
}

注意：用于调用构造函数的this语句必须在第一行，因为初始化动作要先执行

一道小练习

//判断是否是同龄人的功能
class Person{
	private String name;
	private int age;
	//初始化
	Person(String name,int age){
		this.name = name;
		this.age = age;	
	}
	public boolean equalsAge(Person pp){
		/*if (pp.age == this.age){
			return true;
		}else{
			return false;
		}*/		
		return pp.age == this.age;
	}
}
public class EqualsAge{
	public static void main(String args[]){
	Person p1 = new Person("lily",21);
	Person p2 = new Person("lucy",22);
	boolean b = p1.equalsAge(p2);
	System.out.print("b="+b);
	}
}

构造函数的重载

class Person{
	private String name;
	private int age;
	//构造函数初始化
	Person(String name){
		this.name = name;
	}
	Person(String name,int age){
		this.name = name;
		this.age = age;
	}
	Person(){		
	}
	public void show(){
		System.out.println("name="+this.name+",age="+this.age);
	}		
}	
public class PersonOverload{
	public static void main(String args[]){
		Person p1 = new Person();
		Person p2 = new Person("litter baby");
		Person p3 = new Person("litter baby",2);
		p1.show();
		p2.show();
		p3.show();
	}
}

静态关键字static

定义：
1、被静态修饰符修饰的成员，可以直接被类名调用
2、静态成员优于对象存在
3、静态成员随类的加载而加载，随类的消失而消失，静态成员周期 很长
3、静态方法只能访问静态成员，不可访问非静态成员，这是静态方法的访问局限性
4、静态方法中不能出现this或者super关键字
5、主函数是静态的

成员变量和静态变量的区别
名称上：成员变量也称实例变量，静态变量也称类变量
内存存储上：成员变量存储在堆内存中，静态变量存储在方法区的静态区中
生命周期上：成员变量随对象的出现而出现，随对象的消失而消失。静态变量随类的出现而出现，随类的消失而消失。

怎么用和什么时候用？
直接用于修饰成员
成员变量时：如果数据在所有对象中都是一样的，直接静态修饰
成员函数时：如果函数没有访问过对象中的属性数据，那么该函数是静态的

示例：
当创建对象去调用某个方法时，该方法没有涉及到对象中的数据，该对象的建立是没有意义的。
我们可以通过类名的方式调用，即类名.方法名();
但要注意的是，被调用的方法需要用static修饰符修饰。
在函数没有访问到对象中的属性时，就可以使用该方法调用。

class Person{
	private String name;
	private int age;
	private String ID;
	//共有属性
	static String country = "CNINA";
	Person( String name,int age,String ID){
		this.name=name;
		this.age = age;
		this.ID = ID;
	}	
	//创建一个sleep方法，只单纯输出，并不需要使用name,age等
	//使用类名的方式访问，该方法需要使用静态修饰符static
	public static void sleep(){
		System.out.print("呼呼");
	}
	public void show(){
		System.out.println("name="+name+",age="+age+",ID="+ID);
		//类名方式调用共有属性
		System.out.println("FROM:"+Person.country);
	}
}
public class StaticDemo{
	public static void main(String args[]){
		Person p1 = new Person("vincy",21,"1223");
		Person p2 = new Person("lily",22,"1023");
		p1.show();
		p2.show();
		//类名方式调用
		Person.sleep();
	}
}

静态代码块

概念：随着类的加载而执行，且只执行一次
作用：对类进行初始化
应用场景：类不需要创建对象，但需要初始化。将部分代码存储到静态代码块中

class Demo{
	//只能访问静态成员
	static int num;
	//静态代码块
	static{
		int num = 20;
		System.out.println(num);
	}
	static void show(){
		System.out.println("OVER");
	}
}
public class StaticCodeBlog{
	public static void main(String args[]){
		Demo.show();
		Demo.show();
	}
}

构造代码块

概念：定义在类中的非静态代码块。
用处：给所有对象进行初始化。

class Demo{
	private String name;
	private int age;
	//构造函数
	Demo(String name,int age){
		this.name = name;
		this.age = age;
		System.out.println("name="+this.name+",age="+this.age);
	}
	void test(){
		System.out.println("TEST!");
	}
	//构造代码块
	{
		test();
	}
}
public class ConstructDemo{
	public static void main(String args[]){
		Demo d1 = new Demo("lily",20);
		Demo d2 = new Demo("lucy",22);		
	}
}

补充：

局部代码块：用于控制变量的生命周期，用完即弃。

public class PartDemo{
	public static void main(String args[]){
		int x = 3;
		//局部代码块
		{
			System.out.println("TEST");
		}
		System.out.println("x="+x);
	}
}

public class PartDemo{
	public static void main(String args[]){
		//int x = 3;
		//局部代码块
		{	//将变量x放进局部代码块
			int x = 3;
			System.out.println("TEST");
		}
		System.out.println("x="+x);
	}
}

文章为学习笔记，如有不足之处还请指正