Java中 static 关键字详解

static(静态的):

         作用:

                  修饰成员变量和成员方法

         特点:

                  1,当修饰成员变量的时候:被所有对象共享

                  静态的变量所在的内存区域在方法区,且只有一份,所有对象使用的静态变量都是同一个变量

                  2,static修饰的内容,可以通过类名直接调用

                  3,被static修饰的内容,是随着类的加载而加载,优先于对象存在

 

为什么需要使用 static ?

使用 static 关键字可以 共享某个成员

 

举例代码:

建一个学生类

public class Student {
	String name;
	int age;
	static String graduateFrom;//毕业院校
	
	public void show() {
		System.out.println(name + "," + age + "," + graduateFrom);
	}
}

建一个测试类

public class StaticDemo {
	public static void main(String[] args) {
		//Student.graduateFrom = "Java学院2";
		
		//创建学生类的对象
		Student s = new Student();
		//为对象的成员变量进行赋值
		s.name = "小苍同学";
		s.age = 18;
		s.graduateFrom = "Java学院";
	
		
		s.show();
		
		Student s2 = new Student();
		s2.name = "小波同学";
		s2.age = 20;
		s2.show();
	}
}

在测试代码中,小波同学并没有设定毕业院校,但运行后,结果为:

说明了graduateFrom这个成员变量,在这个类中是被所有的成员所共享的,只要设置了一个成员变量的值,后续的对象,不用设置改成员变量了. 

同时,改成员变量,可以直接通过类名来设置,例如案例中的Student.graduateFrom = "Java学院2";

将注释去掉,同时将s.graduateFrom = "Java学院";后,运行结果为

说明了可成功通过类名来设置成员变量的值.

静态内存图解:

 

静态方法的注意事项:

静态的方法,只能访问静态的,非静态的方法,可以访问静态和非静态的.

原因是: 静态的内容是随着类的加载而加载,优先于对象存在

 

 

静态的优缺点:

                  优点:

                          最主要的优点是可以通过类名的方式直接去用静态的方法和静态的变量

                  缺点:

                          静态的方法只能访问静态的,有了限制用起来不能随便用.

静态的应用场景:

static关键字,用的最多的地方,就是写 工具类

何为工具类,该类中,所有的方法都是静态的,都不需要创建对象使用,直接通过类名来调用.

 

如何写一个工具类

1,构造方法私有化

                                   私有化有什么作用:私有化构造方法,那么这个类就不能其他类中被new出来了

                                  私有化的原因:工具类中的方法都是静态的,直接通过类名去调用就可以了,不需要创建对象,     浪费堆内存空间

                                  

   2,所有的方法以及成员变量  都是 静态的                         

  3,一般情况下一个工具类的类名后面都是Utils结束的,比如ArrayUtils

 

工具类的代码案例:

public class MyArrays {
	//这是一个和数组操作有关的工具类，不需要创建对象，所以我们可以私有他的构造方法
	private MyArrays() {}
	
	/*
	 * 获取指定数组中的最大元素
	 * 
	 */
	public static int getMax(int[] arr) {	
		//参照物
		int max = arr[0];
		//遍历数组，获取数组中的每一个元素
		for(int x = 1;x < arr.length;x++) {
			if(max < arr[x]) {
				//替换参照物
				max = arr[x];
			}
		}
		
		return max;
	}
	
	
	
	/*
	 * 获取指定数组中的指定元素的索引位置
	 * 
	 */
	
	public static int getIndex(int[] arr,int a) {
		for(int x = 0;x < arr.length;x++) {
			if(arr[x] == a) {
				return x;
			}
		}
		
		return -1;//如果指定的元素不存在，则返回-1
	}
	
}

测试代码

public class MyArraysDemo {
	public static void main(String[] args) {
		int[] arr = {1,2,3,4,5,3};
		
		//直接通过类名MyArrays来调用方法getMax,获取数组中的最大值
		int max = MyArrays.getMax(arr);
		System.out.println(max);
		
		//直接通过类名MyArrays来调用方法getIndex,获取数组中某个数第一次出现的索引
		int index = MyArrays.getIndex(arr, 3);
		System.out.println(index);
	}
}

运行结果为:

Static静态代码块的特点: 类加载的时候执行,并且只会执行一次

 

代码块:

         局部代码块:

                  位置:写在方法中

                 

                  执行的时机:

                          只要方法被调用了,就执行局部代码块

                 

         构造代码块:

                  位置:类中方法外

                 

                  执行的时机:

                          只要有对象被创建了,就执行构造代码块

                 

         静态代码块:

                  位置:类中方法外

                 

                  格式:

                  static{

                         

                  }

                         

                  执行的时机:

                          类加载的时候执行,并且只会执行一次,因为类的加载只会加载一次

总结: static的特点是共享的,静态的,可直接通过类名调用,不需要创建对象.