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