Java中的静态static关键字

初学java的朋友会将java中的static与C/C++中的static关键字的功能混淆了。在这里只需要记住一点：与C/C++中的static不同，Java中的static关键字不会影响到变量或者方法的作用域。在Java中能够影响到访问权限的只有private、public、protected（包括包访问权限）这几个关键字，并且在C/C++中static是可以作用域局部变量的，但是在Java中切记：static是不允许用来修饰局部变量。这是Java语法的规定。

推荐阅读重新总结的关于static文章：深入理解static关键字

1、static的概述

当在定义类的时候，类中都会有相应的属性和方法。而属性和方法都是通过创建本类对象调用的。当在调用对象的某个方法时，这个方法没有访问到对象的特有数据时，方法创建这个对象有些多余。可是不创建对象，方法又调用不了，这时就会想，那么我们能不能不创建对象，就可以调用方法呢？
可以的，我们可以通过static关键字来实现。static它是静态修饰符，一般用来修饰类中的成员。

2、静态的特点

特点一:
被static修饰的成员变量属于类，不属于这个类的某个对象。（也就是说，多个对象在访问或修改static修饰的成员变量时，其中一个对象将static成员变量值进行了修改，其他对象中的static成员变量值跟着改变，即多个对象共享同一个static成员变量）
特点二:
被static修饰的成员可以并且建议通过类名直接访问
访问静态成员的格式:

类名.静态成员变量名
类名.静态成员方法名(参数)

特点三:
静态的加载优先于对象,随着类的加载而加载

/*
 * static:是一个关键字，用于修饰成员变量和成员方法
 * static的特点：
 * 			被所有的对象所共享
 * 			可以使用类名调用
 * 			静态的加载优先于对象
 * 			随着类的加载而加载
 * 
 */
public class StaticDemo {
	public static void main(String[] args) {
		Person.graduateFrom = "学院";
		
		Person p = new Person();
		p.name = "小明同学";
		p.age = 18;
		//p.graduateFrom = "学院";
		p.speak();
		
		Person p2 = new Person();
		p2.name = "小波同学";
		p2.age = 20;
		//p2.graduateFrom = "学院";
		p2.speak();
	}
}

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

3、 静态的注意事项

一、 静态成员只能直接访问静态成员
二、 非静态成员既可以访问非静态成员也可以访问静态成员

/*
 * static的注意事项：
 * 			静态方法：
 * 				可以调用静态的成员变量
 * 				可以调用静态的成员方法
 * 				不可以调用非静态成员变量
 * 				不可以调用非静态成员方法
 * 				静态方法只能调用静态的成员
 * 			非静态方法：
 * 				可以调用静态的成员变量
 * 				可以调用静态的成员方法
 * 				可以调用非静态的成员变量
 * 				可以调用非静态的成员方法
 * 		
 * 	静态的方法中是没有this这个对象（this代表当前对象）
 * 				
 * 
 */
public class StaticDemo2 {
	public static void main(String[] args) {
		Student.graduateFrom = "学院";
		Student.study();
	}
}


class Student {
	String name;
	int age;
	static String graduateFrom;//院校
	
	public static void study() {
		///System.out.println(graduateFrom);
		//sleep();
		
		//System.out.println(name);
		
		//eat();
		
	}
	
	public static void sleep() {
		System.out.println("sleep");
		
	}
	
	public void eat() {
		System.out.println("eat");
		
		System.out.println(graduateFrom);
		sleep();
		
		
	}
	
}

4、静态的优缺点

静态优点:
对对象的共享数据提供单独空间的存储，节省空间，没有必要每一个对象都存储一份
可以直接被类名调用,不用在堆内存创建对象
静态成员可以通过类名直接访问,相对创建对象访问成员方便

静态弊端:
访问出现局限性。（静态虽好，但只能访问静态）

5、静态应用

Math类是一个很好的静态应用的例子

一、Math 类包含用于执行基本数学运算的方法。数学操作常用的类。
二、Math类的构造方法被private,无法创建对象,也就无法通过对象来访问Math类中的成员
三、Math类中所有的成员都被静态修饰,因此我们可以直接通过类名访问

public class MathDemo {
	public static void main(String[] args) {
		//Math:包含了一些基本的数学运算方法
		//static double PI  
		//System.out.println(Math.PI);
		
		//static double abs(double a)  :返回绝对值
		//System.out.println(Math.abs(15));
		//System.out.println(Math.abs(-10));
		
		//static double ceil(double a)   向上取整
		//System.out.println(Math.ceil(1.2));
		//System.out.println(Math.ceil(1.6));
		//static double floor(double a)   向下取整
		//System.out.println(Math.floor(1.2));
		//System.out.println(Math.floor(1.6));
		
		//static long round(double a)  ：四舍五入
		//System.out.println(Math.round(1.2));
		//System.out.println(Math.round(1.6));
		
		//static double max(double a, double b) 
		//System.out.println(Math.max(3, 4));
		
		//static double pow(double a, double b) :返回第一个参数的第二个参数次幂
		//System.out.println(Math.pow(3, 2));
		
		//static double random() :返回一个随机数，大于零且小于一
		System.out.println(Math.random());
		
	}
}

除了math类，static也常常应用在自定义工具类中

需求:自定义一个专门对数组操作的工具类,具有的功能如下
1.定义一个方法,该方法可以返回数组中最大元素
2.定义一个方法,该方法根据指定的值去数组中查找是否存在该值
存在,返回该值在数组中的索引不存在,返回-1

public class MyArrays {
	private MyArrays() {} 
	
	/*
	 * 返回数组中最大的元素
	 * 
	 */
	public static int getMax(int[] arr) {
		int max = 0;//参照物
		//遍历数组
		for(int x = 0;x < arr.length;x++) {
			if(arr[x] > max) {
				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
	}
}


package com.gx;

public class MyArraysDemo {
	public static void main(String[] args) {
		int[] arr = {3,5,8,10,1};
		int max = MyArrays.getMax(arr);
		System.out.println(max);
		
		int index = MyArrays.getIndex(arr, 8);
		System.out.println(index);
	}
}

6、类变量与实例变量区分

类变量

类变量其实就是静态变量
定义位置--------------定义在类中方法外
所在内存区域--------方法区
生命周期--------------随着类的加载而加载
特点--------------------无论创建多少对象,类变量仅在方法区中,并且只有一份

实例变量

实例变量-------其实就是非静态变量
定义位置-------定义在类中方法外
所在内存区域-------堆
生命周期---------随着对象的创建而加载
特点--------------每创建一个对象,堆中的对象中就有一份实例变量

希望看完后对你有所帮助！