static关键字【java零基础系列】

下一篇持续更新中… 如有错误欢迎指正！！！

static关键字

1. 什么时候成员变量声明为实例变量呢？
   所有对象都有这个属性，但是这个属性的值会随着对象的变化而变化【不同对象的这个属性具体的值不同】
2. 什么时候成员变量声明为静态变量呢？
   所有对象都有这个属性，并且所有对象的这个属性的值是一样的。建议定义为静态变量，节省内存的开销。
3. 静态变量在类加载的时候初始化，内存在方法区中开辟。访问的时候不需要创建对象，直接使用 “ 类名.静态变量名 ” 的方式访问。
4. 关于Java中的static关键字：

• static 英语单词翻译为静态的
• static 修饰的方法是静态方法
• static 修饰的变量是静态变量
• 所有static修饰的元素都称为静态的，都可以使用类名的方式访问，当然也可以用引用的方式访问【但不建议】
• static修饰的所有元素都是类级别的特征，和具体的对象无关

代码块 1 ：

public class Chinese{
	
	//身份证号【每一个对象的身份证号不同】
	//实例变量
	String id;
	
	//姓名【每一个对象的姓名不同】
	//实例变量
	String name;
	
	//国籍【每一个对象由于都是由Chinese类实例化的，所以每一个中国人的国籍都是中国
	//无论通过Chinese类实例化多少个Java对象，这些Java对象的国籍都是中国
	//实例变量【实例变量是一个Java对象就有一份儿。一百个java对象就一百份儿】分析这种设计方式有什么缺点？
	//所有的中国人的国籍都是 “ 中国 ” ，这里声明为实例变量显然是不合适的，太浪费内存空间，没必要让每一个对象都保留一份 “ 国籍 ” 内存。
	//国籍【所有对象国籍一样，这种特征属于类级别的特征可以提升为整个模板的特征，可以在变量前添加static关键字修饰】
	//静态变量【静态变量在类加载的时候初始化，不需要创建对象，内存就开辟了】
	//静态变量储存在方法区内存当中
	static String country;

	//构造函数
	public Chinese{
		/*
		this.id = null;
		this.name = null;
		this.country = null;
		*/
	}

	public Chinese{
		this.id = id;
		this.name = name;
		this.country = country;
	}
}

国籍声明为实例变量的内存分析图

测试 1 ：

public class ChineseTest{
	public static void main(String[] args){
		
		//创建中国人对象1
		Chinese zhangsan = new Chinese("1","zhangsan");
		System.out.println(zhangsan.id + "," + zhangsan.name + "," + zhangsan.country);
		
		//创建中国人对象2
		Chinese lisi = new Chinese("2","lisi");
		System.out.println(lisi.id + "," + lisi.name + "," + lisi.country);
		
		//创建中国人对象3
		Chinese wangwu = new Chinese("1","wangwu");
		System.out.println(wangwu.id + "," + wangwu.name + "," + wangwu.country);
	}
}

代码块 2 ：

public class Chinese{
	
	//身份证号【每一个对象的身份证号不同】
	//实例变量
	String id;
	
	//姓名【每一个对象的姓名不同】
	//实例变量
	String name;
	
	//国籍【所有对象国籍一样，这种特征属于类级别的特征可以提升为整个模板的特征，可以在变量前加static关键字修饰】
	//静态变量【静态变量在类加载的时候初始化，不需要创建对象，内存就开辟了】
	//静态变量储存在方法区内存当中
	static String country = "中国";

	//构造函数
	public Chinese{
		/*
		this.id = null;
		this.name = null;
		this.country = null;
		*/
	}

	public Chinese{
		this.id = id;
		this.name = name;
	}
}

国籍声明为静态变量的内存分析图

测试 2 ：

public class ChineseTest{
	public static void main(String[] args){
		
		//创建中国人对象1
		Chinese zhangsan = new Chinese("1","zhangsan");
		System.out.println(zhangsan.id + "," + zhangsan.name + "," + Chinese.country);
		
		//创建中国人对象2
		Chinese lisi = new Chinese("2","lisi");
		System.out.println(lisi.id + "," + lisi.name + "," + Chinese.country);
		
		//创建中国人对象3
		Chinese wangwu = new Chinese("3","wangwu");
		System.out.println(wangwu.id + "," + wangwu.name + "," + Chinese.country);
		
		System.out.println(Chinese.country); //中国
		System.out.println(zhangsan.country); //中国
		zhangsan = null;
		//所有静态的数据都是可以采用 “ 类名. ” ，也可以采用 “ 引用. ” ，但是建议采用类名的方式访问。
		//采用引用的方式访问的时候，即使引用是null，也不会出现空指针异常。因为访问静态的数据不需要对象的存在
		System.out.println(zhangsan.country); //中国
	}
}

静态代码块

可以使用static关键字来定义 “ 静态代码块 ”：

1. 语法格式：

static{
	java语句;
}

2. 静态代码块在类加载时执行，并且只执行一次
3. 静态代码块在一个类中可以编写多个，并且遵循自上而下的顺序依次执行
4. 静态代码块的作用是什么？怎么用？用在哪儿？什么时候用？

• 这当然和具体的需求有关。例如，项目中要求在类加载的时刻实际执行代码完成日志的记录，那么这段记录日志的代码就可以编写到静态代码块当中，完成日志记录。
• 静态代码块是Java为程序员准备一个特殊的时刻。这个特殊的时刻被称为类加载时刻。若希望在此刻执行一段特殊的程序，这段程序可以直接放到静态代码块当中

5. 通常在静态代码块当中完成预备工作，先完成数据的准备工作，例如：初始化连接池、解析XML配置文件… …

public class StaticTest01{

	static{
		System.out.println("类加载-->1");
	}
	
	static{
		System.out.println("类加载-->2");
	}
	
	static{
		System.out.println("类加载-->3");
	}
	
	public static void main(String[] args){
		System.out.println("main begin");
	}
}

实例代码块 / 语句块【了解内容使用的非常少】

1. 实例代码块可以编写多个，也是遵循自上而下的顺序，依次执行
2. 实例代码块在构造方法执行之前执行。构造方法执行一次，实例代码块对应执行一次
3. 实例代码块也是Java语言，为程序员准备一个特殊的时机。这个特殊时机被称为对象初始化时机

public class Test{
	
	//构造函数
	public Test(){
		System.out.println("Test类的缺省构造器执行");
	}
	
	//实例代码块
	{
		System.out.println(1);
	}

	//实例代码块
	{
		System.out.println(2);
	}

	//实例代码块
	{
		System.out.println(3);
	}

	//主方法
	public static void main(String[] args){
		System.out.println("main begin");
		new Test();// 这里的new，调用无参数构造方法
	}
}

方法什么时候定义为静态的？

方法描述的是动作

当所有的对象执行这个动作的时候，最终产生的影响是一样的，那么这个动作已经不再属于某一个对象动作了。可以将这个动作，提升为类级别的动作，模板级别的动作。

静态方法中无法直接访问实例变量和实例方法

大多数方法都定义为实例方法。一般一个行为或者一个动作在发生的时候都需要对象的参与，但是也有例外，例如大多数 " 工具类 " 中的方法都是静态方法，因为工具类就是方便编程，为了方便方法的调用，自然不需要new对象是最好的。

public class MainTest{
	// public表示公开的在任何位置都是可以访问的
	// static表示静态的，使用类名的方式即可访问，不需要创建对象，就可以调用main方法
	// void表示main方法执行结束之后不返回任何值
	// Main是main方法的方法名
	// （String[] args）是main方法的形式参数列表
	public static void main(String[] args){
		main(10);
		main("Hello World!");
	}
	
	public static void main(int i){
		System.out.println(i);
	}

	public static void main(String args){
		System.out.println(args);
	}
}

/**
*数学工具类
*/
public class MathUtil{
	
	public static int sumInt(int a,int b){
		return a + b;
	}
	public static int divide(int a,int b){
		return a / b;
	}
}

public class StaticTest{
	 
	 //实例变量
	 int i = 100;
	 
	 //实例方法
	 public void doSome(){
	 
	 }

	//静态方法【又叫静态上下文】
	public static void main(String[] args){
		//System.out.println(i);
		//doSome();

		StaticTest st = new StaticTest();
		System.out.println(st.i);
		st.doSome();

		//使用数学工具类
		System.out.println(MathUtil.sumInt(10,20));
		System.out.println(MathUtil.divide(40,20));
	}
}

总结：一个类，到目前为止我们都可以在其中编写什么？

从第一篇博客到目前为止，我们讲的所有东西，关于面向对象

class 类{
	静态代码块;
	实例代码块;
	
	静态变量
	实例变量
	
	构造方法
	
	静态方法
	实例方法
}
plus两个关键字：
this
static