Java中static关键字的作用

Java中static关键字的作用
(1)为特定的数据类型或对象分配单一的存储空间.
(2)实现某个方法或属性与关联在一起.
使用:
(1)static成员变量
属于类的变量,只要static变量所属类被加载,变量就会被分配空间.
引用方式:类.静态变量;对象.静态变量.

(2)static成员方法
I.static方法是类的方法,不需要创建对象就可以被调用,而非static方法是对象的方法,只有对象被创建出来后才可以被使用.
II.static方法中不能使用this和super关键字,不能调用非static方法,只能访问所属类的静态成员变量和成员方法.因为当static方法被调用时,
这个类的对象可能还没被创建,即使已经被创建了,也无法确定调用哪个对象的方法.同理,static方法也不能访问非static类型的变量.

static一个很重要的用途就是实现单例设计模式.单利模式的特点是该类只能有一个实例,为了实现这一功能，必须隐藏类的构造函数,
即把构造函数声明为private,并提供一个创建对象的方法,由于构造对象被声明为private,外界无法直接创建这个类型的对象,
只能通过该类提供的方法来获取类的对象,要达到这样的目的只能把创建对象的方法声明为static.
程序实例如下:

public class Singleton {  
    private Singleton() {}                     //关键点0：构造函数是私有的
    private static Singleton single = null;    //关键点1：声明单例对象是静态的
    private static object obj= new object();
    public static Singleton GetInstance()      //通过静态方法来构造对象
    {                        
         if (single == null)                   //关键点2：判断单例对象是否已经被构造
         {                            
            lock(obj)                          //关键点3：加线程锁
            {
               if(single == null)              //关键点4：二次判断单例是否已经被构造
               {
                  single = new Singleton();  
                }
             }
         }    
        return single;  
    }  
}

(3)static块
在类中独立于成员变量和成员函数的代码块的。static代码块只会被执行一次.

(4)static和final结合使用:
变量:使用 static + final 修饰,赋值后不能修改,通过类名访问.
方法:使用 static + final 修饰,该方法不能被覆盖,通过类名访问.

注意:Java中,不能在成员函数内部定义static变量.

(5)static内部类
I.内部静态类不需要有指向外部类的引用。但非静态内部类需要持有对外部类的引用。
II.非静态内部类能够访问外部类的静态和非静态成员。静态类不能访问外部类的非静态成员。他只能访问外部类的静态成员。
III.非静态内部类不能脱离外部类实体被创建，非静态内部类可以访问外部类的数据和方法。

示例代码:

public class OuterClass {
    private static String msg = "GeeksForGeeks";
        // 静态内部类
        public static class NestedStaticClass{
         // 静态内部类只能访问外部类的静态成员
        public void printMessage() {
        // 试着将msg改成非静态的，这将导致编译错误
            System.out.println("Message from nested static class: " + msg);
        }
    }
        // 非静态内部类
        public class InnerClass{
            // 不管是静态方法还是非静态方法都可以在非静态内部类中访问
            public void display(){
                System.out.println("Message from non-static nested class: "+ msg);
            }
        }
}
class Main
{
        // 怎么创建静态内部类和非静态内部类的实例
        public static void main(String args[]){


        // 创建静态内部类的实例
        OuterClass.NestedStaticClass printer = new OuterClass.NestedStaticClass();
        // 创建静态内部类的非静态方法
        printer.printMessage();


        // 为了创建非静态内部类，我们需要外部类的实例
        OuterClass outer = new OuterClass();
        OuterClass.InnerClass inner = outer.new InnerClass();
        // 调用非静态内部类的非静态方法
        inner.display();


        // 我们也可以结合以上步骤，一步创建的内部类实例
        OuterClass.InnerClass innerObject = new OuterClass().new InnerClass();
        // 同样我们现在可以调用内部类方法
        innerObject.display();
    }
}

(6)静态导包
Java包的静态导入，用import static代替import静态导入包是JDK1.5中的新特性。
一般我们导入一个类都用 import com…..ClassName;而静态导入是这样：import static com…..ClassName.*;这里的多了个static，还有就是类名ClassName后面多了 个.* ，意思是导入这个类里的静态方法。当然，也可以只导入某个静态方法，只要把 .* 换成静态方法名就行了。然后在这个类中，就可以直接用方法名调用静态方法，

而不必用ClassName.方法名的方式来调用。

好处：这种方法的好处就是可以简化一些操作，例如打印操作System.out.println(…);就可以将其写入一个静态方法print(…)，在使用时直接print(…)就可以了。
但是这种方法建议在有很多重复调用的时候使用，如果仅有一到两次调用，不如直接写来的方便.

example:
在Java 5中，import语句得到了增强，以便提供甚至更加强大的减少击键次数功能，虽然一些人争议说这是以可读性为代价的。
这种新的特性成为静态导入。当你想使用static成员时，可以使用静态导入（在API中的类和你自己的类上，都可以使用该特性）。
下面是静态导入前后的代码实例：

在静态导入之前：

public class Singleton {
    public static void main(String [] args){
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.toHexString(36));
    }
}

在静态导入之后：

import static java.lang.System.out;
import static java.lang.Integer.*;

public class Singleton {
    public static void main(String [] args){
        out.println(MAX_VALUE);
        out.println(Integer.toHexString(36));
    }
}

两个类都产生相同的输出：
2147483647
24

使用静态导入特性的代码中将发生什么：
1、虽然该特性通常称为“静态导入”，但语法必须是import static，后面跟你想导入的static成员的完全限
定名称，或者通配符。在本例中，我们在System类的out对象上进行静态导入。

2、在本例中，我们可能想使用java.lang.Integer类的几个static成员。该静态导入语句使用通配符来表达“
我想在此类中的所有静态成员上进行静态导入”。

3、现在我们终于看到静态导入特性的好处！我们不必在System.out.println中键入System。太好了！另外，
我们不必在Integer.MAX_VALUE中键入Integer。因此，在这行代码中，我们能够将快捷方式用于静态方法和一个常量。

4、最后，我们进行更多的快捷操作，这次针对Integer类的方法。
关于该特性，我们已经有点儿讽刺意味儿了，但不仅我们是这样的。我们不认为节省少量的击键次数会让代码
难于阅读一点，但许多开发人员要求将它添加到语言中。

下面是使用静态导入的几条原则：
1)你必须说import static,不能说static import。
2)提防含糊不清的命名static成员。例如，如果你对Integer类和Long类执行了静态导入，引用MAX_VALUE将导致
3)一个编译器错误，因为Integer和Long都有一个MAX_VALUE常量，并且Java不会知道你在引用哪个MAX_VALUE。
4)你可以在static对象引用、常量（记住，它们是static 或final）和static方法上进行静态导入。