final与static final的区别

1   >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

class SelfCounter{

          private static int counter;
          private int id = counter ++;
          
          public String toString(){
                    return "SelfCounter :" + id;
          }
}

class WithFinalFields{
          static final SelfCounter wffs = new SelfCounter();
          final SelfCounter wff = new SelfCounter();
          
          
          public String toString(){
                    return "wff = " + wff + "\n wffs = " + wffs;
          }
}

public class E18_StaticFinal {
          public static void main(String[] args) {
                    System.out.println("First Object :");
                    System.out.println(new WithFinalFields());
                    System.out.println("Second Object: ");
                    System.out.println(new WithFinalFields());
          }
}
，运行结果是
First Object :
wff = SelfCounter :1
 wffs = SelfCounter :0
Second Object: 
wff = SelfCounter :2
 wffs = SelfCounter :0 ，不太明白为什么两次wffs=SelfCounter:0，

我感觉counter被初始化为0后，id会自增为1，为什么声明为static final的对象后，id就是0?

static的常量在类加载的时候被初始化，而实例常量在实例化的时候被初始化。

其实上面的过程很简单。

第一次实例化WithFinalFields的时候，虚拟机发现该类没有被加载，于是先加载类，加载类的同时需要初始化类的所有static无论是变量、常量还是块，于是wffs需要实例化一个SelfCounter对象，这个时候虚拟机发现SelfCounter类也没有被加载，于是加载SelfCounter类，同时初始化static变量counter为0，加载SelfCounter类完毕，开始实例化SelfCounter对象，初始化id为0（此时counter为0），同时counter变为1，这时SelfCounter对象的实例化完毕，并被赋值给WithFinalFields类的wffs常量，加载WithFinalFields类的过程完毕，开始正式实例化WithFinalFields对象，初始化wff常量，又需要实例化一个SelfCounter对象，这时虚拟机发现SelfCounter类已经被加载，于直接开始实例化SelfCounter对象，初始化id为1（此时counter为1），同时counter变为2，实例化WithFinalFields对象完毕，此时wffs的id为0，wff的id为1。

第二次实例化WithFinalFields的时候，虚拟机发现该类已经被加载，直接实例化，不会初始化static无论是变量、常量还是块，于是直接初始化wff常量，需要实例化SelfCounter对象，该类也已经被加载，于是也直接实例化，初始化id为2（此时counter为2），同时counter变为3，实例化SelfCounter对象完毕，同时实例化WithFinalFields对象完毕，此时wffs的id仍然为0，wff的id为2。

重点是静态的东西只会被初始化一次，发生在类加载的时候。

不太明白，那么fianl不也是不可变的吗
final   SelfCounter   wff   =   new   SelfCounter();

final是不可变，但问题是有两个WithFinalFields对象，每个WithFinalFields对象都有它自己的wff常量，而且对于引用类型的常量，所谓不可变仅仅是引用不能重新指向其他对象，而不是对象内部的各种属性的值不可变。

2 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

    java为什么非静态内部类中不能有static修饰的属性，但却可以有常量？


如：
public class InnerClassDemo{
    int x;
    class A{
        static  int a = 0;//这样写是不合法的.
        static final int b=0;//这样写是合法的

     }
}

为什么呢？

说深入点吧，java类加载顺序，首先加载类，执行static变量初始化，接下来执行对象的创建，如果我们要执行代

码中的变量int a 初始化，那么必须先执行加载外部类，再加载内部类，最后初始化静态变量 a ,问题就出在加载

内部类上面，我们可以把内部类看成外部类的非静态成员，它的初始化必须在外部类对象创建后以后进行，要加载

内部类必须在实例化外部类之后完成 ，java虚拟机要求所有的静态变量必须在对象创建之前完成，这样便产生了

矛盾。
(有点绕，呵呵)
而java常量放在内存中常量池，它的机制与变量是不同的，编译时，加载常量是不需要加载类的，所以就没有上面

那种矛盾。

3 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

    Static和Final修饰类属性变量及初始化

1.static修饰一个属性字段,那么这个属性字段将成为类本身的资源,public修饰为共有的,可以在类的外部通过
test.a来访问此属性;在类内部任何地方可以使用.如果被修饰为private私有,那么只能在类内部使用.
<ccid_nobr>
<ccid_code>public class Test{

       public static int a;

       private Test(){

       a=0;

      }

      }

 如果属性被修饰为static静态类资源,那么这个字段永远只有一个,也就是说不管你new test()多少个类的对象
,操作的永远都只是属于类的那一块内存资源.例如:

<ccid_nobr>
<ccid_code>Test t1=new Test();

     t1.a=10;

     Test t2=new Test();

     System.out.println(t1.a);

     System.out.println(t2.a);

           System.out.println(Test.a);

结果是3个0


2.final 用于声明属性，方法和类，分别表示属性一旦被分配内存空间就必须初始化并且以后不可变，方法一旦定

义必须有实现代码并且子类里不可被覆盖，类一旦定义不能被定义为抽象类或是接口,因为不可被继承。而你的代

码里对final修饰的属性进行了修改,所以错误.

(这里举一个项目的例子：

public abstract class ManagedServiceSettings extends SettingsPreferenceFragment {
    
    
// private static final  Config mConfig;
    private static Config mConfig;
    private static Context mContext;
    private PackageManager mPM;
    private static ServiceListing mServiceListing;
    private TextView mEmpty;

    abstract protected Config getConfig();

    public ManagedServiceSettings() {
        mConfig = getConfig();
    }

当我开始写成private static final  Config mConfig; 编译出错，这时因为final声明属性表示属性一旦被分配内存空间就必须初始化并且以后不可变，但final前又有static表明在类加载时就初始化了，而构造函数是在当类被实例化的时候才会执行，所以这里会报错


)

3. 被final修饰而没有被static修饰的类的属性变量只能在两种情况下初始化:

a.在它被定义的时候,例:

<ccid_nobr>

<ccid_code>public class Test{

         public final int a=0;

         private Test(){

         }

            }

b.

在构造函数里初始化,例:

<ccid_nobr>

<ccid_code>public class Test{

         public final int a;

         private Test(){

             a=0;

         }

            }


4.同时被final和static修饰的类的属性变量只能在两种情况下初始化:

a.在它被定义的时候,例:

<ccid_nobr>

<ccid_code>public class Test{

         public final int a=0;

         private Test(){

         }

            }

 
b.在类的静态块里初始化,例:

<ccid_nobr>

<ccid_code>public class Test{

         public final int a;

         static{

             a=0;

         }

            }

5.分析第三第四原因:

第三条:当这个属性被修饰为final,而非static的时候,它属于类的实例对象的资源,当类被加载进内存的时候这个

属性并没有给其分配内存空间,而只是定义了一个变量a,只有当类被实例化的时候这个属性才被分配内存空间,而实

例化的时候同时执行了构造函数,所以属性被初始化了,也就符合了当它被分配内存空间的时候就需要初始化,以后

不再改变的条件.


第四条:当类的属性被同时被修饰为static和final的时候，他属于类的资源,那么就是类在被加载进内存的时候(也

就是应用程序启动的时候)就要已经为此属性分配了内存,所以此时属性已经存在,它又被final修饰,所以必须在属

性定义了以后就给其初始化值.而构造函数是在当类被实例化的时候才会执行,所以用构造函数,这时候这个属性没

有被初始化.程序就会报错.而static块是类被加载的时候执行,且只执行这一次,所以在static块中可以被初始化.