1. 什么是Static 关键字?
Static 能够与变量，方法和类一起使用，称为静态变量，静态方法。如果在一个类中使用static修饰变量或者方法的话，它们可以直接通过类访问，不需要创建一个类的对象来访问成员。
实例：
package com.java.JavaStatic;
/**
* Understand Java Static
* @author Jeff
* @date 2016/03/17
* http://www.weixueyuan.net/view/6003.html
*/
public class demo01 {
//定义静态变量a
public static int a=1;
//定义变量b
int b=2;
//创建静态方法 sum()
public static int sum (int x,int y) {
return x+y;
}
public static void main (String[] args) {
//通过类访问变量a
System.out.println("a= "+demo01.a);
//实例化对象myDemo访问变量b
demo01 myDemo =new demo01();
System.out.println("b= "+myDemo.b);
//通过类访问方法sum
System.out.println("x+y: "+sum(3,5));
}
}
结果：
a= 1
b= 2
x+y: 8
2. Static 内存分配
静态变量属于类，不属于任何独立的对象，所以无需创建类的实例就可以访问静态变量。之所以会产生这样的结果，是因为编译器只为整个类创建了一个静态变量的副本，也就是只分配一个内存空间，虽然有多个实例，但这些实例共享该内存。实例变量则不同，每创建一个对象，都会分配一次内存空间，不同变量的内存相互独立，互不影响，改变 a 对象的实例变量不会影响 b 对象。
实例：
package com.java.JavaStatic;
/**
* Static内存分配
* @author Jeff
* 2016/4/3
* http://www.weixueyuan.net/view/6003.html
*/
public class demo02 {
static int i;
int j;
public static void main(String[] args) {
demo02 obj1 = new demo02();
obj1.i = 10;
obj1.j = 20;
demo02 obj2 = new demo02();
System.out.println("obj1.i=" + obj1.i + ", obj1.j=" + obj1.j);
System.out.println("obj2.i=" + obj2.i + ", obj2.j=" + obj2.j);
}
}
结果：
obj1.i=10, obj1.j=20
obj2.i=10, obj2.j=0
3. 什么情况使用静态方法和静态变量
- 需要通过类访问静态方法和静态变量
- 需要在静态方法中访问静态变量
- 静态方法的类型不是对象型
3. 关于静态变量和静态方法的总结：
- 结论1.构造方法不允许声明为 static 的；
- 结论2.1.静态方法只能访问静态变量
- 结论2.2.静态方法不能访问实例变量
- 结论3.1.静态方法只能够调用静态方法；
- 结论3.2.静态方法不能够调用非静态方法；
- 结论4.静态方法中不存在当前对象，因而不能使用 this,当然也不能使用 super
- 结论5.局部变量不能使用static修饰
- 结论6.1.静态方法能被静态方法重载
- 结论6.2.静态方法能被非静态方法重载
- 结论7.1 静态方法,可以声明object类型,一般不推荐使用静态方法,因为不能通过类访问
- 结论7.2 非静态方法,可以声明object类型,一般推荐使用,因为可以使用实例访问
- 结论8. 静态方法只能在静态类中使用
- 结论9.1.静态方法不能被非静态方法覆盖
- 结论9.2 静态方法能被静态方法覆盖
- 结论10 静态方法直接通过类访问
- 结论11 如访问控制权限允许，静态变量和静态方法也可以通过对象来访问，但是不被推荐
- 结论12 静态方法且类型对象,不能通过类访问
实例：
package com.java.JavaStatic;
/**
* 静态方法和静态方法总结
* @author Jeff
* 2016/04/03
*/
public class demo03 {
public static int a=1;
int b=2;
//结论1.构造方法不允许声明为 static 的；
// public static demo03 ()
// {
// System.out.println("我是构造方法");
// }
public int sum (int x,int y) {
return x+y;
}
//静态方法sum2, int类型
public static int sum2 (int x,int y) {
//结论2.1.静态方法只能访问静态变量
a=3;
x=x+a;
//结论2.2.静态方法不能访问实例变量；
//b=3;
//结论3.1.静态方法只能够调用静态方法；
demo03.sum3(1, 2);
//结论3.2.静态方法不能够调用非静态方法；
//demo03.sum(1,2);
//结论4.静态方法中不存在当前对象，因而不能使用 this,当然也不能使用 super
//this.sum3(1, 2);
return x+y;
}
//静态方法sum3,int类型
public static int sum3 (int x,int y) {
//结论5.局部变量不能使用static修饰
//static int c;
return x+y;
}
//结论6.1.静态方法能被静态方法重载
public static int sum3 (int x) {
return x;
}
//结论6.2.静态方法能被非静态方法重载
public int sum3 (int x, int y, int z) {
return x+y+z;
}
//结论7.1 静态方法,可以声明object类型,一般不推荐使用静态方法,因为不能通过类访问
public static demo03 object () {
demo03 d=new demo03();
d.b=3;
return d;
}
//结论7.2 非静态方法,可以声明object类型,一般推荐使用,因为可以使用实例访问
public demo03 object2 () {
demo03 d=new demo03();
d.b=3;
return d;
}
//结论8. 静态方法只能在静态类中使用
public static class superClass {
public static int getAge (int age) {
return age;
}
public static String getName (String name) {
return name;
}
}
public static class childClass extends superClass {
//结论9.1.静态方法不能被非静态方法覆盖
// public String getName (String name) {
// return name;
// }
//结论9.2 静态方法能被静态方法覆盖
public static String getName (String name) {
return name;
}
}
public static void main (String[] args) {
//结论10 静态方法直接通过类访问
System.out.println("x+y: "+demo03.sum2(3,5));
//结论11 如访问控制权限允许，静态变量和静态方法也可以通过对象来访问，但是不被推荐
demo03 de=new demo03();
de.sum2(1,2);
de.a=4;
//结论12 静态方法且类型对象,不能通过类访问
//demo03.object;
}
}
4.静态导入
对于使用频繁的静态变量和静态方法，可以将其静态导入.
实例：
package com.java.JavaStatic;
//1.通过 import static java.lang.System.*; 将其导入，下次直接调用 out.println() 就可以了
import static java.lang.System.*;
//2.导入类中的Math.random
import static java.lang.Math.random;
/**
* 静态导入. 对于使用频繁的静态变量和静态方法，可以将其静态导入
* @author Jeff
* @date:2016/4/4
* http://www.weixueyuan.net/view/6003.html
*/
public class demo04 {
public static void main(String[] args) {
//输出语句 System.out.println(); 中的 out 就是 System 类的静态变量，
out.println("产生的一个随机数：" + random());
}
}