一、static要领
static要领平常称作静态要领，由于静态要领不依靠于任何对象就可以举行接见，因而关于静态要领来讲，是没有this的，由于它不倚赖于任何对象，既然都没有对象，就谈不上this了。而且由于这个特征，在静态要领中不能接见类的非静态成员变量和非静态成员要领，由于非静态成员要领/变量都是必需依靠细致的对象才可以被挪用。
然则要注重的是，虽然在静态要领中不能接见非静态成员要领和非静态成员变量，然则在非静态成员要领中是可以接见静态成员要领/变量的。举个简朴的例子：
在上面的代码中，由于print2要领是独立于对象存在的，可以直接用过类名挪用。假如说可以在静态要领中接见非静态要领/变量的话，那末假如在main要领中有下面一条语句：
MyObject.print2();
此时对象都没有，str2基础就不存在，所以就会发作矛盾了。一样关于要领也是一样，由于你没法预知在print1要领中是不是接见了非静态成员变量，所以也制止在静态成员要领中接见非静态成员要领。
而关于非静态成员要领，它接见静态成员要领/变量显然是毫无限制的。
因而，假如说想在不建立对象的情况下挪用某个要领，就可以将这个要领设置为static。我们最常见的static要领就是main要领，至于为什么main要领必需是static的，如今就很清晰了。由于递次在实行main要领的时刻没有建立任何对象，因而只要经由过程类名来接见。
别的记着，关于组织器是不是是static要领可参考：http://blog.csdn.net/qq_17864929/article/details/48006835
二、static变量
static变量也称作静态变量，静态变量和非静态变量的区分是：静态变量被一切的对象所同享，在内存中只要一个副本【存放在要领区】，它当且仅当在类首次加载时会被初始化【加final和不加final的static变量初始化的位置不一样】。而非静态变量是对象所具有的，在建立对象的时刻被初始化，存在多个副本，各个对象具有的副本互不影响。
static成员变量的初始化递次依据定义的递次举行初始化。
三、static代码块
static症结字另有一个比较症结的作用就是 用来构成静态代码块以优化递次机能。static块可以置于类中的任何处所，类中可以有多个static块。在类首次被加载的时刻，会依据static块的递次来实行每一个static块，而且只会实行一次【依据class加载道理 每一个类加载一次 运用双亲托付加载】。
初始化的递次 静态代码块 > 组织代码块 > 组织函数
public class Client {
{//组织代码块
System.out.println("实行组织代码块");
}
}
为什么说static块可以用来优化递次机能，是由于它的特征:只会在类加载的时刻实行一次。下面看个例子：
class Person{
private Date birthDate;
public Person(Date birthDate) {
this.birthDate = birthDate;
}
boolean isBornBoomer() {
Date startDate = Date.valueOf("1946");
Date endDate = Date.valueOf("1964");
return birthDate.compareTo(startDate)>=0 && birthDate.compareTo(endDate) < 0;
}
}
isBornBoomer是用来这个人是不是是1946-1964年诞生的，而每次isBornBoomer被挪用的时刻，都邑生成startDate和birthDate两个对象，造成了空间糟蹋，假如改成如许效力会更好，实在就是应用了静态代码块在内存中值加载一次的机制：
class Person{
private Date birthDate;
private static Date startDate,endDate;
static{
startDate = Date.valueOf("1946");
endDate = Date.valueOf("1964");
}
public Person(Date birthDate) {
this.birthDate = birthDate;
}
boolean isBornBoomer() {
return birthDate.compareTo(startDate)>=0 && birthDate.compareTo(endDate) < 0;
}
}
因而，很多时刻会将一些只须要举行一次的初始化操纵都放在static代码块中举行。
四、静态内部类
这个处所不零丁写静态内部类，经由过程和一般的内部类对比来加深对静态内部类的明白：
为什么要用内部类？
1. 内部类平常只为其外部类运用；【供外部类运用说的很好 举例 hashmap鸠合中 有一个内部类 Entry 就是转为 hashmap 存储来运用】
2. 内部类供应了某种进入外部类的窗户，内部类存在外部类的援用，所以内部类可以直接接见外部类的属性；
3. 也是最吸引人的缘由，每一个内部类都能独登时继续一个接口，而不管外部类是不是已继续了某个接口。因而，内部类使多重继续的解决方案变得越发完整。
定义在一个类内部的类叫内部类，包含内部类的类称为外部类。内部类可以声明public、protected、private等接见限制，可以声明 为abstract的供其他内部类或外部类继续与扩大，或许声明为static、final的，也可以完成特定的接口。
外部类按通例的类接见体式格局（以对象的体式格局）运用内部 类，唯一的差别是外部类可以接见内部类的一切要领与属性，包含私有要领与属性，外部类接见内部类，须要建立对象接见；有一点须要注重，内部类不能接见外部类地点的局部变量，只能接见final润饰的局部变量。
在要领内定义内部类时，假如内部类挪用了要领中的变量，那末该变量必需申明为final范例，百思不得其解，厥后想到应该是生命周期的缘由，由于要领内定义的变量是局部变量，脱离该要领，变量就落空了作用，也就会自动被消弭，而内部类却不会脱离它地点要领就落空作用，它有更广的生命周期。
（1）建立实例
OutClass.InnerClass obj = outClassInstance.new InnerClass(); //注重是外部类实例.new，内部类 AAA.StaticInner in = new AAA.StaticInner();//注重是外部类自身，静态内部类
（2）内部类中的this
内部类中的this与其他类一样是指的自身。建立内部类对象时，它会与制造它的外围对象有了某种联络，因而能接见外围类的一切成员，不需任何特别前提，可明白为内部类链接到外部类。 用外部类建立内部类对象时，此内部类对象会隐秘的捕捉一个指向外部类的援用，因而，可以经由过程这个援用来接见外围类的成员。
（3）外部类接见内部类
内部类相似外部类的属性，因而接见内部类对象时老是须要一个建立好的外部类对象。外部类对象经由过程‘外部类名.this.xxx’的情势接见内部类的属性与要领。如：
System.out.println("Print in inner Outer.index=" + pouter.this.index);
System.out.println("Print in inner Inner.index=" + this.index);
（4）内部类向上转型
内部类也可以和一般类一样具有向上转型的特征。将内部类向上转型为基范例，尤其是接口时，内部类就有了用武之地。假如内部类是private的，只可以被它的外部类问，从而完整隐蔽完成的细节。
（5）要领内的类
要领内建立的类（注重要领中也能定义类），不能加接见润饰符。别的，要领内部的类也不是在挪用要领时才会建立的，它们一样也被事前编译了。
（6）静态内部类
定义静态内部类：在定义内部类的时刻，可以在其前面加上一个权限润饰符static。此时这个内部类就变为了静态内部类。
一般称为嵌套类，当内部类是static时，意味着：
[1]要建立嵌套类的对象，并不须要其外围类的对象；
[2]不能从嵌套类的对象中接见非静态的外围类对象（不可以从静态内部类的对象中接见外部类的非静态成员）；
嵌 套类与一般的内部类另有一个区分：一般内部类的字段与要领，只能放在类的外部条理上，所以一般的内部类不能有static数据和static字段， 也不能包含嵌套类。然则在嵌套类里可以包含一切这些东西。也就是说，在非静态内部类中不可以声明静态成员，只要将某个内部类润饰为静态类，然后才可以在这 个类中定义静态的成员变量与成员要领。
别的，在建立静态内部类时不须要将静态内部类的实例绑定在外部类的实例上。一般非静态内部类的 对象是倚赖在外部类对象当中的，要在一个外部类中定义一个静态的内部类，不须要应用症结字new来建立内部类的实例。静态类和要领只属于类自身，并不属于 该类的对象，更不属于其他外部类的对象。
（7）内部类标识符
每一个类会发作一个.class文件，文件名即为类名。一样，内部类也会发作这么一个.class文件，然则它的称号却不是内部类的类名，而是有着严厉的限制：外围类的名字，加上$,再加上内部类名字。
代码细致：
public class OutClassTest
{
static int a;
int b;
public static void test() {
System.out.println("outer class static function");
}
public static void main(String[] args) {
// new一个外部类
OutClassTest oc1 = new OutClassTest();
// 经由过程外部类的对象new一个非静态的内部类
OutClassTest.InnerClass no_static_inner = oc1.new InnerClass();
// 挪用非静态内部类的要领
System.out.println(no_static_inner.getKey());
// 挪用静态内部类的静态变量
System.out.println(OutClassTest.InnerStaticClass.static_value);
// 不依靠于外部类实例,直接实例化内部静态类
OutClassTest.InnerStaticClass inner = new OutClassTest.InnerStaticClass();
// 挪用静态内部类的非静态要领
System.out.println(inner.getValue());
// 挪用内部静态类的静态要领
System.out.println(OutClassTest.InnerStaticClass.getMessage());
}
private class InnerClass {
// 只要在静态内部类中才可以声明或定义静态成员
// private static String tt = "0";
private int flag = 0;
public InnerClass() {
// 三.非静态内部类的非静态成员可以接见外部类的非静态变量和静态变量
System.out.println("InnerClass create a:" + a);
System.out.println("InnerClass create b:" + b);
System.out.println("InnerClass create flag:" + flag);
//
System.out.println("InnerClass call outer static function");
// 挪用外部类的静态要领
test();
}
public String getKey() {
return "no-static-inner";
}
}
private static class InnerStaticClass {
// 静态内部类可以有静态成员，而非静态内部类则不能有静态成员。
private static String static_value = "0";
private int flag = 0;
public InnerStaticClass() {
System.out.println("InnerClass create a:" + a);
// 静态内部类不可以接见外部类的非静态成员
// System.out.println("InnerClass create b:" + b);
System.out.println("InnerStaticClass flag is " + flag);
System.out.println("InnerStaticClass tt is " + static_value);
}
public int getValue() {
// 静态内部类接见外部类的静态要领
test();
return 1;
}
public static String getMessage() {
return "static-inner";
}
}
public OutClassTest() {
// new一个非静态的内部类
InnerClass ic = new InnerClass();
System.out.println("OuterClass create");
}
}
有就是类名ClassName背面多了个.* ，意义是导入这个类里的静态要领。固然，也可以只导入某个静态要领，只要把 .* 换成静态要领名就好了。然后在这个类中，就可以直接用要领名挪用静态要领，而没必要用ClassName.要领名 的体式格局来挪用。
优点：这类要领的优点就是可以简化一些操纵，比方打印操纵System.out.println(…);就可以将其写入一个静态要领print(…)，在运用时直接print(…)就可以了。然则这类要领发起在有很多反复挪用的时刻运用，假如唯一一到两次挪用，不如直接写来的轻易
example：
在Java 5中，import语句得到了加强，以便供应以至越发壮大的削减击键次数功用，虽然一些人争议说这是以可读性为价值的。这类新的特征成为静态导入。当你想运用static成员时，可以运用静态导入（在API中的类和你本身的类上，都可以运用该特征）。下面是静态导入前后的代码实例：
在静态导入之前：
public class TestStatic {
public static void main(String[] args) {
System.out.println(Integer.MAX_VALUE);
System.out.println(Integer.toHexString(42));
}
}
在静态导入以后：
import static java.lang.System.out;
import static java.lang.Integer.*;
public class TestStaticImport {
public static void main(String[] args) {
out.println(MAX_VALUE);
out.println(toHexString(42));
}
}
让我们看一下运用静态导入特征的代码中将发作什么：
1、虽然该特征一般称为“静态导入”，但语法必需是import static，背面跟你想导入的static成员的完整限制称号，或许通配符。在本例中，我们在System类的out对象上举行静态导入。
2、在本例中，我们可以想运用java.lang.Integer类的几个static成员。该静态导入语句运用通配符来表达“我想在此类中的一切静态成员上举行静态导入”。
3、如今我们终究看到静态导入特征的优点！我们没必要在System.out.println中键入System。太好了！别的，我们没必要在Integer.MAX_VALUE中键入Integer。因而，在这行代码中，我们可以将快速体式格局用于静态要领和一个常量。
4、末了，我们举行更多的快速操纵，此次针对Integer类的要领。
关于该特征，我们已有点儿嗤笑意味儿了，但不仅我们是如许的。我们不认为节约少许的击键次数会让代码难于浏览一点，但很多开发人员请求将它添加到语言中。
下面是运用静态导入的几条准绳：
你必需说import static， 不能说static import。
防范含糊不清的定名static成员。比方，假如你对Integer类和Long类实行了静态导入，援用MAX_VALUE将致使一个编译器毛病，由于Integer和Long都有一个MAX_VALUE常量，而且Java不会晓得你在援用哪一个MAX_VALUE。
你可以在static对象援用、常量（记着，它们是static 或final）和static要领上举行静态导入。
浩瀚java培训视频，尽在ki4网，迎接在线进修！
以上就是java static是什么的细致内容，更多请关注ki4网别的相干文章！
