Java Static关键字作用与使用

在日常开发中，static关键字的使用必不可少。

static关键字有四种用法：

1、修饰成员变量和成员方法

2、静态块

3、静态内部类

4、静态导包

下面用代码形式，解释static的用法：

1、修饰成员变量：

•       这是原始未添加static关键字的代码

public class Person {

    private String name;
    private int age;

    public Person (String name,int age){
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public static void main(String[] args) {
        Person person1 = new Person("jimmy",18);
        Person person2 = new Person("Tom",23);
        System.out.println(person1);
        System.out.println(person2);
    }

    /*outPut:
    * Person{name='jimmy', age=18}
    * Person{name='Tom', age=23}
    * */
}

• 添加关键字后：

public class Person {

    private static String name;
    private int age;

    public Person (String name,int age){
        this.name = name;//因为添加了static关键字，这里有个警告
        this.age = age;
    }

    ...此处代码与上面一样，省略
    
    /*outPut:
    * Person{name='Tom', age=18}
    * Person{name='Tom', age=23}
    * */
    

从输出的结果来看，添加关键字后，name属性被类所管理，创建多个Person对象都共享这个name属性。未添加static关键字的时候name属性由对象管理，而添加后由类管理。

    修饰成员方法：

public class Hello {

    public static void sayHello(){
        System.out.println("Hello World");
    }

    public static void main(String[] args){
        Hello.sayHello();
    }
    /*outPut
    * Hello World
    * */
}

修饰成员方法和成员变量的特性在于，可以直接通过类名访问静态方法，类名.静态方法名()；类名.静态变量，实现调用。

2、静态代码块：

public class Hello {

    Person person = new Person("Person成员变量初始化");

    public Hello(String msg){
        System.out.println("我是构造方法");
    }

    static {
        System.out.println("我是静态代码块");
    }

    public static void say(){
        System.out.println("我是静态方法");
    }

    public static void main(String[] args){
        Hello hello = new Hello("msg");
        System.out.println("*********分割线**********");
        Hello hello1 = new Hello("msg1");
    }

    class Person{
        public Person(String name){
            System.out.println("我是"+name);
        }
    }
    /* outPut    
    我是静态代码块 
    我是Person成员变量初始化
    我是构造方法
    *********分割线**********
    我是Person成员变量初始化
    我是构造方法
    */
}

静态代码定义在类中，方法外，代码执行（静态代码---非静态方法---构造方法），而且无论创建多少个该对象，静态代码只会在第一次使用类时执行。

3、静态内部类：

public class Hello {

    private static String name = "jimmy";

    public static class Inner {
        public void Hi(){
            System.out.println("我是静态内部类中的方法");
            System.out.println("我只能访问外部静态变量或静态方法: "+Hello.name);
        }
    }

    public static void main(String[] args){
        Hello.Inner inner = new Hello.Inner();
        inner.Hi();
    }
    
    /* outPut
    我是静态内部类中的方法
    我只能访问外部静态变量或静态方法: jimmy
    */
}

此处可以拓展一个设计模式：单例模式

package hello;

public class SingleTon {

    //类私有的构造方法,避免了使用默认的无参构造方法
    private SingleTon(){}

    //私有的静态内部类只能被本类使用
    private static class SingleTonIntance{
        private static final SingleTon Instance = new SingleTon();
    }

    public static SingleTon getInstance(){
        return SingleTonIntance.Instance;
    }
}

这种方式使得SingleTon类被加载的时候不会立即实例化，而是有需要的时候调用getInstance()实例化

4、静态导包：

     Person类

package hello.person;

public class Person {
    public static void sayHello(){
        System.out.println("Hello World");
    }
}

    Hello类

package hello;

import static hello.person.Person.sayHello;

public class Hello {

    public static void main(String[] args){
        sayHello();
    }

    /* outPut
    Hello World
    */
}

用import static导入包，可以直接用其静态变量和静态方法，而不需要类名。