java修飾符使用指南
1、什麼是修飾符？
指的是一種標識型別以及型別成員的訪問範圍的宣告。
應用在修飾類名，類成員，方法，引數，構造器中。
2、修飾符的有幾種?
一共大致有14種，分別為public、private、protected、static、final、
synchronized、volatile、transient、native、interface、abstract、
strictfp、enum、annotation。
對於這些，我們有些可能很熟悉，有些可能很陌生。總之，一半一半吧。我們先從原始碼分析。
3、java原始碼
package java.lang.reflect;
import java.security.AccessController;
import sun.reflect.LangReflectAccess;
import sun.reflect.ReflectionFactory;
/**
* The Modifier class provides {@code static} methods and
* constants to decode class and member access modifiers. The sets
* of modifiers are represented as integers with distinct bit
* positions representing different modifiers. The values for the
* constants representing the modifiers are taken from the tables
* in sections 4.1, 4.4, 4.5, and 4.7 of <cite>The Java™
* Virtual Machine Specification</cite>.
*
* @see Class#getModifiers()
* @see Member#getModifiers()
*
* @author Nakul Saraiya
* @author Kenneth Russell
*/
public class Modifier {
/*
* Bootstrapping protocol between java.lang and
* java.lang.reflect
* packages
*/
static {
sun.reflect.ReflectionFactory factory =
AccessController.doPrivileged(
new ReflectionFactory.GetReflectionFactoryAction());
factory.setLangReflectAccess(
new java.lang.reflect.ReflectAccess());
}
/**
* Return {@code true} if the integer argument includes the
* {@code public} modifier, {@code false} otherwise.
*
* @param mod a set of modifiers
* @return {@code true} if {@code mod} includes the
* {@code public} modifier; {@code false} otherwise.
*/
public static boolean isPublic(int mod) {
return (mod & PUBLIC) != 0;
}
/**
* Return {@code true} if the integer argument includes the
* {@code private} modifier, {@code false} otherwise.
*
* @param mod a set of modifiers
* @return {@code true} if {@code mod} includes the
* {@code private} modifier; {@code false} otherwise.
*/
public static boolean isPrivate(int mod) {
return (mod & PRIVATE) != 0;
}
/**
* Return {@code true} if the integer argument includes the
* {@code protected} modifier, {@code false} otherwise.
*
* @param mod a set of modifiers
* @return {@code true} if {@code mod} includes the
* {@code protected} modifier; {@code false} otherwise.
*/
public static boolean isProtected(int mod) {
return (mod & PROTECTED) != 0;
}
/**
* Return {@code true} if the integer argument includes the
* {@code static} modifier, {@code false} otherwise.
*
* @param mod a set of modifiers
* @return {@code true} if {@code mod} includes the
* {@code static} modifier; {@code false} otherwise.
*/
public static boolean isStatic(int mod) {
return (mod & STATIC) != 0;
}
/**
* Return {@code true} if the integer argument includes the
* {@code final} modifier, {@code false} otherwise.
*
* @param mod a set of modifiers
* @return {@code true} if {@code mod} includes the
* {@code final} modifier; {@code false} otherwise.
*/
public static boolean isFinal(int mod) {
return (mod & FINAL) != 0;
}
/**
* Return {@code true} if the integer argument includes the
* {@code synchronized} modifier, {@code false} otherwise.
*
* @param mod a set of modifiers
* @return {@code true} if {@code mod} includes the
* {@code synchronized} modifier; {@code false} otherwise.
*/
public static boolean isSynchronized(int mod) {
return (mod & SYNCHRONIZED) != 0;
}
/**
* Return {@code true} if the integer argument includes the
* {@code volatile} modifier, {@code false} otherwise.
*
* @param mod a set of modifiers
* @return {@code true} if {@code mod} includes the
* {@code volatile} modifier; {@code false} otherwise.
*/
public static boolean isVolatile(int mod) {
return (mod & VOLATILE) != 0;
}
/**
* Return {@code true} if the integer argument includes the
* {@code transient} modifier, {@code false} otherwise.
*
* @param mod a set of modifiers
* @return {@code true} if {@code mod} includes the
* {@code transient} modifier; {@code false} otherwise.
*/
public static boolean isTransient(int mod) {
return (mod & TRANSIENT) != 0;
}
/**
* Return {@code true} if the integer argument includes the
* {@code native} modifier, {@code false} otherwise.
*
* @param mod a set of modifiers
* @return {@code true} if {@code mod} includes the
* {@code native} modifier; {@code false} otherwise.
*/
public static boolean isNative(int mod) {
return (mod & NATIVE) != 0;
}
/**
* Return {@code true} if the integer argument includes the
* {@code interface} modifier, {@code false} otherwise.
*
* @param mod a set of modifiers
* @return {@code true} if {@code mod} includes the
* {@code interface} modifier; {@code false} otherwise.
*/
public static boolean isInterface(int mod) {
return (mod & INTERFACE) != 0;
}
/**
* Return {@code true} if the integer argument includes the
* {@code abstract} modifier, {@code false} otherwise.
*
* @param mod a set of modifiers
* @return {@code true} if {@code mod} includes the
* {@code abstract} modifier; {@code false} otherwise.
*/
public static boolean isAbstract(int mod) {
return (mod & ABSTRACT) != 0;
}
/**
* Return {@code true} if the integer argument includes the
* {@code strictfp} modifier, {@code false} otherwise.
*
* @param mod a set of modifiers
* @return {@code true} if {@code mod} includes the
* {@code strictfp} modifier; {@code false} otherwise.
*/
public static boolean isStrict(int mod) {
return (mod & STRICT) != 0;
}
/**
* Return a string describing the access modifier flags in
* the specified modifier. For example:
* <blockquote><pre>
* public final synchronized strictfp
* </pre></blockquote>
* The modifier names are returned in an order consistent with
* the suggested modifier orderings given in sections 8.1.1,
* 8.3.1, 8.4.3, 8.8.3, and 9.1.1 of
* <cite>The Java™ Language Specification</cite>.
* The full modifier ordering used by this method is:
* <blockquote> {@code
* public protected private abstract static final transient
* volatile synchronized native strictfp
* interface } </blockquote>
* The {@code interface} modifier discussed in this class is
* not a true modifier in the Java language and it appears after
* all other modifiers listed by this method. This method may
* return a string of modifiers that are not valid modifiers of a
* Java entity; in other words, no checking is done on the
* possible validity of the combination of modifiers represented
* by the input.
*
* Note that to perform such checking for a known kind of entity,
* such as a constructor or method, first AND the argument of
* {@code toString} with the appropriate mask from a method like
* {@link #constructorModifiers} or {@link #methodModifiers}.
*
* @param mod a set of modifiers
* @return a string representation of the set of modifiers
* represented by {@code mod}
*/
public static String toString(int mod) {
StringBuilder sb = new StringBuilder();
int len;
if ((mod & PUBLIC) != 0) sb.append("public ");
if ((mod & PROTECTED) != 0) sb.append("protected ");
if ((mod & PRIVATE) != 0) sb.append("private ");
/* Canonical order */
if ((mod & ABSTRACT) != 0) sb.append("abstract ");
if ((mod & STATIC) != 0) sb.append("static ");
if ((mod & FINAL) != 0) sb.append("final ");
if ((mod & TRANSIENT) != 0) sb.append("transient ");
if ((mod & VOLATILE) != 0) sb.append("volatile ");
if ((mod & SYNCHRONIZED) != 0) sb.append("synchronized ");
if ((mod & NATIVE) != 0) sb.append("native ");
if ((mod & STRICT) != 0) sb.append("strictfp ");
if ((mod & INTERFACE) != 0) sb.append("interface ");
if ((len = sb.length()) > 0) /* trim trailing space */
return sb.toString().substring(0, len-1);
return "";
}
/*
* Access modifier flag constants from tables 4.1, 4.4, 4.5, and
* 4.7 of <cite>The Java™ Virtual Machine
* Specification</cite>
*/
/**
* The {@code int} value representing the {@code public}
* modifier.
*/
public static final int PUBLIC = 0x00000001;
/**
* The {@code int} value representing the {@code private}
* modifier.
*/
public static final int PRIVATE = 0x00000002;
/**
* The {@code int} value representing the {@code protected}
* modifier.
*/
public static final int PROTECTED = 0x00000004;
/**
* The {@code int} value representing the {@code static}
* modifier.
*/
public static final int STATIC = 0x00000008;
/**
* The {@code int} value representing the {@code final}
* modifier.
*/
public static final int FINAL = 0x00000010;
/**
* The {@code int} value representing the {@code synchronized}
* modifier.
*/
public static final int SYNCHRONIZED = 0x00000020;
/**
* The {@code int} value representing the {@code volatile}
* modifier.
*/
public static final int VOLATILE = 0x00000040;
/**
* The {@code int} value representing the {@code transient}
* modifier.
*/
public static final int TRANSIENT = 0x00000080;
/**
* The {@code int} value representing the {@code native}
* modifier.
*/
public static final int NATIVE = 0x00000100;
/**
* The {@code int} value representing the {@code interface}
* modifier.
*/
public static final int INTERFACE = 0x00000200;
/**
* The {@code int} value representing the {@code abstract}
* modifier.
*/
public static final int ABSTRACT = 0x00000400;
/**
* The {@code int} value representing the {@code strictfp}
* modifier.
*/
public static final int STRICT = 0x00000800;
// Bits not (yet) exposed in the public API either because they
// have different meanings for fields and methods and there is no
// way to distinguish between the two in this class, or because
// they are not Java programming language keywords
static final int BRIDGE = 0x00000040;
static final int VARARGS = 0x00000080;
static final int SYNTHETIC = 0x00001000;
static final int ANNOTATION = 0x00002000;
static final int ENUM = 0x00004000;
static final int MANDATED = 0x00008000;
static boolean isSynthetic(int mod) {
return (mod & SYNTHETIC) != 0;
}
static boolean isMandated(int mod) {
return (mod & MANDATED) != 0;
}
// Note on the FOO_MODIFIERS fields and fooModifiers() methods:
// the sets of modifiers are not guaranteed to be constants
// across time and Java SE releases. Therefore, it would not be
// appropriate to expose an external interface to this information
// that would allow the values to be treated as Java-level
// constants since the values could be constant folded and updates
// to the sets of modifiers missed. Thus, the fooModifiers()
// methods return an unchanging values for a given release, but a
// value that can potentially change over time.
/**
* The Java source modifiers that can be applied to a class.
* @jls 8.1.1 Class Modifiers
*/
private static final int CLASS_MODIFIERS =
Modifier.PUBLIC | Modifier.PROTECTED
| Modifier.PRIVATE | Modifier.ABSTRACT
| Modifier.STATIC | Modifier.FINAL
| Modifier.STRICT;
/**
* The Java source modifiers that can be applied to an interface.
* @jls 9.1.1 Interface Modifiers
*/
private static final int INTERFACE_MODIFIERS =
Modifier.PUBLIC | Modifier.PROTECTED
| Modifier.PRIVATE | Modifier.ABSTRACT
| Modifier.STATIC | Modifier.STRICT;
/**
* The Java source modifiers that can be applied to a constructor.
* @jls 8.8.3 Constructor Modifiers
*/
private static final int CONSTRUCTOR_MODIFIERS =
Modifier.PUBLIC | Modifier.PROTECTED
| Modifier.PRIVATE;
/**
* The Java source modifiers that can be applied to a method.
* @jls8.4.3 Method Modifiers
*/
private static final int METHOD_MODIFIERS =
Modifier.PUBLIC | Modifier.PROTECTED
| Modifier.PRIVATE | Modifier.ABSTRACT
| Modifier.STATIC | Modifier.FINAL
| Modifier.SYNCHRONIZED | Modifier.NATIVE
| Modifier.STRICT;
/**
* The Java source modifiers that can be applied to a field.
* @jls 8.3.1 Field Modifiers
*/
private static final int FIELD_MODIFIERS =
Modifier.PUBLIC | Modifier.PROTECTED
| Modifier.PRIVATE | Modifier.STATIC
| Modifier.FINAL | Modifier.TRANSIENT
| Modifier.VOLATILE;
/**
* The Java source modifiers that can be applied to a method or
* constructor parameter.
* @jls 8.4.1 Formal Parameters
*/
private static final int PARAMETER_MODIFIERS =
Modifier.FINAL;
/**
*
*/
static final int ACCESS_MODIFIERS =
Modifier.PUBLIC | Modifier.PROTECTED | Modifier.PRIVATE;
/**
* Return an {@code int} value OR-ing together the source language
* modifiers that can be applied to a class.
* @return an {@code int} value OR-ing together the source language
* modifiers that can be applied to a class.
*
* @jls 8.1.1 Class Modifiers
* @since 1.7
*/
public static int classModifiers() {
return CLASS_MODIFIERS;
}
/**
* Return an {@code int} value OR-ing together the source
* language modifiers that can be applied to an interface.
* @return an {@code int} value OR-ing together the source
* language modifiers that can be applied to an interface.
*
* @jls 9.1.1 Interface Modifiers
* @since 1.7
*/
public static int interfaceModifiers() {
return INTERFACE_MODIFIERS;
}
/**
* Return an {@code int} value OR-ing together the source
* language modifiers that can be applied to a constructor.
* @return an {@code int} value OR-ing together the source
* language modifiers that can be applied to a constructor.
*
* @jls 8.8.3 Constructor Modifiers
* @since 1.7
*/
public static int constructorModifiers() {
return CONSTRUCTOR_MODIFIERS;
}
/**
* Return an {@code int} value OR-ing together the source
* language modifiers that can be applied to a method. @return
* an {@code int} value OR-ing together the source language
* modifiers that can be applied to a method.
*
* @jls 8.4.3 Method Modifiers
* @since 1.7
*/
public static int methodModifiers() {
return METHOD_MODIFIERS;
}
/**
* Return an {@code int} value OR-ing together the source
* language modifiers that can be applied to a field.@return
* an {@code int} value OR-ing together the source language
* modifiers that can be applied to a field.
*
* @jls 8.3.1 Field Modifiers
* @since 1.7
*/
public static int fieldModifiers() {
return FIELD_MODIFIERS;
}
/**
* Return an {@code int} value OR-ing together the source
* language modifiers that can be applied to a parameter.
* @return an {@code int} value OR-ing together the source
* language modifiers that can be applied to a parameter.
*
* @jls 8.4.1 Formal Parameters
* @since 1.8
*/
public static int parameterModifiers() {
return PARAMETER_MODIFIERS;
}
}
4. 分析
具體的先不看，我們先看這裡：
/**
* The Java source modifiers that can be applied to a class.
* @jls 8.1.1 Class Modifiers
*/
private static final int CLASS_MODIFIERS =
Modifier.PUBLIC | Modifier.PROTECTED | Modifier.PRIVATE |
Modifier.ABSTRACT | Modifier.STATIC | Modifier.FINAL |
Modifier.STRICT;
/**
* The Java source modifiers that can be applied to an interface.
* @jls 9.1.1 Interface Modifiers
*/
private static final int INTERFACE_MODIFIERS =
Modifier.PUBLIC | Modifier.PROTECTED | Modifier.PRIVATE |
Modifier.ABSTRACT | Modifier.STATIC | Modifier.STRICT;
/**
* The Java source modifiers that can be applied to a constructor.
* @jls 8.8.3 Constructor Modifiers
*/
private static final int CONSTRUCTOR_MODIFIERS =
Modifier.PUBLIC | Modifier.PROTECTED | Modifier.PRIVATE;
/**
* The Java source modifiers that can be applied to a method.
* @jls8.4.3 Method Modifiers
*/
private static final int METHOD_MODIFIERS =
Modifier.PUBLIC | Modifier.PROTECTED | Modifier.PRIVATE |
Modifier.ABSTRACT | Modifier.STATIC | Modifier.FINAL |
Modifier.SYNCHRONIZED | Modifier.NATIVE | Modifier.STRICT;
/**
* The Java source modifiers that can be applied to a field.
* @jls 8.3.1 Field Modifiers
*/
private static final int FIELD_MODIFIERS =
Modifier.PUBLIC | Modifier.PROTECTED | Modifier.PRIVATE |
Modifier.STATIC | Modifier.FINAL | Modifier.TRANSIENT |
Modifier.VOLATILE;
/**
* The Java source modifiers that can be applied to a method or
* constructor parameter.
* @jls 8.4.1 Formal Parameters
*/
private static final int PARAMETER_MODIFIERS =
Modifier.FINAL;
/**
*
*/
static final int ACCESS_MODIFIERS =
Modifier.PUBLIC | Modifier.PROTECTED | Modifier.PRIVATE;
4.1 分析：
CLASS_MODIFIERS ：表示的是類的修飾符。
INTERFACE_MODIFIERS：介面修飾符
CONSTRUCTOR_MODIFIERS：構造器修飾符
METHOD_MODIFIERS：方法修飾符
FIELD_MODIFIERS：欄位修飾符
PARAMETER_MODIFIERS：引數修飾符
ACCESS_MODIFIERS：最基本的修飾符
4.2 作用在類上：
public:當此修飾符修飾類。那麼，這個類將對外保持公開。也就是說，對任何包下的
任何類都是可用的。
private:當此修飾符修飾類。那麼，這個類將對外不公開。也就是說，除型別建立者和
型別內部方法之外的任何元素都不能訪問。
protected:當此修飾符修飾類。那麼，這個類將對外保持半公開。可以理解為：同包、
子類和本身可以訪問。當然，這裡要注意一下，不同包下的子類不能訪問。
abstract:當此修飾符修飾類。那麼，這個類將表示抽象。抽象類表示的是一種預設行為。
在類裡面可以定義的東西，抽象類也一樣也可定義。同時，也可以定義預設方法，此方法
可以實現，也可以是類似於介面的抽象方法。
static:當此修飾符修飾類。那麼這個類，只有一種情況，這個類是靜態內部類。俗稱：
內嵌類。只能訪問靜態的成員變數和方法，不能訪問非靜態的方法和屬性，但是普通內部
類可以訪問任意外部類的成員變數和方法
final: 當此修飾符修飾類。那麼，就表明此類不希望從這個類繼承。換言之，final
修飾的類不能被繼承，也就是不能被擴充套件。不希望被子類化（子類處理）。
strictfp: 當此修飾符修飾類。那麼，就宣告此類所有運算都是精確的，而此類中的所有
方法也都是strictfp的。主要是用來精確浮點。
4.3 作用在介面上：
public:當此修飾符修飾介面。那麼，這個介面將對外保持公開。也就是說，對任何包下的
任何類都是可實現的。
private:理論上，private是可以修飾介面的。實際上,介面是需要其他類實現的，如果
介面定義成private，而介面又要求被實現，但同時自己又不可見，這是無法實現的。假如定
義一個空介面，比如說Cloneable、Serializable介面，如果定義成private.沒錯，這是一
個空介面，同時又不見。那麼，請問這個介面定義了和沒定義有什麼區別。所以，private不
能修飾介面。
protected:當此修飾符修飾介面。如果private不能修飾介面，那麼這個應該可以了吧。
假設有一個protected介面A,那麼只能位於同包下的類實現這個介面。於是同包下的類B就實
現這個介面A。這樣是沒錯的。如果不同包下的類C去使用類b，可以使用嗎？如果再如果不同
包下的類D繼承類B怎麼辦。這樣就失去了介面的重要意義：提供統一的介面，面向介面程式設計思
想也無法體現。所以，protected也不能修飾介面;
abstract:當此修飾符修飾介面。就表示為父介面。打個比方，如果目前一個功能，但
這個功能目前要有列印和顯示的效果，隨時可以擴充套件功能，那麼這個時候，先定義一個父介面，
然後讓子介面去繼承它，如果功能需要擴充套件，我們就可以在更改介面的前提下，擴充套件功能。
static:當此修飾符修飾介面。那麼這個類，只有一種情況，這個類是靜態內部介面。俗
稱：內嵌介面。可以理解為一個類或介面中進行進一步的邏輯細分, 比如JDK介面Map中的內
部介面Entry;可以增強程式碼的易讀性和可維護性。
final: 這個修飾符理論上是可以修飾介面的，但實際上，它不能用來修飾介面， 因為
final修飾類，類不可以被繼承，修飾介面，那麼其它類不能實現，介面也就毫無意義了。
strictfp: 當此修飾符修飾介面。那麼，就宣告實現此介面的類所有運算都是精確的，而
實現類中的所有方法也都是strictfp的。主要是用來精確浮點。
4.4 作用在構造器上：
在構造器上，只允許使用三種修飾符，private、protected、public。當然，還有一種，就是
什麼也不寫，表示預設的，對於在這個。先放在後面講。
public:當此修飾符修飾構造器。那麼，這個構造器將對外保持公開。也就是說，對任何
包下的任何類都是可用的。
private:當此修飾符修飾構造器。那麼，這個構造器將對外不公開。也就是說，除型別
建立者和型別內部方法之外的任何元素都不能訪問。
protected:當此修飾符修飾構造器。那麼，這個構造器將對外保持半公開。可以理解為：
同包、子類和本身可以訪問。當然，這裡要注意一下，不同包下的子類不能訪問。
4.5 作用於方法上的修飾符
public:當此修飾符修飾方法。那麼，這個方法將對外保持公開。也就是說，對任何
包下的任何類都是可用的。
private:當此修飾符修飾方法。那麼，這個方法將對外不公開。也就是說，除型別
建立者和型別內部方法之外的任何元素都不能訪問。
protected:當此修飾符修飾方法。那麼，這個方法將對外保持半公開。可以理解為：
同包、子類和本身可以訪問。當然，這裡要注意一下，不同包下的子類不能訪問。---
abstract:當此修飾符修飾方法,表示的是一種預設行為。
static：當此修飾符修飾方法，表示為靜態方法，會隨著類的定義而被分配和裝載到
記憶體中。
final:當此修飾符修飾方法。那麼，這個類一定是final類，這樣可以把方法鎖定，
防止任何繼承類修改它的意義和實現。高效。編譯器在遇到呼叫final方法時候會轉入內嵌
機制，大大提高執行效率。
synchronized:當此修飾符修飾方法，那麼，當一個執行緒使用到了被synchronized
修飾的方法，那麼其他執行緒都必須等待，直至這個執行緒釋放了鎖，其他的執行緒才可以使用。
native:當此修飾符修飾方法，那麼這個方法就是一個java呼叫非java程式碼的介面。
此方法的實現由非java語言實現，比如說C、C++等。這個待徵並非java所特有，很多其它
的程式語言都有這一機制。
strictfp:當此修飾符修飾方法。那麼，在此方法內所有運算都是精確的，主要是用來
精確浮點。
4.6 作用在欄位上
public:當此修飾符修飾欄位。那麼，這個欄位將對外保持公開。也就是說，對任何
包下的任何類都是可用的。
private:當此修飾符修飾欄位。那麼，這個欄位將對外不公開。也就是說，除型別
建立者和型別內部方法之外的任何元素都不能訪問。
protected:當此修飾符修飾欄位。那麼，這個欄位將對外保持半公開。可以理解為：
同包、子類和本身可以訪問。當然，這裡要注意一下，不同包下的子類不能訪問。
static:當此修飾符修飾欄位。那麼，這個欄位可以在沒有建立物件的情況下進來訪問
只要類被載入了，就可以通過類名去進行訪問。
final:當此修飾符修飾欄位。那麼，這個欄位一旦賦值，這個欄位的值就無法改變。
不能賦值。一般在程式中多個地方使用到共同的資料，且該資料不會改變，此時我們專門定
義全域性的常量。
transient:當此修飾符修飾欄位。標記為transient的變數，在物件儲存時，這些變數
狀態不會被持久化。當物件序列化的儲存在儲存器上時，不希望有些欄位資料被儲存，為了保證
安全性，可以把這些欄位宣告為transien
volatile:當此修飾符修飾欄位。在每次執行緒訪問時，都強迫從共享記憶體中重讀該成員
變數值。而且，當成員變數發生變化時，強迫執行緒將變化值回寫到共享記憶體中。
4.7 作用在引數上
當final作用在引數上，那麼如果定義的是基本型別，那麼在這個方法的內部，基本型別
的值不能改變。但如果定義的是引用型別的變數，那麼引用型別變數的引用不能改變，但引用類
型變數的值可以改變。
5. 總結
5.1 關於 private、protected、public以及default
- protected修飾符所修飾的類（這句話中指父類）屬成員變數和方法，只可以被子類訪問，而不管子類是不是和父類位於同一個包中。default修飾符所修飾的類屬成員變數和方法，只可被同一個包中的其他類訪問，而不管其他類是不是該類的子類。protected屬於子類限制修飾符，而default屬於包限制修飾符。5.2 關於 final
5.2.1 final 引數
final來修飾方法引數的原因是防止方法引數在呼叫時被改變，主要是這個原因，但可能會有歧
義，需要注意的點：
1. 在final修飾的方法引數中，如果修飾的是基本型別，那麼在這個方法的內部，基本型別
的值是不能夠改變的.
2. 在final修飾的方法引數中，如果修飾的是引用型別的變數，引用型別變數所指的引用是
不能夠改變的，但是引用型別變數的值是可以改變的。
5.2.2 final 其它情況
- 如果final修飾類，這個類不可以從這個類繼承，或者不允許其他任何人採取這種操作
- 如果修飾變數，那麼這個變數一旦被賦值，就不可以被改變。
5.3 abstract 和 interface
1.理解抽象類：指的是將某一事物的特性抽象出來，單獨拎出來，進行型別隱藏，對某一事物的
行為抽象描述，但這組行為卻能夠有任意個可能的具體實現方式，這就是這個抽象描述就是抽
象類。
2.interface是一種特殊形式的abstract class
3.abstract class表示的是一種繼承關係，一個類只能使用一次繼承關係。但一個類可以實現
多個interface.可能是java語言設計者對多重繼承的一種折中考慮。
4.如果有必要，請在abstract class中定義預設行為。
5.abstract class和interface是Java語言中的兩種定義抽象類的方式，它們之間有很大的相
似性。但是對於它們的選擇卻又往往反映出對於問題領域中的概念本質的理解、對於設計意圖
的反映是否正確、合理，因為它們表現了概念間的不同的關係（雖然都能夠實現需求的功能)。
這其實也是語言的一種的慣用法，
5.5 static
1.static修飾的靜態方法會隨著類的定義而被分配和裝載入記憶體中，編譯器只為整個類建立了一
個靜態變數的副本，也就是隻分配一個記憶體空間，雖然可能有多個例項，但這些例項共享該內
存，特別值得注意的是，任何一個物件對靜態資料成員的修改，都會影響其它物件。
2.靜態不能引用非靜態這一特性，是由於靜態的會隨著類的定義而被分配和裝載入記憶體中這一關鍵
點決定的；如果靜態引用了非靜態的，根本無法從記憶體中找到非靜態的程式碼段，勢必會出錯，這
種做法是Java虛擬機器決不允許的
5.6 關於strictfp
strictfp 的意思是FP-strict，也就是說精確浮點的意思。在Java虛擬機器進行浮點運
算時,如果沒有指定strictfp關鍵字時，Java的編譯器以及運 行環境在對浮點運算的表示式
是採取一種近似於我行我素的行為來完成這些操作，以致於得到的結果往往無法令你滿意。而
一旦使用了strictfp來宣告一個 類、介面或者方法時，那麼所宣告的範圍內Java的編譯器以
及執行環境會完全依照浮點規範IEEE-754來執行。因此如果你想讓你的浮點運算更加精確,而
且不會因為不同的硬體平臺所執行的結果不一致的話，那就請用關鍵字strictfp。
5.7 關於transient 和 volatile
1.當使用transient修飾符時，就意思著這個變數不會被持久化，所以如果物件在序列化的儲存
在儲存器上時，為了安全性，可以把某些不希望被儲存的資料用transient修飾。
2.volatile具有synchronized的可見性，但不具備原子性，也就是說，執行緒可以自動發生
volatile變數的最新值。只有同時滿足如下兩個條件才可以使用volatile變數：
1.對變數的寫操作不信賴於當前值。
2.該變數沒有包含在具有其他變數的不變式中
3.實際上，這些條件表明，可以被寫入 volatile 變數的這些有效值獨立於任何程式的狀態，
包括變數的當前狀態。但使用volatile變數的次要原因是其效能：某些情況下，volatile變數同
步機制的效能要優於鎖。volatile 操作不會像鎖一樣造成阻塞，因此，在能夠安全使用
volatile 的情況下，volatile 可以提供一些優於鎖的可伸縮特性。如果讀操作的次數要遠遠超
過寫操作，與鎖相比，volatile 變數通常能夠減少同步的效能開銷。
4.與鎖相比，Volatile 變數是一種非常簡單但同時又非常脆弱的同步機制，它在某些情況下
將提供優於鎖的效能和伸縮性。如果嚴格遵循 volatile 的使用條件 —— 即變數真正獨立於其他
變數和自己以前的值 —— 在某些情況下可以使用 volatile 代替 synchronized 來簡化程式碼。
5.8 關於synchronized
1.synchronized 修飾方法時鎖定的是呼叫該方法的物件。它並不能使呼叫該方法的多個物件
在執行順序上互斥。
5.9 關於內部類
1.使用內部類最吸引人的原因是：每個內部類都能獨立地繼承一個（介面的）實現，所以無論外
圍類是否已經繼承了某個（介面的）實現，對於內部類都沒有影響。
2.內部類使得多重繼承的解決方案變得更加完整。
相關文章
- Java 修飾符Java 修飾符
- java修飾符Java
- Java 常用修飾符Java
- java中的修飾符Java
- Java的static修飾符Java
- Java的訪問修飾符Java
- JAVA java學習（24）——————java修飾符Java
- Vue - 按鍵修飾符 && 系統修飾符Vue
- java oop 修飾符&關鍵字JavaOOP
- Java 修飾符順序問題Java 修飾符
- Java修飾符關鍵詞大全Java
- Java中的native修飾符Java
- java static修飾符的問題Java
- Java的“友好的”訪問指示符（修飾符）Java
- 關於Java中各種修飾符與訪問修飾符的說明 (轉)Java
- java常用修飾符（隨堂筆記）Java筆記
- 深入理解 Java 中 protected 修飾符Java
- Java中”失效”的private修飾符解析Java
- java中final修飾符的用法Java
- vue 事件修飾符Vue事件
- vue sync 修飾符Vue
- 繼承&修飾符繼承
- iOS __block修飾符iOSBloC
- Java修飾符關鍵字的順序Java
- java基礎學習之四:修飾符Java
- 09-02 Java語言基礎（修飾符）Java
- Java中final修飾符都有什麼作用Java
- Vue事件修飾符詳解Vue事件
- TypeScript 類訪問修飾符TypeScript
- 如何獲取java類中的欄位修飾符？Java
- Java入門系列之訪問修飾符作用範圍Java
- #Java教程：訪問修飾符：public、protected、預設、private @FDDLCJava
- Java 訪問許可權修飾符學習筆記Java訪問許可權筆記
- v-on 及其事件修飾符事件
- 從實踐認識修飾符
- Kotlin可見性修飾符Kotlin
- 正規表示式模式修飾符模式
- MongoDB （ 四 ）高階_find修飾符MongoDB