JAVA类成员

static 关键字修饰的成员就是类成员，前面已经介绍的类成员有类属性、类方法、静态初始化块等三个成分，static关键字不能修饰构造器。

static修饰的类成员属于整个类，不是属于单个实例的。

在JA V A类里只能包含属性，方法，构造器，初始化块，内部类和枚举类等六种成员，也包含了接口，目前已经介绍了前面四种，其中static可以修饰属性，方法，初始化块，内部类和枚举类，以static修饰的成员就是类成员，类成员属于整个类，而不是属于单个对象。

我们要知道，当系统第一次准备使用该类时，系统会为该类属性分配内存空间，类属性开始生效，直到该类被卸载，该类的类属性怕占有的内存才被系统的垃圾回收机制回收。

类属性生存范围几乎等同于该类的生存范围，当类初始化完成后，类属性也被初始化完成。

类属性既可通过类来访问，也可通过类的对象来访问。

但通过类的对象来访问类属性时，实际上并不是访问该对象所具有的属性。

当通过对象来访问类属性时，系统会在底层转换让为通过该类来访问类属性。

由于所有对象实际上并不保持类属性，类属性是由该类来保持的，同一个类的所有对象访问类属性时，实际上访问的是该类所持有的属性。

因此从程序运行表面上来看，即可看到同一类的所有实例的类属性共享同一块内存区。

类方法也是类成员的一种，类方法也是属于类的，通常直接使用类作为调用类方法，但也可以使用对象来调用类方法。

与类属性类似的，即使使用对象来调用类方法，其效果与采用类来调用类方法完全一样。

当使用实例来访问类成员时，实际依然委托给该类来访问类成员，因此即使某个实例为Null它也可以访问它所属类的类成员。

本来是不想写太多的概念性的东西的，但为了大家能更好的理解写出来的代码，所以还是麻烦下自已写出来。

看代码：
public class NullAccessStatic
{
private static void test()
{
System.out.println("static修饰的类方法");
}
//主方法入口
public static void main(String[] args)
{
//定义一个NullAccessStatic变量，其值为：null
NullAccessStatic nas = null;
//null对象调用所属类的静态方法
nas.test();
}
}
编译结果：
从编译结果来看，一切正常，这表明null对象可以访问它所属类的类成员
如果一个null对象访问实例成员（属性和方法），将会引发NullPointerException异常，因为null表明该实例根本不存在，既然实例不存在，理所当然的，那么它的属性和方法也不存在。

静态初始化块也是类成员的一种，静态初始化块用于执行类初始化动作，在类的初始化阶段，系统会调用该类的静态初始化块来对类进行初始化。

一旦该类初始化结束后，静态初始化块将永远不会获得执行的机会。

对于static 关键字而言，有一条非常重要的规则：类成员（包括方法，初始化块，内部类和枚举类）不能访问实例成员（包括属性，方法，初始化块，内部类和枚举类）。

因为类成员是属于类的，类成员的作用域比实例成员的作用域更大。

完全可能出现类成员已经初始化完成，但实例成员还不曾初始化，如果允许类成员访问实例成员将会引起大量错误。

单例（Singleton）类
大部分时候，我们把类的构造器定义成public访问权限，允许任何类自由创建该类的对象。

但在某此时候，允许其他类自由创建该类的对象没有任何意义，还可能造成系统性能下降（因为创建一个对象的系统开销问题）。

例如系统可能只有一个窗口管理器，一个假脱机打印设备或一个数据库引擎访问点，此时如果在系统中为这些类创建多个对象就没有太大的实际意义。

如果一个类始终只能创建一个实例，则这个类被称为单例类。

总之，在一些特殊场景下，要求不允许自由创建该类的对象，而是只允许为该类创建一个对象，为了避免其他类自由创建该类的实例，我们把该类的构造器使用private修饰，从而把该类的所有构造器隐藏起来。

根据良好封装的原则：一旦把该类的构造器隐藏起来，则需要提供一个public方法作为该类的访问点，用于创建该类的对象，且该方法必须使用static修饰（因为调用该方法之前还不存在对象，因此调用该方法的不可能是对象，只能是类）。

除此之外，该类还必须缓存已经创建的对象，否则该类无法知道是否曾经创建过对象，也就无法保证只创建一个对象。

为此该类需要使用一个属性来保存曾经创建的对象，因为该属性需要被上面的静态方法访问，故该属性必须使用static修饰。

看代码：
class Singleton
{
//使用一个变量来缓存曾经创建的实例
private static Singleton instance;
//将构造器使用private 修饰，隐藏该构造器
private Singleton()
{
}
//提供一个静态方法，用于返回Singleton实例
//该方法可以加入自定义的控制，保证只产生一个Singleton对象
public static Singleton getInstance()
{
//如果instance为null，表明还不曾经创建Singleton对象
//如果instance不为null,则表明已经创建了Singleton对象，将不会执行该方法
if(instance == null)
{
//创建一个Singleton对象，并将其缓存起来
instance = new Singleton();
}
return instance;
}
}
public class TestSingleton
{
public static void main(String[] args)
{
//创建Singleton对象不能通过构造器，只能通过getInstance方法
Singleton s1 = Singleton.getInstance();
Singleton s2 = Singleton.getInstance();
//将输出true
System.out.println(s1== s2);
}
}
看下编译结果：
正是通过上面getInstance 方法提供的自定义控制（这也是封装的优势：不允许自由访问类的属性和实现细节，而是通过方法来控制合适暴露），保证Singleton类只能产生一个实例，所以在TestSingleton类的main方法中看到两冷饮产生的Singleton对象实际上是同一个对象。

可以看出单例模式有以下特点：
》单例类只可有一个实例。

》单例类必须自己创建自己这惟一的实例
》单例类必须给所有其他对象提供这一实例
单例模式的特点主要表现在单例类如何将自己袖珍化上。

饿汉式单例类
饿汉式单例类是在JA V A语言里实现得最为简便的单例类。

public class EagerSingleton
{
private static final EagerSingleton m_instance = new EagerSingleton();
//定义私有构造器
private EagerSingleton()
{
}
//主方法入口
public static EagerSingleton getInstacnce()
{
return m_instance
}
}
这时我们知道使用单例模式有一个很重要的必要条件：
在一个系统要求一个类只有一个实例时才应当使用单例模式。

反过来说，如果一个类可以有几个实例共存，那么就没有必要使用单例类。