Java基础-学习笔记（九）——static关键字

1、静态成员变量

程序中的类，只是在描述其对象的属性和成员，并没有产生实际对象，只有通过new关键字才能产生出对象，这时系统才会分配内存空间给对象，其方法才能供外部调用。

每生成一个对象，都会在内存中给它分配一个单独的空间，有时候我们希望无论产生多少对象，某些某些特定的数据在内存空间里只有一份，我们只需要在这种数据面前加上statice关键字即可。静态变量在某种程度下与其他语言中的全局变量比较类似。并且，我们可以不需要产生实例对象，直接使用类名来调用，如下代码所示

class Chinese
{
    static String country="中国";
    String name;
    int age;
    void SingOurCountry()
    {
        System.out.println("啊！，亲爱的"+country);
    }
    
}
class TestChinese
{
    public static void main(String [] args)
    {
        System.out.println("China is "+Chinese.country);
        Chinese ch=new Chinese();
        ch.SingOurCountry();
    }
}
/*
China is 中国
啊！，亲爱的中国*/

2、静态方法

有时候不希望创建对象来调用方法，也就是说不想让方法与对象绑定在一起，要达到这样的目的，我们需要在类定义的方法前加上static关键字，可将此类方法称为静态成员方法。同静态成员变量一样，它也可以由类直接调用，也可以创建对象来调用。

class Chinese
{
    String name;
    int age=5;
    static void SingOurCountry()
    {
        //System.out.println("my age is "+age);
        System.out.println("啊，亲爱的祖国!");
    }
    void Sing()//同类中的非静态方法可以调用静态方法
    {
        Chinese.SingOurCountry();
    }
}
class TestChinese
{
    public static void main(String [] args)
    {
        Chinese.SingOurCountry();
        Chinese ch=new Chinese();
        ch.SingOurCountry();
        ch.Sing();
    }
}
/*

F:java_example>java TestChinese
啊，亲爱的祖国!
啊，亲爱的祖国!
啊，亲爱的祖国!*/

注意事项：

1）静态成员方法中不能访问类中其他的非静态变量或非静态成员方法。因为此时都没有创建对象，非静态成员变量和非静态成员方法都没有分配空间，他们是不存在的；

2）静态方法中不能以任何方式引用this和super关键字。同上理，由于没有创建对象，所以也不知道this所指向的对象是哪个；

3）由于main()就是一个静态的方法，所以他不能访问类中的非静态成员，需要新建实例对象之后，才能引用。

3、静态代码块

一个类可以使用不包含在任何方法中的静态代码块(static block)，当类被载入时，静态代码块就被执行，且被执行一次，静态代码块常用来进行类属性的初始化。

class StaticCode
{
    static int age;
    static
    {
        age=23;
        System.out.println("StaticCode is loading...");
    }
}
class TestStaticCode
{
    static 
    {
        System.out.println("TestStaticCode is loading...");
        
    }
    public static void main(String [] args)
    {
        System.out.println("begain executing main method...");
        new StaticCode();
        new StaticCode();
    }
}
/*
F:java_example>java TestStaticCode
TestStaticCode is loading...
begain executing main method...
StaticCode is loading...*/

以上代码，就充分说明了，static block是在加载类的时候运行，且只执行一次。

4、单态设计模式

单态也就是说类只创建一个实例对象

class StaticCode
{
    private StaticCode()
    {};
    static StaticCode obj = new StaticCode();
    public static StaticCode getObj()
    {
        return obj;
    }
}
class TestStaticCode
{
    public static void main(String [] args)
    {
        StaticCode obj1=StaticCode.getObj();
        StaticCode obj2=StaticCode.getObj();
        if(obj1==obj2)
            System.out.println("only one instance~");
    }
}
/*
F:java_example>java TestStaticCode
only one instance~*/

首先，我们要限制程序中该类只产生一个对象，我们知道对象是通过构造函数产生的，那我们就从这里入手，限制构造函数，不让外部调用我们的构造函数，那就需要将它用private进行修饰；

再是，我们说了，只能有一个对象，那我们既然不能在外面调用构造函数，那就得在类内部产生一个对象，并提供方法，让外部程序来进行访问；

还有，外部没有对象，怎么能调用我们的方法来获取这唯一的对象实例呢？那我们顺其自然的就想到了，将这个方法变成静态方法，不用外部创建对象就可以使用；

最后，为什么要在创建对象实例时加一个static呢？如果不加的话，我们静态方法中使用的obj，它是非静态成员，无法进行访问使用。