java基础知识--final和static关键字

final和static关键字

1、final关键字

　　1、含义

　　　　　　final在Java中是一个保留的关键字，可以声明成员变量、方法、类以及本地变量。一旦你将引用声明作final，你将不能改变这个引用了，

　　　　编译器会检查代码，如果你试图将变量再次初始化的话，编译器会报编译错误。

　　　2、final类（final修饰类）

　　　　　　被final修饰的类，是不可以被继承的，这样做的目的可以保证该类不被修改，Java的一些核心的API都是final类，例如String、Integer、Math等

　　　　　　

　　3、final方法（final修饰方法）

　　　　　　final也可以声明方法。方法前面加上final关键字，代表这个方法不可以被子类的方法重写。

　　　　　　如果你认为一个方法的功能已经足够完整了，子类中不需要改变的话，你可以声明此方法为final。final方法比非final方法要快，因为在编译的时候已经静态绑定了，不需要在运行时再动态绑定。

　　　　　　

　　final方法的原因有二：
        第一、把方法锁定，防止任何继承类修改它的意义和实现。
        第二、高效。编译器在遇到调用final方法时候会转入内嵌机制，大大提高执行效率。

4、final修饰实例变量(类的属性，定义在类内，但是在类内的方法之外)

　　　　　　final修饰实例变量时必须初始化，且不可再修改;

　　　　　　示例：

　　　　　　

　　　　　　

　　　　　　　　final修饰实例变量时必须初始化，且不可再修改代码。

　　　5、final修饰局部变量(方法体内的变量)

　　　　　　final修饰局部变量时只能初始化(赋值)一次，但也可以不初始化

　　　　　　

　　　　　　

　　　6、final修饰方法参数

　　　　　　final修饰方法参数时，是在调用方法传递参数时候初始化的

　　　　　　

　　　　7、final关键字的好处　　　　　　　

1. final关键字提高了性能。JVM和Java应用都会缓存final变量。
2. final变量可以安全的在多线程环境下进行共享，而不需要额外的同步开销。
3. 使用final关键字，JVM会对方法、变量及类进行优化。

　　　　8、final关键字知识点总结　　　　　　

1. 1. 1. final关键字可以用于成员变量、本地变量、方法以及类。
      2. final成员变量必须在声明的时候初始化或者在构造器中初始化，否则就会报编译错误。
      3. 你不能够对final变量再次赋值。
      4. 本地变量必须在声明时赋值。
      5. 在匿名类中所有变量都必须是final变量。
      6. final方法不能被重写。
      7. final类不能被继承。
      8. final关键字不同于finally关键字，后者用于异常处理。
      9. final关键字容易与finalize()方法搞混，后者是在Object类中定义的方法，是在垃圾回收之前被JVM调用的方法。
      10. 接口中声明的所有变量本身是final的。
      11. final和abstract这两个关键字是反相关的，final类就不可能是abstract的。
      12. final方法在编译阶段绑定，称为静态绑定(static binding)。
      13. 没有在声明时初始化final变量的称为空白final变量(blank final variable)，它们必须在构造器中初始化，或者调用this()初始化。不这么做的话，编译器会报错“final变量(变量名)需要进行初始化”。
      14. 将类、方法、变量声明为final能够提高性能，这样JVM就有机会进行估计，然后优化。
      15. 按照Java代码惯例，final变量就是常量，而且通常常量名要大写：

 

　　　　private final int COUNT = 10;

 

　　　　　16.对于集合对象声明为final指的是引用不能被更改，但是你可以向其中增加，删除或者改变内容。譬如：　　　

private final List Loans = new ArrayList();

list.add(“home loan”);  //valid

list.add("personal loan"); //valid

loans = new Vector();  //not valid

 

　　　　

2、static关键字

　　1、概念

　　　　　　 static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，也可以形成静态static代码块，但是Java语言中没有全局变量的概念。

　　　　　　被static修饰的成员变量和成员方法独立于该类的任何对象，也就是说，它不依赖类特定的实例，被类的所有实例共享。只要这个类被加载，Java虚拟机就能根据类

　　　　名在运行时数据区的方法区内定找到他们。因此，static对象可以在它的任何对象创建之前访问，无需引用任何对象。

　　　　用public修饰的static成员变量和成员方法本质是全局变量和全局方法，当声明它类的对象时，不生成static变量的副本，而是类的所有实例共享同一个static变量。

　　　　 static变量前可以有private修饰，表示这个变量可以在类的静态代码块中，或者类的其他静态成员方法中使用，但是不能在其他类中通过类名来直接引用。　　　　

　　　　 static修饰的成员变量和成员方法习惯上称为静态变量和静态方法，可以直接通过类名来访问，访问语法为：
　　　　　　类名.静态方法名(参数列表...) 
　　　　　　类名.静态变量名

        　　用static修饰的代码块表示静态代码块，当Java虚拟机（JVM）加载类时，就会执行该代码块；

 

　　2、修饰成员变量

　　　　static最常用的功能就是修饰类的属性和方法，让他们成为类的成员属性和方法，我们通常将用static修饰的成员称为类成员或者静态成员：　　　

　　　　Java类提供了两种类型的变量：

　　　　　　用static关键字修饰的静态变量和不用static关键字修饰的实例变量。静态变量属于类，在内存中只有一个复制，只要静态变量所在的类被加载，这个静态变量就会被分配空间，

　　　　因此就可以被使用了。对静态变量的引用有两种方式，分别是“类.静态变量"和”对象.静态变量"

　　　　实例变量属于对象，只有对象被创建后，实例变量才会被分配内存空间，才能被使用，它在内存中存在多个复制，只有用“对象.实例变量”的方式来引用。

　　3、static成员方法　　　　　

　　　　　　Java中提供了static方法和非static方法。static方法是类的方法，不需要创建对象就可以被调用，而非static方法是对象的方法，只有对象被创建出来后才可以被使用

　　　　　　static方法中不能使用this和super关键字，不能调用非static方法，只能访问所属类的静态成员变量和成员方法，因为当static方法被调用时，这个类的对象可能还没被

　　　　创建，即使已经被创建了，也无法确定调用哪个对象的方法。同理，static方法也不能访问非static类型的变量。

public class PrintHelper {

    public static void print(Object o){
        System.out.println(o);
    }
    
    public static void main(String[] args) {
        PrintHelper.print("Hello world");
    }
}

　　4、static代码块

　　　　static代码块在类中是独立于成员变量和成员函数的代码块的。注意：这些static代码块只会被执行一次　　

class Book{
    public Book(String msg) {
        System.out.println(msg);
    }
}

public class Person {

    Book book1 = new Book("book1成员变量初始化");
    static Book book2;
    
    static {
        book2 = new Book("static成员book2成员变量初始化");
        book4 = new Book("static成员book4成员变量初始化");
    }
    
    public Person(String msg) {
        System.out.println(msg);
    }
    
    Book book3 = new Book("book3成员变量初始化");
    static Book book4;
    
    public static void funStatic() {
        System.out.println("static修饰的funStatic方法");
    }
    
    public static void main(String[] args) {
        Person.funStatic();
        System.out.println("****************");
        Person p1 = new Person("p1初始化");
    }
    /**Output
     * static成员book2成员变量初始化
     * static成员book4成员变量初始化
     * static修饰的funStatic方法
     * ***************
     * book1成员变量初始化
     * book3成员变量初始化
     * p1初始化
     *///~

　　5、静态导包　　　

/* PrintHelper.java文件 */
package com.dotgua.study;

public class PrintHelper {

    public static void print(Object o){
        System.out.println(o);
    }
}

/* App.java文件 */

import static com.dotgua.study.PrintHelper.*;

public class App 
{
    public static void main( String[] args )
    {
        print("Hello World!");
    }
    /**Output
     * Hello World!
     *///~
}

　　　　上面的代码来自于两个java文件，其中的PrintHelper很简单，包含了一个用于打印的static方法。而在App.java文件中，我们首先将PrintHelper类导入，这里在导入时，我们使用了static关键字，而且在引入类的最后还加上了“.*”，它的作用就是将PrintHelper类中的所有类方法直接导入。不同于非static导入，采用static导入包后，在不与当前类的方法名冲突的情况下，无需使用“类名.方法名”的方法去调用类方法了，直接可以采用"方法名"去调用类方法，就好像是该类自己的方法一样使用即可。

　　　6、总结　　　　　　　

static是java中非常重要的一个关键字，而且它的用法也很丰富，主要有四种用法：

1. 1. 用来修饰成员变量，将其变为类的成员，从而实现所有对象对于该成员的共享；
   2. 用来修饰成员方法，将其变为类方法，可以直接使用“类名.方法名”的方式调用，常用于工具类；
   3. 静态块用法，将多个类成员放在一起初始化，使得程序更加规整，其中理解对象的初始化过程非常关键；
   4. 静态导包用法，将类的方法直接导入到当前类中，从而直接使用“方法名”即可调用类方法，更加方便。

　

　　

3、static与final结合使用表示的意思：　　　

对于变量，若使用static  final修饰，表示一旦赋值不能修改，并且通过类名可以访问。

对于方法，若使用static final修饰，表示该方法不可被覆盖，并且可以通过类名直接访问。

 

 

 

参考博客：

　　http://www.importnew.com/7553.html

　　http://www.cnblogs.com/dotgua/p/6354151.html?utm_source=itdadao&utm_medium=referral

　　http://blog.csdn.net/jsqfengbao/article/details/44724219

　　http://lavasoft.blog.51cto.com/62575/18771/