Java基础static关键字

一：关于java中的static关键字：

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

示例代码：

class Chinese {
    
	//身份证号【每个对象的身份证号不同】
	//实例变量
	int id;
    
	//姓名【每一个对象的姓名不同】
	//实例变量
	String name;
	
	//实例对象存储在java对象内部，在堆内存当中，在构造方法执行的时候初始化
	//国籍【所有对象国籍一样，这种特征属于类级别的特征，可以提升为整个模板的特征，可以在变量前添加static关键字修饰】
	//静态变量，静态变量在类加载的时候初始化，不需要创建对象，内存就开辟了
	//所有的中国人的国籍都是"中国"，这里声明为实例变量显然是不太合适的，太浪费内存空间，没不要让每个对象都保存一份“国籍”内存
	static String country = "中国";
	
	public Chinese(){	
		/*this.id = 0;
		this.name = null;
		this.country = null;*/
	}
	
	public Chinese(int id,String name){
		this.id = id;
		this.name = name;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public static String getCountry() {
		return country;
	}

	public static void setCountry(String country) {
		Chinese.country = country;
	}
}
public class ChineseTest {

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

}
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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

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

• 1.语法格式：

 static{
            java语句；
        }
1
2
3

• 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 -->");
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

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

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

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

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

示例代码：

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 StaticTest03 {
     
	//实例变量
	int i = 10;
	
	//实例方法
	public void doSome(){
		
	}
	
	//静态主方法
	public static void main(String[] args) {
		
	   StaticTest03 st = new StaticTest03();
	   System.out.println(st.i);
	   st.doSome();
	   
	   //使用数学工具类
	   System.out.println(MathUtil.sumInt(20,30));
	   System.out.println(MathUtil.divide(20,30));
			  
	}
}
/*
 * 总结：
 * class{
 *    静态代码块;
 *    实例代码块;
 * 
 *    静态变量;
 *    实例变量;
 *    
 *    构造方法;
 *    
 *    静态方法;
 *    实例方法;
 * }
 * 
 * 
 * 
 * 
 * 
 * */

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
45
46
47
48
49
50
51
52
53
54

四：实例代码块/代码块【了解内容，使用的非常少】

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

示例代码：

public class StaticTest2 {
	
	//构造函数
	public StaticTest2(){
		System.out.println("缺省构造器执行！");
	}
    
	//实例代码块
	{
		System.out.println(1);
	}
	
	//实例代码块
	{
		System.out.println(2);
	}
	
	//实例代码块
	{
		System.out.println(3);
	}
	public static void main(String[] args) {
			System.out.println("main begin!");
			
			new StaticTest2();
			
			new StaticTest2();
	}
}
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