Java还要再学一遍基础（二）Java中的关键字

重新熟悉Java中常见的关键字

Java中的关键字都有

• abstract
• assert
• boolean
• break
• byte
• case
• catch
• char
• class
• const
• continue
• default
• do
• double
• else
• enum
• extends
• final
• finally
• float
• for
• goto
• if
• implements
• import
• instanceof
• int
• interface
• long
• native
• new
• package
• private
• protected
• public
• return
• strictfp
• short
• static
• super
• switch
• synchronized
• this
• throw
• throws
• transient
• try
• void
• volatile
• while

---

其中可能不太令人熟知的关键字

1. assert
表示断言，在JDK1.4中被添加。一般在程序测试时候使用。
用法1： assert expression 如果expression为true则程序通过继续执行，如果位false则抛出AssertionError异常
例：

public void test(){
    assert true;
    System.out.println("assert true -->ok");
    assert false;
    System.out.println("assert false -->ok");
}

结果：打印assert true –>ok并跑出异常。

用法2：assert expression：Str 断言错误的时候把str字符串中的信息打出。
Point：一般在测试时候时候，平时我们的IDE并没有启用assert功能。

2. const和goto
这两个关键字是Java中的保留关键字，没有具体的意义。
3. native
native关键字标识了这个方法是原生的方法，所谓原生的方法意思是这个方法的实现并不是用java实现的。
比如Object类中的hashCode方法：

public native int hashCode();

一般native的方法是用于java去调用其他语言所写的实现（或者说这个native方法更类似一个接口的调用吧）比如C，C++，因为java本身是不能控制操作系统底层的，同时由于java的跨平台性，因为使用native方法通过JNI（Java Native Interface）来调用对应操作系统的该方法的实现。
一般native方法都是通过静态代码块来完成加载：
Object类：

 private static native void registerNatives();
    static {
        registerNatives();
    }

也可以自己类似的编写native方法，此处不多赘述，Google–>

4. strictfp
strictfp 即strict float point，精确浮点数。该关键字可以用于类，方法，接口。被声明的范围内的所有float和double的表达式都将遵守FP-strict的限制，符合IEEE-754规范，可以使得浮点运算更加精确，并且不会出现因为不同的硬件平台而结果不一致的情况。

5. transient
transient标识此属性不能被序列化。使用场景一般是对象需要序列化的时候。也就是实现了Serializable接口的时候才被使用。
比如有一个User类序列化的时候不想序列化User的password属性，即可使用transient。

6. volatile
volatile关键字e修饰的变量，线程在每次使用变量的时候，都会读取变量修改后的最的值。

---

部分详解

1. static关键字的作用？
static又称作静态，可以用来修饰变量、修饰方法，也可以用来修饰代码块。也可以用作静态内部类，例如HashMap中的Entry：

static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;

        Node(int hash, K key, V value, Node<K,V> next) {
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.next = next;
        }
        //省略.......

还有一个不太为人知的JDK1.5新特性是用作静态导包，用作导入一个类的静态方法，比如通常比如我们需要打印控制台输出的时候一般是System.out.println();用的很多，同时我们使用static来导入System里面的out静态变量

import static java.lang.System.*;

public class Main {
    public static void main(String[] args) {
            out.println("static example");
    }
}

同样我们可以只导入其中的out

import static java.lang.System.out;

Point：Java中没有所谓的全局变量，不得不提的是java的内存笼统的说分为堆和栈，详细一点说分为堆内存，本地方法栈，方法区（其中包含常量池），程序计数器和虚拟机栈，这里不对个别做说明，
其中对象分配内存的区域在堆内存，而静态变量则存储在方法区中。
static修饰的变量，或者方法等跟它所在的类没有关系，只是在调用的时候使用类名的全限定名来指定而已。
因为java的类的加载顺序一般为：装载-链接-初始化三个阶段，其中链接又可以细分为校验，准备，解析三部分。而静态变量则是在这里的准备阶段在方法区中分配了内存。而实际对象的内存一般是在初始化阶段或者在我们new一个对象的时候才会被分配。

2. return 和finally到底谁先被执行？
当try catch语句块中含有return语句的时候 到底哪一个先执行？
答案：return先执行，但是实际finally中的代码是在return的值返回之前执行。（黑人问好？？？？？？？？）
看一个栗子：

public class Demo {

    public static void main(String[] args) {
        System.out.println("in main a is " + test());
    }
    public static int test(){
        int a = 1;
        try{
            System.out.println("in try{} a is " + a);
            return ++a;
        }catch(Exception e){
            e.printStackTrace();
        }
        finally{
            System.err.println("in finally a is " + a);
        }

        return a;
    }
}

运行结果：
in try{} a is 1
in finally a is 2
in main a is 2

可以看出是先执行了try catch语句中的return再执行的finnaly语句块再执行的return值的返回。
稍作修改：

package hiho.no1082;

public class Demo {

    public static void main(String[] args) {
        System.out.println("in main a is " + test());
    }
    public static int test(){
        int a = 1;
        try{
            System.out.println("in try{} a is " + a);
            return ++a;
        }catch(Exception e){
            e.printStackTrace();
        }
        finally{
            System.err.println("in finally a is " + ++a);
        }

        return a;
    }
}

输出结果
in try{} a is 1
in finally a is 3
in main a is 2
这样更加清晰一点点。

3. volatile

别人很好的解释