資訊專欄INFORMATION COLUMN
摘要：應(yīng)用在修飾類名，類成員，方法，參數(shù)，構(gòu)造器中。接口修飾符構(gòu)造器修飾符方法修飾符字段修飾符參數(shù)修飾符最基本的修飾符作用在類上當(dāng)此修飾符修飾類。作用在構(gòu)造器上在構(gòu)造器上，只允許使用三種修飾符，。當(dāng)此修飾符修飾構(gòu)造器。
1、什么是修飾符？
指的是一種標(biāo)識類型以及類型成員的訪問范圍的聲明。
應(yīng)用在修飾類名，類成員，方法，參數(shù)，構(gòu)造器中。
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 The Java™
* Virtual Machine Specification.
*
* @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:
*
* public final synchronized strictfp
*
* 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
* The Java™ Language Specification.
* The full modifier ordering used by this method is:
* {@code
* public protected private abstract static final transient
* volatile synchronized native strictfp
* interface }
* 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 The Java™ Virtual Machine
* Specification
*/
/**
* 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：構(gòu)造器修飾符 METHOD_MODIFIERS：方法修飾符 FIELD_MODIFIERS：字段修飾符 PARAMETER_MODIFIERS：參數(shù)修飾符 ACCESS_MODIFIERS：最基本的修飾符4.2 作用在類上：
public:當(dāng)此修飾符修飾類。那么，這個類將對外保持公開。也就是說，對任何包下的 任何類都是可用的。
private:當(dāng)此修飾符修飾類。那么，這個類將對外不公開。也就是說，除類型創(chuàng)建者和 類型內(nèi)部方法之外的任何元素都不能訪問。
protected:當(dāng)此修飾符修飾類。那么，這個類將對外保持半公開。可以理解為：同包、 子類和本身可以訪問。當(dāng)然，這里要注意一下，不同包下的子類不能訪問。
abstract:當(dāng)此修飾符修飾類。那么，這個類將表示抽象。抽象類表示的是一種默認(rèn)行為。 在類里面可以定義的東西，抽象類也一樣也可定義。同時，也可以定義默認(rèn)方法，此方法 可以實(shí)現(xiàn)，也可以是類似于接口的抽象方法。
static:當(dāng)此修飾符修飾類。那么這個類，只有一種情況，這個類是靜態(tài)內(nèi)部類。俗稱： 內(nèi)嵌類。只能訪問靜態(tài)的成員變量和方法，不能訪問非靜態(tài)的方法和屬性，但是普通內(nèi)部 類可以訪問任意外部類的成員變量和方法
final: 當(dāng)此修飾符修飾類。那么，就表明此類不希望從這個類繼承。換言之，final 修飾的類不能被繼承，也就是不能被擴(kuò)展。不希望被子類化（子類處理）。
strictfp: 當(dāng)此修飾符修飾類。那么，就聲明此類所有運(yùn)算都是精確的，而此類中的所有 方法也都是strictfp的。主要是用來精確浮點(diǎn)。4.3 作用在接口上：
public:當(dāng)此修飾符修飾接口。那么，這個接口將對外保持公開。也就是說，對任何包下的 任何類都是可實(shí)現(xiàn)的。
private:理論上，private是可以修飾接口的。實(shí)際上,接口是需要其他類實(shí)現(xiàn)的，如果 接口定義成private，而接口又要求被實(shí)現(xiàn)，但同時自己又不可見，這是無法實(shí)現(xiàn)的。假如定 義一個空接口，比如說Cloneable、Serializable接口，如果定義成private.沒錯，這是一 個空接口，同時又不見。那么，請問這個接口定義了和沒定義有什么區(qū)別。所以，private不 能修飾接口。
protected:當(dāng)此修飾符修飾接口。如果private不能修飾接口，那么這個應(yīng)該可以了吧。 假設(shè)有一個protected接口A,那么只能位于同包下的類實(shí)現(xiàn)這個接口。于是同包下的類B就實(shí) 現(xiàn)這個接口A。這樣是沒錯的。如果不同包下的類C去使用類b，可以使用嗎？如果再如果不同 包下的類D繼承類B怎么辦。這樣就失去了接口的重要意義：提供統(tǒng)一的接口，面向接口編程思 想也無法體現(xiàn)。所以，protected也不能修飾接口;
abstract:當(dāng)此修飾符修飾接口。就表示為父接口。打個比方，如果目前一個功能，但 這個功能目前要有打印和顯示的效果，隨時可以擴(kuò)展功能，那么這個時候，先定義一個父接口， 然后讓子接口去繼承它，如果功能需要擴(kuò)展，我們就可以在更改接口的前提下，擴(kuò)展功能。
static:當(dāng)此修飾符修飾接口。那么這個類，只有一種情況，這個類是靜態(tài)內(nèi)部接口。俗 稱：內(nèi)嵌接口。可以理解為一個類或接口中進(jìn)行進(jìn)一步的邏輯細(xì)分, 比如JDK接口Map中的內(nèi) 部接口Entry;可以增強(qiáng)代碼的易讀性和可維護(hù)性。
final: 這個修飾符理論上是可以修飾接口的，但實(shí)際上，它不能用來修飾接口， 因為 final修飾類，類不可以被繼承，修飾接口，那么其它類不能實(shí)現(xiàn)，接口也就毫無意義了。
strictfp: 當(dāng)此修飾符修飾接口。那么，就聲明實(shí)現(xiàn)此接口的類所有運(yùn)算都是精確的，而 實(shí)現(xiàn)類中的所有方法也都是strictfp的。主要是用來精確浮點(diǎn)。4.4 作用在構(gòu)造器上：
在構(gòu)造器上，只允許使用三種修飾符，private、protected、public。當(dāng)然，還有一種，就是
什么也不寫，表示默認(rèn)的，對于在這個。先放在后面講。
public:當(dāng)此修飾符修飾構(gòu)造器。那么，這個構(gòu)造器將對外保持公開。也就是說，對任何 包下的任何類都是可用的。
private:當(dāng)此修飾符修飾構(gòu)造器。那么，這個構(gòu)造器將對外不公開。也就是說，除類型 創(chuàng)建者和類型內(nèi)部方法之外的任何元素都不能訪問。
protected:當(dāng)此修飾符修飾構(gòu)造器。那么，這個構(gòu)造器將對外保持半公開。可以理解為： 同包、子類和本身可以訪問。當(dāng)然，這里要注意一下，不同包下的子類不能訪問。4.5 作用于方法上的修飾符
public:當(dāng)此修飾符修飾方法。那么，這個方法將對外保持公開。也就是說，對任何 包下的任何類都是可用的。
private:當(dāng)此修飾符修飾方法。那么，這個方法將對外不公開。也就是說，除類型 創(chuàng)建者和類型內(nèi)部方法之外的任何元素都不能訪問。
protected:當(dāng)此修飾符修飾方法。那么，這個方法將對外保持半公開。可以理解為： 同包、子類和本身可以訪問。當(dāng)然，這里要注意一下，不同包下的子類不能訪問。
---
abstract:當(dāng)此修飾符修飾方法,表示的是一種默認(rèn)行為。
static：當(dāng)此修飾符修飾方法，表示為靜態(tài)方法，會隨著類的定義而被分配和裝載到 內(nèi)存中。
final:當(dāng)此修飾符修飾方法。那么，這個類一定是final類，這樣可以把方法鎖定， 防止任何繼承類修改它的意義和實(shí)現(xiàn)。高效。編譯器在遇到調(diào)用final方法時候會轉(zhuǎn)入內(nèi)嵌 機(jī)制，大大提高執(zhí)行效率。
synchronized:當(dāng)此修飾符修飾方法，那么，當(dāng)一個線程使用到了被synchronized 修飾的方法，那么其他線程都必須等待，直至這個線程釋放了鎖，其他的線程才可以使用。
native:當(dāng)此修飾符修飾方法，那么這個方法就是一個java調(diào)用非java代碼的接口。 此方法的實(shí)現(xiàn)由非java語言實(shí)現(xiàn)，比如說C、C++等。這個待征并非java所特有，很多其它 的編程語言都有這一機(jī)制。
strictfp:當(dāng)此修飾符修飾方法。那么，在此方法內(nèi)所有運(yùn)算都是精確的，主要是用來 精確浮點(diǎn)。4.6 作用在字段上
public:當(dāng)此修飾符修飾字段。那么，這個字段將對外保持公開。也就是說，對任何 包下的任何類都是可用的。
private:當(dāng)此修飾符修飾字段。那么，這個字段將對外不公開。也就是說，除類型 創(chuàng)建者和類型內(nèi)部方法之外的任何元素都不能訪問。
protected:當(dāng)此修飾符修飾字段。那么，這個字段將對外保持半公開。可以理解為： 同包、子類和本身可以訪問。當(dāng)然，這里要注意一下，不同包下的子類不能訪問。
static:當(dāng)此修飾符修飾字段。那么，這個字段可以在沒有創(chuàng)建對象的情況下進(jìn)來訪問 只要類被加載了，就可以通過類名去進(jìn)行訪問。
final:當(dāng)此修飾符修飾字段。那么，這個字段一旦賦值，這個字段的值就無法改變。 不能賦值。一般在程序中多個地方使用到共同的數(shù)據(jù)，且該數(shù)據(jù)不會改變，此時我們專門定 義全局的常量。
transient:當(dāng)此修飾符修飾字段。標(biāo)記為transient的變量，在對象存儲時，這些變量 狀態(tài)不會被持久化。當(dāng)對象序列化的保存在存儲器上時，不希望有些字段數(shù)據(jù)被保存，為了保證 安全性，可以把這些字段聲明為transien
volatile:當(dāng)此修飾符修飾字段。在每次線程訪問時，都強(qiáng)迫從共享內(nèi)存中重讀該成員 變量值。而且，當(dāng)成員變量發(fā)生變化時，強(qiáng)迫線程將變化值回寫到共享內(nèi)存中。4.7 作用在參數(shù)上
當(dāng)final作用在參數(shù)上，那么如果定義的是基本類型，那么在這個方法的內(nèi)部，基本類型 的值不能改變。但如果定義的是引用類型的變量，那么引用類型變量的引用不能改變，但引用類 型變量的值可以改變。5. 總結(jié) 5.1 關(guān)于 private、protected、public以及default
- protected修飾符所修飾的類（這句話中指父類）屬成員變量和方法，只可以被子類訪問，而不管子類是不是和父類位于同一個包中。default修飾符所修飾的類屬成員變量和方法，只可被同一個包中的其他類訪問，而不管其他類是不是該類的子類。protected屬于子類限制修飾符，而default屬于包限制修飾符。5.2 關(guān)于 final 5.2.1 final 參數(shù)
final來修飾方法參數(shù)的原因是防止方法參數(shù)在調(diào)用時被改變，主要是這個原因，但可能會有歧
義，需要注意的點(diǎn)：
1. 在final修飾的方法參數(shù)中，如果修飾的是基本類型，那么在這個方法的內(nèi)部，基本類型
的值是不能夠改變的.
2. 在final修飾的方法參數(shù)中，如果修飾的是引用類型的變量，引用類型變量所指的引用是
不能夠改變的，但是引用類型變量的值是可以改變的。
5.2.2 final 其它情況
- 如果final修飾類，這個類不可以從這個類繼承，或者不允許其他任何人采取這種操作
- 如果修飾變量，那么這個變量一旦被賦值，就不可以被改變。5.3 abstract 和 interface
1.理解抽象類：指的是將某一事物的特性抽象出來，多帶帶拎出來，進(jìn)行類型隱藏，對某一事物的 行為抽象描述，但這組行為卻能夠有任意個可能的具體實(shí)現(xiàn)方式，這就是這個抽象描述就是抽 象類。
2.interface是一種特殊形式的abstract class
3.abstract class表示的是一種繼承關(guān)系，一個類只能使用一次繼承關(guān)系。但一個類可以實(shí)現(xiàn) 多個interface.可能是java語言設(shè)計者對多重繼承的一種折中考慮。
4.如果有必要，請在abstract class中定義默認(rèn)行為。
5.abstract class和interface是Java語言中的兩種定義抽象類的方式，它們之間有很大的相 似性。但是對于它們的選擇卻又往往反映出對于問題領(lǐng)域中的概念本質(zhì)的理解、對于設(shè)計意圖 的反映是否正確、合理，因為它們表現(xiàn)了概念間的不同的關(guān)系（雖然都能夠?qū)崿F(xiàn)需求的功能)。 這其實(shí)也是語言的一種的慣用法，5.5 static
1.static修飾的靜態(tài)方法會隨著類的定義而被分配和裝載入內(nèi)存中，編譯器只為整個類創(chuàng)建了一
個靜態(tài)變量的副本，也就是只分配一個內(nèi)存空間，雖然可能有多個實(shí)例，但這些實(shí)例共享該內(nèi)
存，特別值得注意的是，任何一個對象對靜態(tài)數(shù)據(jù)成員的修改，都會影響其它對象。
2.靜態(tài)不能引用非靜態(tài)這一特性，是由于靜態(tài)的會隨著類的定義而被分配和裝載入內(nèi)存中這一關(guān)鍵
點(diǎn)決定的；如果靜態(tài)引用了非靜態(tài)的，根本無法從內(nèi)存中找到非靜態(tài)的代碼段，勢必會出錯，這
種做法是Java虛擬機(jī)決不允許的
5.6 關(guān)于strictfp
strictfp 的意思是FP-strict，也就是說精確浮點(diǎn)的意思。在Java虛擬機(jī)進(jìn)行浮點(diǎn)運(yùn) 算時,如果沒有指定strictfp關(guān)鍵字時，Java的編譯器以及運(yùn) 行環(huán)境在對浮點(diǎn)運(yùn)算的表達(dá)式 是采取一種近似于我行我素的行為來完成這些操作，以致于得到的結(jié)果往往無法令你滿意。而 一旦使用了strictfp來聲明一個 類、接口或者方法時，那么所聲明的范圍內(nèi)Java的編譯器以 及運(yùn)行環(huán)境會完全依照浮點(diǎn)規(guī)范IEEE-754來執(zhí)行。因此如果你想讓你的浮點(diǎn)運(yùn)算更加精確,而 且不會因為不同的硬件平臺所執(zhí)行的結(jié)果不一致的話，那就請用關(guān)鍵字strictfp。5.7 關(guān)于transient 和 volatile
1.當(dāng)使用transient修飾符時，就意思著這個變量不會被持久化，所以如果對象在序列化的保存 在存儲器上時，為了安全性，可以把某些不希望被保存的數(shù)據(jù)用transient修飾。
2.volatile具有synchronized的可見性，但不具備原子性，也就是說，線程可以自動發(fā)生
volatile變量的最新值。只有同時滿足如下兩個條件才可以使用volatile變量：
1.對變量的寫操作不信賴于當(dāng)前值。
2.該變量沒有包含在具有其他變量的不變式中
3.實(shí)際上，這些條件表明，可以被寫入 volatile 變量的這些有效值獨(dú)立于任何程序的狀態(tài)， 包括變量的當(dāng)前狀態(tài)。但使用volatile變量的次要原因是其性能：某些情況下，volatile變量同 步機(jī)制的性能要優(yōu)于鎖。volatile 操作不會像鎖一樣造成阻塞，因此，在能夠安全使用 volatile 的情況下，volatile 可以提供一些優(yōu)于鎖的可伸縮特性。如果讀操作的次數(shù)要遠(yuǎn)遠(yuǎn)超 過寫操作，與鎖相比，volatile 變量通常能夠減少同步的性能開銷。
4.與鎖相比，Volatile 變量是一種非常簡單但同時又非常脆弱的同步機(jī)制，它在某些情況下 將提供優(yōu)于鎖的性能和伸縮性。如果嚴(yán)格遵循 volatile 的使用條件 —— 即變量真正獨(dú)立于其他 變量和自己以前的值 —— 在某些情況下可以使用 volatile 代替 synchronized 來簡化代碼。5.8 關(guān)于synchronized
1.synchronized 修飾方法時鎖定的是調(diào)用該方法的對象。它并不能使調(diào)用該方法的多個對象 在執(zhí)行順序上互斥。5.9 關(guān)于內(nèi)部類
1.使用內(nèi)部類最吸引人的原因是：每個內(nèi)部類都能獨(dú)立地繼承一個（接口的）實(shí)現(xiàn)，所以無論外 圍類是否已經(jīng)繼承了某個（接口的）實(shí)現(xiàn)，對于內(nèi)部類都沒有影響。
2.內(nèi)部類使得多重繼承的解決方案變得更加完整。
參考：
深入理解abstract class和interface
正確使用 Volatile 變量
Java中static方法和普通方法的區(qū)別
Java語言中關(guān)鍵字strictfp的用途
JAVA方法中的參數(shù)用final來修飾的效果
詳解內(nèi)部類
如果有侵權(quán)，馬上刪除
文章版權(quán)歸作者所有，未經(jīng)允許請勿轉(zhuǎn)載,若此文章存在違規(guī)行為，您可以聯(lián)系管理員刪除。
轉(zhuǎn)載請注明本文地址：http://specialneedsforspecialkids.com/yun/69560.html
摘要：修飾符包包的概述和使用其實(shí)就是文件夾作用對類進(jìn)行分類管理包的定義格式格式包名多級包用分開范例帶包的類編譯和執(zhí)行手動建包按照以前的格式編譯文件手動創(chuàng)建包建立文件夾然后在下建立文件夾把文件放到包的最里面把文件放到下的這個文件夾下帶包 1 修飾符1.1 包1.1.1 包的概述和使用其實(shí)就是文件夾作用:對類進(jìn)行分類管理...
摘要：老夫的老夫的主頁謝謝閱讀那點(diǎn)事訪問級別修飾符注本文討論的所有情況沒有考慮嵌套類。這種訪問級別是范圍最大的，當(dāng)泥萌使用該修飾符修飾類的成員的時候，代表該成員可以被所有類訪問，即整個項目下都是可以訪問的。 老夫的gayhub老夫的主頁謝謝閱讀 Java那點(diǎn)事-訪問級別修飾符 注：本文討論的所有情況沒有考慮嵌套類。 Java的訪問級別修飾符(Access Level Modifiers)有四...
摘要：外部類要訪問內(nèi)部類的成員，必須創(chuàng)建對象。前提存在一個類或者接口這里的類可以是具體類也可以是抽象類。 1.package關(guān)鍵字的概述及作用(了解) A:為什么要有包 將字節(jié)碼(.class)進(jìn)行分類存放 包其實(shí)就是文件夾 B:包的概述 舉例： 學(xué)生：增加，刪除，修改，查詢 老師：增加，刪除，修改，查詢 ... 方案1：按照功能分 com.heima.add ...
摘要：大家好，小樂繼續(xù)接著上集樂字節(jié)反射之一反射概念與獲取反射源頭這次是之二實(shí)例化對象接口與父類修飾符和屬性一實(shí)例化對象之前我們講解過創(chuàng)建對象的方式有克隆反序列化，再加一種，根據(jù)對象，使用或者構(gòu)造器實(shí)例化對象。 大家好，小樂繼續(xù)接著上集：樂字節(jié)Java反射之一：反射概念與獲取反射源頭Class 這次是之二：實(shí)例化對象、接口與父類、修飾符和屬性 一：實(shí)例化對象 之前我們講解過創(chuàng)建對象的方式,有...
摘要：程序入口方法淺析方法的方法簽名方法簽名講解修飾符類由虛擬機(jī)調(diào)用，為了沒有限制可以自由的調(diào)用，所以采用修飾符。返回值主方法被調(diào)用，將返回值返回給沒有任何意義，因此該方法沒有返回值，所以使用。 java程序入口main（）方法淺析 main（）方法的方法簽名 public static void main(String[] args) 方法簽名講解 ?public修飾符：java類由jav...
閱讀 2322·2021-11-17 09:33
閱讀 848·2021-10-13 09:40
閱讀 579·2019-08-30 15:54
閱讀 786·2019-08-29 15:38
閱讀 2423·2019-08-28 18:15
閱讀 2481·2019-08-26 13:38
閱讀 1847·2019-08-26 13:36
閱讀 2135·2019-08-26 11:36
