本文目录一览：
1、java中的static到底有什么作用? 2、Java中static的作用? 3、java中static的用法 4、[java static是什么意思？](#java static是什么意思？) 5、java中的static如何使用? 6、java中static是什么意思？能不能通俗的讲下，让我这个菜鸟好理解一点
java中的static到底有什么作用?
static 表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，也可以形成静态 static 代码块，但是 Java 语言中没有全局变量的概念。被 static 修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有实例共享。static 变量前可以有 private 修饰，表示这个变量可以在类的静态代码块中，或者类的其他静态成员方法中使用（当然也可以在非静态成员方法中使用——废话），但是不能在其他类中通过类名来直接引用，这一点很重要。实际上你需要搞明白，private 是访问权限限定，static 表示不要实例化就可以使用，这样就容易理解多了。static 前面加上其它访问权限关键字的效果也以此类推。
Java中static的作用?
1. static 成员变量
在类中一个成员变量可用 static 关键字来修饰，这样的成员变量称为 static 成员变量，或静态成员变量。而没有用 static 关键字修饰的成员变量称为非静态成员变量。
静态成员变量是属于类的，也就是说，该成员变量并不属于某个对象，即使有多个该类的对象实例，静态成员变量也只有一个。只要静态成员变量所在的类被加载，这个静态成员变量就会被分配内存空间。因此在引用该静态成员变量时，通常不需要生成该类的对象，而是通过类名直接引用。引用的方法是“类名.静态变量名”。当然仍然可以通过“对象名.静态变量名”的方式引用该静态成员变量。相对应的非静态成员变量则属于对象而非类，只有在内存中构建该类对象时，非静态成员变量才被分配内存空间。
2. static 成员方法
Java 中也支持用 static 关键字修饰的成员方法，即静态成员方法。与此相对应的没有用 static 修饰的成员方法称为非静态成员方法。
与静态成员变量类似，静态成员方法是类方法，它属于类本身而不属于某个对象。因此静态成员方法不需要创建对象就可以被调用，而非静态成员方法则需要通过对象来调用。
特别需要注意的是，在静态成员方法中不能使用 this、super 关键字，也不能调用非静态成员方法，同时不能引用非静态成员变量。这个道理是显而易见的，因为静态成员方法属于类而不属于某个对象，而 this、super 都是对象的引用，非静态成员方法和成员变量也都属于对象。所以当某个静态成员方法被调用时，该类的对象可能还没有被创建，那么在静态成员方法中调用对象属性的方法或成员变量显然是不合适的。即使该类的对象已经被创建，也是无法确定它究竟是调用哪个对象的方法，或是哪个对象中的成员变量的。所以在这里特别强调这一点。
3. static 代码块
static 代码块又称为静态代码块，或静态初始化器。它是在类中独立于成员函数的代码块。static 代码块不需要程序主动调用，在 JVM 加载类时系统会执行 static 代码块，因此在 static 代码块中可以做一些类成员变量的初始化工作。如果一个类中有多个 static 代码块，JVM 将会按顺序依次执行。需要注意的是，所有的 static 代码块只能在 JVM 加载类时被执行一次。
4. static 内部类
在 Java 中还支持用 static 修饰的内部类，称为静态内部类。静态成员内部类的特点主要是它本身是类相关的内部类，所以它可以不依赖于外部类实例而被实例化。静态内部类不能访问其外部类的实例成员（包括普通的成员变量和方法），只能访问外部类的类成员（包括静态成员变量和静态方法）。即使是静态内部类的实例方法（非静态成员方法）也不能访问其外部类的实例成员。
java中static的用法
1. 静态方法
通常，在一个类中定义一个方法为 static，那就是说，无需本类的对象即可调用此方法。
声明为 static 的方法有以下几条限制：
- 它们仅能调用其他的
static方法。 - 它们只能访问
static数据。 - 它们不能以任何方式引用
this或super。
class Simple {
static void go() {
System.out.println("Welcome");
}
}
public class Cal {
public static void main(String[] args) {
Simple.go();
}
}
调用一个静态方法就是“类名.方法名”，静态方法的使用很简单如上所示。一般来说，静态方法常常为应用程序中的其它类提供一些实用工具所用，在 Java 的类库中大量的静态方法正是出于此目的而定义的。
2. 静态变量
声明为 static 的变量实质上就是全局变量。当声明一个对象时，并不产生 static 变量的拷贝，而是该类所有的实例变量共用同一个 static 变量。静态变量与静态方法类似。所有此类实例共享此静态变量，也就是说在类装载时，只分配一块存储空间，所有此类的对象都可以操控此块存储空间，当然对于 final 则另当别论了。
class Value {
static int c = 0;
static void inc() {
c++;
}
}
public class Count2 {
public static void prt(String s) {
System.out.print(s);
}
public static void main(String[] args) {
Value v1, v2;
v1 = new Value();
v2 = new Value();
prt("v1.c=" + v1.c + " v2.c=" + v2.c);
v1.inc();
prt(" v1.c=" + v1.c + " v2.c=" + v2.c);
}
}
结果为：v1.c=0 v2.c=0 v1.c=1 v2.c=1
由此可以证明它们共享一块存储区。static 变量有点类似于 C 中的全局变量的概念。
值得探讨的是静态变量的初始化问题。
如果你需要通过计算来初始化你的 static 变量，你可以声明一个 static 块，static 块仅在该类被加载时执行一次。下面的例子显示的类有一个 static 方法，一些 static 变量，以及一个 static 初始化块：
class Value3 {
static int c = 0;
Value3() {
c = 15;
}
Value3(int i) {
c = i;
}
static void inc() {
c++;
}
}
public class Count {
public static void prt(String s) {
System.out.println(s);
}
Value3 v = new Value3(10);
static Value3 v1, v2;
static { // 此即为 static 块
prt("v1.c=" + v1.c + " v2.c=" + v2.c);
v1 = new Value3(27);
prt("v1.c=" + v1.c + " v2.c=" + v2.c);
v2 = new Value3(15);
prt("v1.c=" + v1.c + " v2.c=" + v2.c);
}
public static void main(String[] args) {
Count ct = new Count();
prt("ct.c=" + ct.v.c);
prt("v1.c=" + v1.c + " v2.c=" + v2.c);
v1.inc();
prt("v1.c=" + v1.c + " v2.c=" + v2.c);
prt("ct.c=" + ct.v.c);
}
}
结果为：
v1.c=0 v2.c=0
v1.c=27 v2.c=27
v1.c=15 v2.c=15
ct.c=10
v1.c=10 v2.c=10
v1.c=11 v2.c=11
ct.c=11
这个程序展示了静态初始化的各种特性。如果你初次接触 Java，结果可能令你吃惊。可能会对 static 后加大括号感到困惑。首先要告诉你的是，static 定义的变量会优先于任何其它非 static 变量，不论其出现的顺序如何。正如在程序中所表现的，虽然 v 出现在 v1 和 v2 的前面，但是结果却是 v1 和 v2 的初始化在 v 的前面。在 static{ 后面跟着一段代码，这是用来进行显式的静态变量初始化，这段代码只会初始化一次，且在类被第一次装载时。如果你能读懂并理解这段代码，会帮助你对 static 关键字的认识。在涉及到继承的时候，会先初始化父类的 static 变量，然后是子类的，依次类推。
3. 静态类
通常一个普通类不允许声明为静态的，只有一个内部类才可以。这时这个声明为静态的内部类可以直接作为一个普通类来使用，而不需实例一个外部类。
public class StaticCls {
public static void main(String[] args) {
OuterCls.InnerCls oi = new OuterCls.InnerCls();
}
}
class OuterCls {
public static class InnerCls {
InnerCls() {
System.out.println("InnerCls");
}
}
}
结果为：InnerCls
java static是什么意思？
是静态修饰符，什么叫静态修饰符呢？大家都知道，在程序中任何变量或者代码都是在编译时由系统自动分配内存来存储的，而所谓静态就是指在编译后所分配的内存会一直存在，直到程序退出内存才会释放这个空间，也就是只要程序在运行，那么这块内存就会一直存在。这样做有什么意义呢？
在 Java 程序里面，所有的东西都是对象，而对象的抽象就是类，对于一个类而言，如果要使用他的成员，那么普通情况下必须先实例化对象后，通过对象的引用才能够访问这些成员，但是有种情况例外，就是该成员是用 static 声明的（在这里所讲排除了类的访问控制），例如：
未声明为 static
class ClassA {
int b;
public void ex1() {
...
}
}
class ClassB {
void ex2 {
int i;
ClassA a = new ClassA();
i = a.b; // 这里通过对象引用访问成员变量 b
a.ex1; // 这里通过对象引用访问成员函数 ex1
}
}
声明为 static
class ClassA {
static int b;
static void ex1() {
...
}
}
class ClassB {
void ex2 {
int i;
i = ClassA.b; // 这里通过类名访问成员变量 b
ClassA.ex1; // 这里通过类名访问成员函数 ex1
}
}
通过以上两种比较，就可以知道 static 用来修饰类成员的主要作用了，在 Java 类库当中有很多类成员都声明为 static，可以让用户不需要实例化对象就可以引用成员，最基本的有 Integer.parseInt()，Float.parseFloat() 等等用来把对象转换为所需要的基本数据类型。这样的变量和方法我们又叫做类变量和类方法。
接下来讲一下被 static 修饰后的变量的值的问题，刚才在前面讲过，被 static 修饰后的成员，在编译时由内存分配一块内存空间，直到程序停止运行才会释放，那么就是说该类的所有对象都会共享这块内存空间，看一下下面这个例子：
class TStatic {
static int i;
public TStatic() {
i = 4;
}
public TStatic(int j) {
i = j;
}
public static void main(String args[]) {
TStatic t = new TStatic(5); // 声明对象引用，并实例化
TStatic tt = new TStatic(); // 同上
System.out.println(t.i);
System.out.println(tt.i);
System.out.println(t.i);
}
}
这段代码里面 Tstatic 类有一个 static 的 int 变量 i，有两个构造函数，第一个用于初始化 i 为 4，第二个用于初始化 i 为传进函数的值，在 main 中所传的值是 5，程序首先声明对象的引用 t，然后调用带参数的构造函数实例化对象，此时对象 t 的成员变量 i 的值为 5，接着声明对象 tt，调用无参数的构造函数，那么就把对象 tt 的成员变量 i 的值初始化为 4 了，注意了，在这里 i 是 static，那就是说该类的所有对象都共享该内存，那也就是说在实例化对象 tt 的时候改变了 i 的值，那么实际上对象 t 的 i 值也变了，因为实际上它们引用的是同一个成员变量。最后打印的结果是三个 4。
java中的static如何使用?
有时你希望定义一个类成员，使它的使用完全独立于该类的任何对象。通常情况下，类成员必须通过它的类的对象访问，但是可以创建这样一个成员，它能够被它自己使用，而不必引用特定的实例。在成员的声明前面加上关键字 static(静态的)就能创建这样的成员。如果一个成员被声明为 static，它就能够在它的类的任何对象创建之前被访问，而不必引用任何对象。你可以将方法和变量都声明为 static。static 成员的最常见的例子是 main()。因为在程序开始执行时必须调用 main()，所以它被声明为 static。声明为 static 的变量实质上就是全局变量。当声明一个对象时，并不产生 static 变量的拷贝，而是该类所有的实例变量共用同一个 static 变量。
声明为 static 的方法有以下几条限制：
- 它们仅能调用其他的
static方法。 - 它们只能访问
static数据。 - 它们不能以任何方式引用
this或super（关键字super与继承有关，在下一章中描述）。 如果你需要通过计算来初始化你的static变量，你可以声明一个static块，static块仅在该类被加载时执行一次。 下面的例子显示的类有一个static方法，一些static变量，以及一个static初始化块：
class UseStatic {
static int a = 3;
static int b;
static void meth(int x) {
System.out.println("x = " + x);
System.out.println("a = " + a);
System.out.println("b = " + b);
}
static {
System.out.println("Static block initialized.");
b = a * 4;
}
public static void main(String args[]) {
meth(42);
}
}
一旦 UseStatic 类被装载，所有的 static 语句被运行。首先，a 被设置为 3，接着 static 块执行（打印一条消息），最后，b 被初始化为 a * 4 或 12。然后调用 main()，main() 调用 meth()，把值 42 传递给 x。3 个 println() 语句引用两个 static 变量 a 和 b，以及局部变量 x。
注意：在一个 static 方法中引用任何实例变量都是非法的。
下面是该程序的输出：
Static block initialized.
x = 42
a = 3
b = 12
在定义它们的类的外面，static 方法和变量能独立于任何对象而被使用。这样，你只要在类的名字后面加点号运算符即可。例如，如果你希望从类外面调用一个 static 方法，你可以使用下面通用的格式：
classname.method()
这里，classname 是类的名字，在该类中定义 static 方法。可以看到，这种格式与通过对象引用变量调用非 static 方法的格式类似。一 static 变量可以以同样的格式来访问——类名加点号运算符。这就是 Java 如何实现全局功能和全局变量的一个控制版本。
下面是一个例子。在 main() 中，static 方法 callme() 和 static 变量 b 在它们的类之外被访问。
class StaticDemo {
static int a = 42;
static int b = 99;
static void callme() {
System.out.println("a = " + a);
}
}
class StaticByName {
public static void main(String args[]) {
StaticDemo.callme();
System.out.println("b = " + StaticDemo.b);
}
}
下面是该程序的输出：
a = 42
b = 99
static 成员是不能被其所在 class 创建的实例访问的。
如果不加 static 修饰的成员是对象成员，也就是归每个对象所有的。
加 static 修饰的成员是类成员，就是可以由一个类直接调用，为所有对象共有的。
java中static是什么意思？能不能通俗的讲下，让我这个菜鸟好理解一点
static 英文是静态的意思，所以它在 Java 中也是这么用的，是一个修饰词，在定义数据前面加上它是指这个数据是静态不变的，在方法名加上它是指这个方法是静态的。一般就是这些用处。
