• 1 final
  • 1.1 final总结
  • 1.2 使用final意义
• 2 static
  • 2.1 static总结
  • 2.2 理解Java的static import静态引入机制
    • 2.2.1 精确导入的方式
    • 2.2.2 按需导入的方式
    • 2.2.3 可以导入的种种东西
    • 2.2.4 导入之间的冲突问题
    • 2.2.5 本地和外来的竞争
    • 2.2.6 Static Import的负面影响
  • 2.3 java静态方法能否被重写

1 final

1.1 final总结

1. final修饰类:表示该类不可继承；
   final不能修饰interface接口
2. final修饰方法:表示该方法不能被子类覆盖(即子类不能重写父类的final方法,可以继承)；
   final不能修饰构造函数
3. final修饰字段属性:表示属性值第一次初始化后不能被修改
   final属性可以直接初始化或在构造函数中初始化，如果属性是直接初始化，则其值不能被其它函数(包括构造函数)修改
4. final修饰函数参数，参数值不能被函数修改
5. final修饰函数中的局部变量，局部变量被第一次初始化后不能被修改

  public void hello() {
 final String name;
        name = "hi";       //ok
        name = "hello";    //error
  }

1.2 使用final意义

使用final的意义：

1. 为方法上锁，防止任何继承类改变它的本来含义和实现。设计程序时，若希望一个方法的行为在继承期间保持不变，而且不可被覆盖或改写，就可以采取这种做法。
2. 提高程序执行的效率，将一个方法设成final后，编译器就可以把对那个方法的所有调用都置入嵌入调用里（内嵌机制）。

2 static

2.1 static总结

1. static修饰成员函数:该成员函数不能使用this对象
   static不能修饰构造函数
   static不能修饰函数参数
   static不能修饰局部成员变量
2. static修饰成员字段
   当类被虚拟机加载时，首先按照字段声明的先后顺序对static成员字段进行初始化
3. static修饰语句块
   当类被虚拟机加载时，按照声明顺序先后初始化static成员字段和static语句块
   static所修饰的方法和字段是只属于类，所有对象共享。
   在static所修饰的函数和语句块中不能使用非static成员字段。
   在Java不能直接定义全局变量，是通过static来实现的
   在Java中没有const，不能直接定义常量，通过static final来实现

2.2 理解Java的static import静态引入机制

J2SE 1.5里引入了Static Import机制，借助这一机制，可以用略掉所在的类或接口名的方式，来使用静态成员。
在Java程序中，是不允许定义独立的函数和常量（当然，准确的说，只是被final修饰、只能赋值一次的变量）的。即使从它们本身的功能来看，完全不需要依附于什么东西，也要找个类或接口作为挂靠单位才行（在类里可以挂靠各种成员，而接口里则只能挂靠常量）。
挂靠的方法，是把它们加上static修饰符，定义为这个类或接口的静态成员。这方面的典型例子是java.lang.Math类——包含了大量的sin、cos这样的函数和PI、E这样的常量。
传统上，在访问这些挂靠了的函数、变量和常量的时候，需要在前面加上它们挂靠单位的名称。如果只是偶尔访问这些东西一下，这样的写法可以工作得很好；但是如果要频繁访问这些成员的话，这样的写法就显得比较罗嗦了。
J2SE 1.5里引入了Static Import机制，借助这一机制，可以用略掉所在的类或接口名的方式，来使用静态成员。
Static Import机制常常被直译成静态导入。但是从含义上看，静态成员导入是更为贴切的译法。不过考虑到静态导入这说法比较简短，估计还是会有强大的生命力。

有一种省去常量前的挂靠单位的变通做法：将所有的常量都定义到一个接口里面，然后让需要这些常量的类实现这个接口（这样的接口有一个专门的名目，叫作Constant Interface）。
这个方法可以工作。但是，因为这样一来，就可以从一个类实现了哪个接口推断出这个类需要使用哪些常量，有会暴露实现细节的问题。

2.2.1 精确导入的方式

精确的导入一个静态成员的方法，是在源文件的开头部分（任何类或接口的定义之前），加上类似这样的声明：
import static 包名.类或接口名.静态成员名;

注意尽管这个机制的名目是叫做Static Import，但是在这里的次序却是正好相反的import static。一经导入之后，在整个源文件的范围内，就可以直接用这个成员的名字来访问它了。

用精确导入的方式，导入sin和PI

//精确的导入Math.sin和Math.PI
import static java.lang.Math.sin;
import static java.lang.Math.PI;

public class StaticImportSampleA {
    public static void main(String[] args) {
        System.out.println(sin(PI/2));//输出“1.0”
    }
}

Java语言并未要求每个类和接口都必须属于某一个包。但是，在J2SE 1.4以后，无论是import语句也好，还是import static语句也好，都要求给一个所在包名出来。换而言之，对于不属于任何包的类和接口，是既不能用import导入它本身，也不能用import static导入它的静态成员的。

2.2.2 按需导入的方式

Static Import机制也支持一种不必逐一指出静态成员名称的导入方式。这时，要采用这样的语法：
import static 包名.类或接口名.*;
注意:这种方式只是指出遇到来历不明的成员时，可以到这个类或接口里来查找，并不是把这个类或接口里的所有静态成员全部导入。

用按需导入的方式，导入sin和PI

声明遇到来历不明的成员时到java.lang.Math中去寻找
import static java.lang.Math.*;

public class StaticImportSampleB {
    public static void main(String[] args) {
        System.out.println(sin(PI/2));//输出“1.0”
    }
}

2.2.3 可以导入的种种东西

使用import static语句，可以导入一个类里的一切被static修饰的东西，包括变量、常量、方法和内类。
变量、常量、方法和内部类都可以导入

package com.example.p3;

public class StaticImportee {
    public static int one = 1;
    public static final int TWO = 2;
    public static int three() {
        return 3;
    }
    public static class Four {
        public int value() {
            return 4;
        }
    }
}
package com.example.p3;
import static com.example.p3.StaticImportee.*;

public class StaticImporter {
    public static void main(String[] args) {
        System.out.println(one);
        System.out.println(TWO);
        System.out.println(three());
        System.out.println(new Four());
    }
}

不受影响的访问控制
Static Import不能突破Java语言中原有的访问控制机制的限制，不过也并不在这方面增加新的约束。原来有权限访问的静态成员，都可以被导入和使用；而原来无权限访问的静态成员，用了这个方法之后也仍然是访问不能。

2.2.4 导入之间的冲突问题

不同的类（接口）可以包括名称相同的静态成员。因此，在进行Static Import的时候，可能会出现两个语句导入同名的静态成员的情况。
在这种时候，J2SE 1.5会这样来加以处理：

• 如果两个语句都是精确导入的形式，或者都是按需导入的形式，那么会造成编译错误。
• 如果一个语句采用精确导入的形式，一个采用按需导入的形式，那么采用精确导入的形式的一个有效。
• 如果两个同名的静态成员一个是属性，而另一个是方法，那么因为使用时的写法有差异，不会造成任何的冲突。

采用精确导入的形式的一个有效

package com.example.p4;
import static com.example.p4.Importee1.name;
import static com.example.p4.Importee1.*;
import static com.example.p4.Importee2.*;
import static com.example.p4.Importee2.pass;

public class Importer {
    public static void main(String[] args) {
        System.out.println(name);//输出“Name1”
        System.out.println(pass);//输出“Pass2”
    }
}
package com.example.p4;

public class Importee1 {
    public static String name = "Name1";
    public static String pass = "Pass1";
}
package com.example.p4;

public class Importee2 {
    public static String name = "Name2";
    public static String pass = "Pass2";
}

2.2.5 本地和外来的竞争

有时候，导入的东西还可能和本地的东西相冲突，这种情况下的处理规则，是本地优先。
本地的优先于外来的

package com.example.p5;
import static com.example.Zero.*;

public class One {
    public static int flag = 1;
    public static void main(String[] args) {
        System.out.println(flag);//输出“1”
    }
}
package com.example.p5;

public class Zero {
    public static int flag = 0;
}

2.2.6 Static Import的负面影响

在编译期间，所有因Static Import的存在而简化了的名字，都会被编译器打回原型。因此在性能方面，Static Import没有任何影响。但是名字简化却可能造成一些维护方面的问题。
去掉静态成员前面的类型名，固然有助于在频繁调用时显得简洁，但是同时也失去了关于这个东西在哪里定义的提示信息，增加了阅读理解的麻烦。如果导入的来源很著名（比如java.lang.Math），或者来源的总数比较少，这个问题并不严重；但是在不属于这两种的情况下，这就不是基本可以忽略的问题了。

2.3 java静态方法能否被重写

JAVA静态方法形式上可以重写，但从本质上来说不是JAVA的重写。因为静态方法只与类相关，不与具体实现相关，声明的是什么类，则引用相应类的静态方法(本来静态无需声明，可以直接引用)，看下例子：

class Base{  
        static void a( ){System.out.println("A");  }  
                 void b( ){System.out.println("B"); }  
}  
public class  Inherit extends Base{  
          static void a( ){System.out.println("C");  }  
                  void b( ){System.out.println("D"); }  
           public static void main(String args[]){  
                    Base b=new Base();  
                    Base  c=new Inherit();  
                    b.a();  
                    b.b();  
                    c.a();  
                    c.b();  
         }  
}  
 
 
以上输出的结果是：A
               B
               A
               D

非静态方法 按重写规则调用相应的类实现方法，而静态方法只与类相关。
所谓静态，就是在运行时，虚拟机已经认定此方法属于哪个类。
专业术语有严格的含义,用语要准确.重写只能适用于实例方法.不能用于静态方法.对于静态方法,只能隐藏(刚才的例子可以重写那只是形式上的 ，并不满足多态的特征，所以严格说不是重写)。
静态方法的调用不需要实例化吧.. 不实例化也就不能用多态了，也就没有所谓的父类引用指向子类实例.因为不能实例化 也就没有机会去指向子类的实例。所以也就不存在多态了。
点击此处查看重载和重写区别