java中的修饰符static,final和abstract

一、static 关键字          可以修饰：          1.属性 --> 被static关键字修饰的属性叫类变量，是全类共有的，可直接用类名访问。                     初始化类变量是在类加载是完成。                类加载：当虚拟机JVM第一次使用一个类时，会通过classpath找到这个类所对应的                        字节码文件，将这个文件中包含的类信息全读入JVM并保存起来，使下次再用                        这个类时就不需要再去加载，一个类只加载一次。                  2.方法 --> 被static关键字修饰的方法叫静态方法，可直接用类名访问。                             静态方法的特点：                            （1）静态方法只能访问类的静态成员（静态属性和静态方法）                            （2）静态方法只能被子类中的静态方法覆盖，并且没有多态                     例子：A a=new B(); A类是B类的父类                           A中有m()方法，B中也有m()方法，则a.m()调用的是B中的m()方法；                           如果A、B中的m()方法都是静态方法，则a.m()调用的是A中的m()方法                   3.静态代码块                      在类加载时运行一次 二、final关键字          可以修饰：          1.变量 --> 被final修饰的变量成为常量，一旦赋值，不能被修改。          2.方法 --> 如果一个方法被final修饰，说明该方法不能被子类覆盖           3.类 -->   如果一个类被final修饰，说明该类不能被继承 三、abstract 抽象的         可以修饰：          1.类 --> 不能创建对象，但可以声明对象的引用           2.方法 --> 只有定义，没有实现               （1）如果一个类中有抽象方法，则这个类必须是抽象类               （2）子类继承一个抽象类，如果子类不希望也成为抽象类，                    就必须实现父类中所有的抽象方法               （3）抽象类中有构造方法

*************************************************************************************************************

总结起来，能放修饰符的地方有4个（更高级的内部类就先不谈了）：
1）类名或接口名前  2）类的成员变量前  3）类的成员方法前 4）方法内的局部变量前

你先搞清楚这四个位置吧：
public  /* 1 */ class Test1 {
public /* 2 */ int  instanceVariable;
public /* 3 */ void  method( ) {
int  /* 4 */  localVariable;
...
}
}

常见的会用就可以了，重要在于理解含义。

final可以用于类名前，表示类不可被继承；final用于变量前，表示它是只能一次赋值的变量，如果初始化了那就是常量。
static可用于类内部的变量或方法前，表示这是整个类共享的变量和方法，与类对象无关。
abstract用于类名前表示一个抽象类，abstract用于成员方法前表示抽象方法，而抽象类内部至少要有一个抽象方法，这个跟final不能一起用，至于为什么，你一想就清楚了，抽象类本身必须有子类需要实现它的方法，但是final类又不能有子类，这不矛盾了么，所以不能一起用。

static final 用于修饰类的静态变量时表示一个常数，其实更多的还是用在接口里，毕竟用在类里面可能会被子类隐藏。

**********************************************************************************************************

final 是老婆，独享的，这对象和引用就占起来，不能在把这个引用给别人了。
static是某个情人，这意味着他还是其他人的情人，所以这叫公共情人。一旦某个类有一个static了，那就意味着这个变量被这个类所有对象共用。
abstract 是小姐，很悲惨，只有到了做的时候你才知道是谁。而且很可能下一次可能又换人了。

你可以把你的老婆当做共同情人，所以final static 是可以一起的，但是你不能把天下的小姐都当做事你老婆，这是不合法的，所以final 和 abstract 是不能在一起的。如果你把static，abstract放一起就是你光顾某个小姐，那么其他人必须也要去找她，这也是不可能的所以这两个也是不能放一起的。

********************************************************************************************************************************

一、static 表示静态，它可以修饰属性，方法和代码块。

1.static修饰静态属性（类变量），那么这个属性就可以用 类名.属性名 来访问，也就是使这个属性成为本类的类变量，为本类对象所共有。这个属性就是全类公有。（共有的类变量与对象无关，只和类有关）。

类加载：虚拟机通过I/O流把一个类的信息从字节码文件中读入虚拟机并保存起来。
一个类只会加载一次。

类变量，会在加载时自动初始化，初始化规则和实例变量相同。

注意：类中的实例变量是在创建对象时被初始化的，被static修饰的属性，也就是类变量，是在类加载时被创建并进行初始化，类加载的过程是进行一次。也就是类变量只会被创建一次。

2.static修饰方法（静态方法），会使这个方法成为整个类所公有的方法，可以用 类名.方法名 访问。

注意：static修饰的方法，不直接能访问（可以通过组合方式访问）本类中的非静态(static)成员（包括方法和属性），本类的非静态（static）方法可以访问本类的静态成员（包括方法和属性），可以调用静态方法。静态方法要慎重使用。在静态方法中不能出现this关键字，因为这是针对对象而言的。

注意：父类中是静态方法，子类中不能覆盖为非静态方法，在符合覆盖规则的前提下，在父子类中，父类中的静态方法可以被子类中的静态方法覆盖，但是没有多态。使用引用调静态方法，相当于使用引用的类型去调用静态方法。（在使用对象调用静态方法是其实是调用编译时类型的静态方法）

注意：父子类中，静态方法只能被静态方法覆盖，父子类中，非静态方法只能被非静态方法覆盖。

java中的main方法必须写成static的因为，在类加载时无法创建对象，因为静态方法可以不通过对象调用。所以在类的main方法。所在在类加载时就可以通过main方法入口来运行程序。

3.static修饰初始代码块，这时这个初始代码块就叫做静态初始代码块，这个代码块只在类加载时被执行一次。可以用静态初始代码块初始化一个类。
静态初始代码块：在类加载时运行    static{……}  只被运行一次，往往用作一个类的准备工作。
动态初始代码块：在初始化属性之前调用初始化代码块 {……}。二、final修饰符，可以修饰变量，方法，类
1.final修饰变量
   被fianl修饰的变量就是常量（常量名大写），一旦赋值不能改变   
   修饰局部变量：修饰基本数据类型 -> 变量的值不能改变
                 修饰引用 -> 引用只能指向固定的对象
   修饰实例变量：默认值不生效，可以再赋值
                 有两次赋值机会：初始化变量的时候 final int a = 20;  对于直接在初始化时赋值，final修饰符常和static修饰符一起使用，避免浪费空间
                                 构造方法中设置  this.a = a;
                                 但是不能同时使用这两种方法                                                                 
                 在一个对象完成创建的时候，对象中的所有final属性必须都完成赋值
   类变量可以是final的，也有两次赋值机会 ：定义变量的时候就赋值 ； 静态初始代码块中    
 
 2、final修饰方法                 
    被final修饰的方法将不能被其子类覆盖，从面向对象的角度理解，可以保持操作的稳定性。
   
 3、final修饰类
    被final修饰的类将不能被继承。在树状单继承关系中，final类是树叶节点。final类中的方法也都是final的。
    
  注意：final，不能用来修饰构造方法。
        在父类中如果有常量属性，在子类中使用常量属性时是不会进行父类的类加载。
        静态常量如果其值可以确定，就不会加载该类，如果不能确定则会加载该常量所在的类。   
        class Super{
           private final void m(){}   //用final可以证明出private的方法不继承给子类
        } 
        class Sub extends Super{
           public void m(){}  //不是方法的覆盖
        }        
        
三、abstract（抽象）修饰符，可以修饰类和方法        
  
 1、修饰类 ->  抽象类
    不能创建对象，可以声明引用，并通过引用调用类中的方法
    主要用于被子类继承的，可以用父类引用指向子类对象
    
 2、修饰方法
    只有声明，没有实现，用“；”代替“{ }”    
    需要子类继承实现（覆盖）。
    
    如果一个类中有抽象方法，那么这个类必须是抽象类。
    抽象类中不一定有抽象方法
      
    注意：父类是抽象类，其中有抽象方法，子类继承父类，必须把父类中的所有抽象方法都实现（覆盖）了，子类才有创建对象的能力，
          否则子类也必须是抽象类。
          抽象类中可以有构造方法，是子类在构造子类对象时需要调用的父类（抽象类）的构造方法。
          
   抽象类的合理性：
      没有抽象类的实例，只有抽象类子类的实例
      抽象方法，定义和实现分离    
      
      抽象（abstract）方法代表了某种标准，定义标准，定义功能，在子类中去实现功能（子类继承了父类并需要给出从父类继承的抽象方法的实现）。
      方法一时间想不到怎么被实现，或有意要子类去实现而定义某种标准，这个方法可以被定义为抽象。(abstract)  
      
四、三个修饰符都能修饰方法（不包含构造方法）
 1、构造方法在创建对象的时候使用，如果是static，那么只会在加载类的时候调用一次
   构造方法不能被继承（final），谈不到覆盖，更不会由子类实现（abstract）
 2、final和abstract，private和abstract，static和abstract，这些是不能放在一起的修饰符
   因为abstract修饰的方法是必须在其子类中实现（覆盖），才能以多态方式调用，以上修饰符在修饰方法时子类都覆盖不了这个方法。
   final是不可以覆盖，private是不能够继承到子类，所以也就不能覆盖。
   static是可以覆盖的，但是在调用时会调用编译时类型的方法（引用类型的方法），因为调用的是父类的方法，而父类的方法又是抽象的方法，不能调用。
   所以以上的修饰符不能放在一起。