static 与 final 修饰符

A) 用static(静态)修饰属性：一个类生成了N个对象，这些对象会共同使用一份静态的成员变量。一个对象对这个成员变量进行修改，其他对象的该成员变量的值也会随之变化。

B) 我们可以通过 类名.成员变量名  来调用这个静态成员变量。

C)static修饰方法： static修饰的方法叫静态犯法。 可以使用 类名.方法名 来调用。

D)静态方法只能继承，不能重写。(子类的静态方法不能覆盖父类的方法，父类的静态方法不能覆盖子类的方法，想要继承，必须都为静态方法)

例：

 public class Animal
 {
          public static void testMethod()
           {
                System.out.println("The class method in Animal.");
           }

            public void testInstanceMethod()
            {
                 System.out.println("The instance method in Animal.");
            }

 }

 public class Cat extends Animal
 {
          public static void testMethod()
           {
                System.out.println("The class method in Cat.");
           }

            public void testInstanceMethod()
            {
                 System.out.println("The instance method in Cat.");
            }

         public static void main (String[] args)
       {
          Cat myCat = new Cat();
          Animal myAnimal = myCat;
          Animal.testMethod();
          myAnimal.testInstanceMethod();
        }
 }

输出的结果为：

The instance method in Animal.

The instance method in Cat.

---------------------------------------------
---------------------------------------------

A)final关键字可以修饰属性，方法，类。

B)final修饰类：一个被final修饰的类时一个终态类，不能被继承。

C)final修饰方法： 一个被final修饰的方法时一个终态方法，不能被重写。

D)final修饰属性：当一个属性被final修饰，这个属性的值不能被改写。

E)当final修饰一个原生数据类型，该原生数据类型的值不能发生变化；当final修饰一个引用类型时，表示该引用类型不能指向别的对象了，但是该对象的内容是可以发生变化的。

F)对于final类型的成员变量，一般有两种赋初值的方法：
a. 在声明final类型的成员变量时就为其赋上初值。
b. 在声明时不赋值，但在类的所有构造方法中都为其赋上初值。

G)static代码块：静态代码块。静态代码块的作用也是完成一些初始化工作。首先执行静态代码块，然后执行构造方法。静态代码块在类被加载的时候执行，而构造方法是在生成对象时执行；想要调用某个类来生成对象，首先需要将类加载到Java的虚拟机上（JVM），然后有JNM加载这个类来生成对象。

H)类的静态代码块只会执行一次，在类被加载的时候执行的，因为每个类只会加载一次，所以静态代码块只会被执行一次；而构造方法不同，每次生成一个对象时都会调用类的构造方法，所以new一次就会调用构造方法一次。

I)如果继承体系中既有构造方法也有静态代码块，那么首先执行最顶层的类静态代码块，一直执行到最底层类的静态代码块，然后再去执行最顶层类的构造方法，一直执行到最底层类的构造方法。注意：静态代码块只会执行一次。
例子：

 public class StaticTest
 {
     public static void main(String[] args)
     {
           new R();
           new R();
      }
 }

 class P
 {
        static
         {
              System.out.println("P static block");
          }

        public P()
        {
              System.out.println("P constructor");
         }
 }

 class Q extends P
 {
        static
         {
              System.out.println("Q static block");
          }

        public Q()
        {
              System.out.println("Q constructor");
         }
 }

 class R extends Q
 {
        static
         {
              System.out.println("R static block");
          }

        public R()
        {
              System.out.println("R constructor");
         }
 }

输出的结果为：

P static block

Q static block

R static block

P constructor

Q constructor

R constructor

P constructor

Q constructor

R constructor

J)不能再静态的方法中访问非静态的成员变量；可以在静态方法中访问静态的成员变量。可以在非静态的方法中访问静态的成员变量。

K)不能再静态的方法中使用this关键字

总结：静态的只能访问静态的；非静态的可以访问一切。

L）一个类不能既是final，又是abstract的。因为abstract的主要目的是定义一种约定，让子类去实现这种约定，必然需要被继承。而final修饰后不能不继承，这样是不允许的。