• 前言

       在Java中声明类的成员变量和方法时，可以使用static关键字把成员声明为静态成员。静态变量也叫类变量，非静态变量也叫实例变量；静态方法也叫类方法，非静态方法也叫实例方法。静态成员最主要的特点是它不属于任何一个类的对象，它不保存在任意一个对象的内存空间中，而是保存在类的公共区域中，所以任何一个对象都可以直接访问该类的静态成员，都能获得相同的数据值，修改时，也在类的公共区域进行修改。下面将介绍静态成员、包含静态方法、变量和常量，以及一些特殊的静态方法，如main方法和factory方法。

• 静态变量和常量

在Java中没有一个直接的修饰符来实现常量，而是通过静态成员变量的方式来实现的，如下代码：

public static final int x=10;
static public final int y=20;
final static public int z=40;

       static表示属于类，不必创建对象就可以使用，因为常量应该不依赖任何对象，final表示值不能改变。一般用作常量的静态成员访问权限都设置为public，因为常量应该允许所有类或对象访问。

另外需要注意的是，static可以与其他修饰符组合使用，且顺序可以任意调换。

在Java中，静态成员变量的的初始化要求在静态语句块结束之前必须完成，即Java中静态成员变量的初始化时机有两个，在声明的同时进行初始化或在静态语句中初始化。例如：

public class Sample3_14 
{
	public static final int const1=11;
	public static final int const2;
	static //静态语句
	{
		const2=22;
	}
	
	public static void main(String[] args) 
	{
		// TODO Auto-generated method stub
		System.out.print(const1 +" " +const2);
	}

}

• 静态成员的访问

静态成员是属于类的，因此对其访问不需要创建对象，可以使用<类名> . <静态成员名>的语法调用静态成员变量。

1、静态方法访问非静态成员

首先参考以下代码：

public class Sample3_16 
{
	static int staticVar=13;
	public static void main(String[] args) 
	{
		// TODO Auto-generated method stub
		System.out.println("成员变量staticVar的值为："+ staticVar +".");
	}

}

       静态成员的生命周期比非静态的长，即使访问时存在非静态成员，静态方法也不知道访问的是哪一个对象的成员，因为静态方法属于类，非静态方法属于对象，所以静态方法将不知道关于其所属类的对象信息。

       main方法之所以被定义为静态也因为如此，其只是程序开始执行的入口，不需要依赖任何对象，若要在静态方法中访问非静态成员只要使用指定特定对象的引用即可。而静态方法访问访问静态成员时，自然是任何时候都没有问题，静态成员都属于类，只要类关系存在，静态成员都将村在。

       同样的道理，在静态方法中是不能使用this预定义对象的引用的，即使其后边所操作的也是静态成员也是不行，因为this代表指向自己对象的引用，而静态方法是属于类的，不属于对象，其成功加载后，对象还不一定存在，即使存在，也不知道this指向的是哪一个对象。

2、非静态方法访问静态成员

       非静态方法访问静态成员的时候，规则就比较简单，非静态成员的生命周期被静态成员所包含，因此非静态成员存在的时候，静态成员一定存在，故非静态成员任何时候都可以访问静态成员。

public class Sample3_18 
{
	static int s=1000;
	
	//在非静态方法中调用静态成员
	public void showStatic()
	{
		System.out.println("非静态方法getStatic（）成功调用静态成员s，其值为："+Sample3_18.s);
	}
	public static void main(String[] args) 
	{
		// TODO Auto-generated method stub
		Sample3_18 sa=new Sample3_18();
		sa.showStatic();
	}

}

• main() 方法

       main方法是Java程序的入口方法，也就是说，程序在运行的时候，第一个执行的方法就是main方法，这个方法与其他方法有很大不同，比如方法的名字必须是main，方法必须是public static void 类型的，方法必须接收一个字符串数组的参数等等。

        因为main方法是由Java虚拟机调用的，所以必须为public，虚拟机调用main方法不需要产生任何对象，所以main方法声明为static，且不需要返回值，所以声明为void。既然是类，Java允许类不加public关键字作为约束，当然类的定义只能限制为public或者无限制关键字。为什么要这么定义，这和JVM的运行有关。main方法中还有一个输入参数，类型为String[] ，这个也是Java的规范，main方法中必须有一个入参，类型必须为String[] ,至于字符串数组的名字，这个是可以自己设定的，根据习惯，这个字符串数组的名字一般和Sun Java规范范例main的参数名保持一致，取名为args。而main方法不准抛出异常，因此main方法中的异常要么处理要么不处理，不能继续抛出。

        当一个类中由main方法时，则执行命令“Java 类名” 则会启动虚拟机执行该类中的main方法，由于JVM在运行这个Java程序的时候，首先会调用main方法，调用时不实例化这个类的对象，而是通过类名直接调用，因此需要限制其为public static。

• Factory 方法

       Java的静态方法有一种常见的用途，就是使用 Factory方法产生不同风格的对象，例如NumberFormat类使用 Factory方法产生不同风格的格式对象。 Factory Method是最常用的模式了，Factory方法在Java程序系统中可以说是随处可见。Factory方法就相当于创建实例对象的new，我们经常要根据类 Class生成实例对象，如A a= new A( )， Factory Method也是用来创建实例对象的，所以以后new时可以考虑实用工厂模式,虽然这样做，可能多做一些工作，但会给系统带来更大的可扩展性和尽量少的修改量。
下面以类 Sample为例，如果要创建 Sample的实例对象。
Sample sample-new Sample();

       但实际情况是，通常用户都要在创建 sample实例时做初始化的工作，例如赋值、查询数据库等。首先想到的是，可以使用 Sample I的构造函数，这样生成实例就写成:
Sample sample- new Sample(参数)

       但是，如果创建 sample实例时所做的初始化工作不是像赋值这样简单的事，可能是很长一段代码，如果也写入构造函数中，那么代码就很难看了。初始化工作如果是很长一段代码，说明要做的工作很多，将很多工作装入一个方法中，相当于将很多鸡蛋放在一个篮子里，是很危险的，这也是有悖于Jaa面向对象的原则的，面向对象的封装( Encapsulation)和分派( Delegation)告诉我们，尽量将长的代码“切割”成段，将每段再“封装”起来(减少段和段之间耦合性)，这样，就会将风险分散，以后如果需要修改，只要更改每段，不会再发生牵一动百的事情。

        所以，首先需要将创建实例的工作与使用实例的工作分开，也就是说，让创建实例所需要的大量初始化工作从 Sample的构造函数中分离出去。这时就需要使用 Factory方法来生成对象了，不能再用上面的" new Sample(参数) "了。还有，如果 Sample有个继承如 MySample，如按照面向接口编程，则需要将 Sample抽象成一个接口。现在 Sample是接口，有两个子类 MySample和 HisSample，要实例化它们：
（1） Sample mysample=new Mysample();

（2）Sample hissample=new Hissample();

       上面所示的 Sample类可能还会“生出很多儿子出来”(继承)，那么要对这儿子一个个实例化，而且可能还要对以前的代码进行修改，加入到后来生出的儿子的实例中下面是一个简单的 Factory例子：
 

interface Fruit
{
	void plant();//种植
	void grow();//生长
	void harvest();//收割
}

class Apple implements Fruit
{
	private int treeAge;
	public void plant()
	{
		System.out.println("苹果已种植");
	}
	public void grow()
	{
		System.out.println("苹果正在生长中。。。。");
	}
	public void harvest()
	{
		System.out.println("苹果已经收获");
	}
	
	public void setTreeAge(int treeAge)//设置树的年龄
	{
		this.treeAge=treeAge;
	}
}

class AppleGardeber
{
	public static Apple factory()
	{
		Apple f=new Apple();
		System.out.println("水果工厂成功创建一个水果：苹果！");
		return f;
	}
}

public class Sample3_20 
{
	private void test()
	{
		Apple a=AppleGardeber.factory();
	}
	public static void main(String[] args) 
	{
		// TODO Auto-generated method stub
		Sample3_20 test=new Sample3_20();
		test.test();
	}

}

       在上面的例子中，苹果实现了水果接口。苹果的生产由专门的苹果Factory负责，这样，在不涉及苹果的具体子类的情况下，达到了封装效果，也减少了错误；

今日在看《c/c++程序员面试秘笈》时，有如下题，

p173面试题：对静态数据成员的正确描述是：

A.静态数据成员可以在类体内进行初始化

B.静态数据成员不可以被类对象调用

C.静态数据成员不受private控制符作用

D.静态数据成员可以直接用类名调用

这里答案给的是CD，对于C有所疑问，于是写下如下代码进行测试：

#include <iostream>  
#include <conio.h>  
using namespace std;  
  
class test  
{  
public:  
    static int i;  
    test() {}  
    void print();  
private:  
    static int j;  
};  
  
int test::i = 0;  
int test::j = 0;  
  
void test::print()  
{  
    cout << "i = "<< i << endl;//对比参照项1  
    cout << "j = "<< j << endl;//对比参照项2  
}  
  
int main()  
{  
    test t;  
    t.print();  
  
    cout << "i = "<< t.i << endl;//对比参照项3  
    cout << "j = "<< t.j << endl;//测试是否可以不受private作用  
  
        getch();  
    return 0;  
}  

结果是报错

1. cout << "j = "<< t.j << endl;  

于是可知C选项错误，这是这本书上的失误

静态的成员变量与非静态的成员变量的区别：

1. 作用上的区别：
   1） 静态的成员变量的作用是共享一个数据给所有的对象使用。
   2）非静态的成员变量的作用是描述一类事物的公共属性。
2. 数量与存储位置上的区别：
   1）静态成员变量是存储方法 区内存中，而且只会存在一份数据。
   2）非静态的成员变量是存储在堆内存中，有n个对象就有n份数据。
3. 生命周期的区别：
   1）静态的成员变量数据是随着类的加载而存在，随着类文件的消失而消失。
   2）非静态的成员数据是随着对象的创建而存在，随着对象被垃圾回收器回收而消失。