java—（6）native strictfp transient throw throws synchronized volatile关键字

 一. Native

   "A native method is a Java method whose implementation is provided by non-java code."
   一个Native Method就是一个java方法：该方法的实现由非java语言实现，比如C。
   在定义一个native method时，并不提供实现体（有些像定义一个java interface），因为其实现体是由非java语言在外面实现的。，下面给了一个示例：   

1. package java.lang; 
3. public class Object { 
5.     ......
7.     public final native Class<?> getClass(); 
9.     public native int hashCode(); 
11.     protected native Object clone() throws CloneNotSupportedException; 
13.     public final native void notify(); 
15.     public final native void notifyAll(); 
17.     public final native void wait(long timeout) throws InterruptedException; 
19.     ......
21. } 

       标识符native可以与所有其它的java标识符连用，但是abstract除外。这是合理的，因为native暗示这些方法是有实现体的，只不过这些实现体是非java的，但是abstract却显然的指明这些方法无实现体。

       参考http://blog.csdn.net/jiakw_1981/article/details/3073613

 二. strictfp  即 strict float point (精确浮点)

可应用于类、接口或方法。使用 strictfp 关键字声明一个方法时，该方法中所有的float和double表达式都严格遵守FP-strict的限制,符合IEEE-754规范。当对一个类或接口使用 strictfp 关键字时，该类中的所有代码，包括嵌套类型中的初始设定值和代码，都将严格地进行计算。严格约束意味着所有表达式的结果都必须是 IEEE 754 算法对操作数预期的结果，以单精度和双精度格式表示。
　　如果你想让你的浮点运算更加精确，而且不会因为不同的硬件平台所执行的结果不一致的话，可以用关键字strictfp.

 三. volatile

Java语言是支持多线程的，为了解决线程并发的问题，在语言内部引入了 同步块 和 volatile 关键字机制。

synchronized 

同步块大家都比较熟悉，通过 synchronized 关键字来实现，所有加上synchronized 和 块语句，在多线程访问的时候，同一时刻只能有一个线程能够用synchronized 修饰的方法 或者 代码块。

Volatile修饰的成员变量在每次被线程访问时，都强迫从主内存中重读该成员变量的值。而且，当成员变量发生变化时，强迫线程将变化值回写到主内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。   

Java语言规范中指出：为了获得最佳速度，允许线程保存共享成员变量的私有拷贝，而且只当线程进入或者离开同步代码块时才与共享成员变量的原始值对比。     
这样当多个线程同时与某个对象交互时，就必须要注意到要让线程及时的得到共享成员变量的变化。    
而volatile关键字就是提示VM：对于这个成员变量不能保存它的私有拷贝，而应直接与共享成员变量交互。     
使用建议：在两个或者更多的线程访问的成员变量上使用volatile。当要访问的变量已在synchronized代码块中，或者为常量时，不必使用。     
由于使用volatile屏蔽掉了VM中必要的代码优化，所以在效率上比较低，因此一定在必要时才使用此关键字。

jvm运行时有一个内存区域是jvm虚拟机栈，每一个线程运行时都有一个线程栈，

线程栈保存了线程运行时候变量值信息。当线程访问某一个对象时候值的时候，首先通过对象的引用找到对应在堆内存的变量的值，然后把堆内存

变量的具体值load到线程本地内存中，建立一个变量副本，之后线程就不再和对象在堆内存变量值有任何关系，而是直接修改副本变量的值，

在修改完之后的某一个时刻（线程退出之前），自动把线程变量副本的值回写到对象在堆中变量。这样在堆中的对象的值就产生变化了。

   参考http://www.blogjava.net/fhtdy2004/archive/2009/06/20/286112.html

http://www.cnblogs.com/aigongsi/archive/2012/04/01/2429166.html

 四.Transient   

  Java的serialization提供了一种持久化对象实例的机制。当持久化对象时，可能有一个特殊的对象数据成员，我们不想用serialization机制来保存它。为了在一个特定对象的一个域上关闭serialization，可以在这个域前加上关键字transient。   
transient是Java语言的关键字，用来表示一个域不是该对象串行化的一部分。当一个对象被串行化的时候，transient型变量的值不包括在串行化的表示中，然而非transient型的变量是被包括进去的。 

注意static变量也是可以串行化的 
  
首先，让我们看一个Java serialization的代码：   
public class LoggingInfo implements java.io.Serializable   
{   
    private Date loggingDate = new Date();   
    private String uid;   
    private transient String pwd;   
      
    LoggingInfo(String user, String password)   
    {   
        uid = user;   
        pwd = password;   
    }   
    public String toString()   
    {   
        String password=null;   
        if(pwd == null)   
        {   
        password = "NOT SET";   
        }   
        else  
        {   
            password = pwd;   
        }   
        return "logon info: \n   " + "user: " + uid +   
            "\n   logging date : " + loggingDate.toString() +   
            "\n   password: " + password;   
    }   
}   
  
现在我们创建一个这个类的实例，并且串行化(serialize)它 ,然后将这个串行化对象写入磁盘。   
  
LoggingInfo logInfo = new LoggingInfo("MIKE", "MECHANICS");   
System.out.println(logInfo.toString());   
try  
{   
   ObjectOutputStream o = new ObjectOutputStream(   
                new FileOutputStream("logInfo.out"));   
   o.writeObject(logInfo);   
   o.close();   
}   
catch(Exception e) {//deal with exception}   
  
To read the object back, we can write   
  
try  
{   
   ObjectInputStream in =new ObjectInputStream(   
                new FileInputStream("logInfo.out"));   
   LoggingInfo logInfo = (LoggingInfo)in.readObject();   
   System.out.println(logInfo.toString());   
}   
catch(Exception e) {//deal with exception}   
  
如果我们运行这段代码，我们会注意到从磁盘中读回(read——back (de-serializing))的对象打印password为"NOT SET"。这是当我们定义pwd域为transient时，所期望的正确结果。   
现在，让我们来看一下粗心对待transient域可能引起的潜在问题。假设我们修改了类定义，提供给transient域一个默认值，   代码如下：   
  
public class GuestLoggingInfo implements java.io.Serializable   
{   
    private Date loggingDate = new Date();   
    private String uid;   
    private transient String pwd;   
      
    GuestLoggingInfo()   
    {   
        uid = "guest";   
        pwd = "guest";   
    }   
    public String toString()   
    {   
        //same as above   
     }   
}   
现在，如果我们串行化GuestLoggingInfo的一个实例，将它写入磁盘，并且再将它从磁盘中读出，我们仍然看到读回的对象打印password 为 "NOT SET"。磁盘读出的时候不会执行构造，构造是你在存到磁盘的时候执行的，肯定是new的就会执行构造了。那个关键字是在序列化为对象流的时候起作用的。屏蔽了pwd这个字段，不将他放入流中。磁盘里当然就没有这个属性了。你存到磁盘的时候是一个对象。所有的对象只保存属性，不保存函数。函数是功能，是在类中定义的。所有这个类的对象都能调用函数，但是你传递对象的时候只有属性。这个pwd没有被序列化，就不会再磁盘里。读出数据的时候（getPWD()）也就没有这个属性值  

 四.异常

对于异常有两种处理方法

1、声明异常，也就是在方法名后面加上throws exception name,..., 将异常抛给调用者，让调用者处理。方法本身只是抛出异常，由函数调用者来捕获异常。 若产生异常，异常会沿着调用栈下移，一直找到与之匹配的处理方法，若到达调用栈底仍未找到，程序终止。

2、捕获异常。在发生异常的地方直接处理，通过try catch方法，catch子句中放置处理异常的语句。

throw 是语句抛出一个异常；throws 是方法抛出一个异常；

throw要么和try-catch-finally语句配套使用，显式捕获该异常；要么与throws配套使用。

throws可以单独使用，不知道当前如何处理该异常，由调用方法的方法捕获。

ssm开发中，service层、Component层 一般使用throws声明异常，action层调用这些方法，使用try catch捕获异常。