怎么在java中利用枚舉對修飾符進行組合

這篇文章主要介紹了怎么在java中利用枚舉對修飾符進行組合，此處通過實例代碼給大家介紹的非常詳細，對大家的學習或工作具有一定的參考價值，需要的朋友可以參考下：

Java的特點有哪些

Java的特點有哪些 1.Java語言作為靜態面向對象編程語言的代表，實現了面向對象理論，允許程序員以優雅的思維方式進行復雜的編程。 2.Java具有簡單性、面向對象、分布式、安全性、平臺獨立與可移植性、動態性等特點。 3.使用Java可以編寫桌面應用程序、Web應用程序、分布式系統和嵌入式系統應用程序等。

package model;
top class的修飾符組合
abstract final public
  * 2 * 2
warning:
abstract final 沖突
最終,共有2*(2*2-1)=6種修飾符組合用于top class
*/
/*
public abstract class PublicAbstractClass{}
public final  class PublicFinalClass{}
    abstract class AbstractClass{}
    final  class FinalClass{}
public     class PublicClass{}
        class Class{}
關于constructor的修飾符組合
abstract [DEFAULT] protected public
關于field的修飾符組合
    *  2   *   2   *   2     *  2
權限           靜態的     瞬態的     同步的
private    缺省     缺省     缺省      缺省
缺省    (not final) (not static) (not transient) (not volatile)
protected
public     final    static    transient    volatile
warning:
volatile final 沖突
最終,共有4*2*2*(2*2-1)=48種修飾符組合用于field
關于method的修飾符組合
    *  2     *  2   *   2   *    2     *  2
權限                   靜態的       同步的     本地的
private   缺省      缺省     缺省        缺省     缺省
缺省  (not abstract)  (not final) (not static) (not synchronized) (not native)
protected
public   abstract     final    static    synchronized    native
warning:
abstract 和 private 沖突
abstract 和 final 沖突
abstract 和 synchronized 沖突
abstract 和 static 沖突
abstract 和 native 沖突
所以abstract method 的修飾符組合只有三種:
     abstract
protected abstract
public  abstract
最終,共有4*2*2*2*2+3=67中修飾符組合用于method
*/
/**
 * 這個類列舉了所有的用于字段的修飾符組合
 *         ├構造器的修飾符組合
 *         └方法的修飾符組合
 * @author zhangxingshuo
 */
abstract class A {
  /*fields*/
  /*transient and volatile*/
  private        transient volatile int privateTransientVolatileIntMemberField;
              transient volatile int transientVolatileIntMemberField;
  protected       transient volatile int protectedTransientVolatileIntMemberField;
  public         transient volatile int publicTransientVolatileIntMemberField;
//  private  final    transient volatile int privateFinalTransientVolatileIntMemberField=0;
//       final    transient volatile int finalTransientVolatileIntMemberField=0;
//  protected final    transient volatile int protectedFinalTransientVolatileIntMemberField=0;
//  public  final    transient volatile int publicFinalTransientVolatileIntMemberField=0;
  private     static transient volatile int privateStaticTransientVolatileIntMemberField;
          static transient volatile int staticTransientVolatileIntMemberField;
  protected    static transient volatile int protectedStaticTransientVolatileIntMemberField;
  public     static transient volatile int publicStaticTransientVolatileIntMemberField;
//  private  final static transient volatile int privateFinalStaticTransientVolatileIntMemberField=0;
//       final static transient volatile int finalStaticTransientVolatileIntMemberField=0;
//  protected final static transient volatile int protectedFinalStaticTransientVolatileIntMemberField=0;
//  public  final static transient volatile int publicFinalStaticTransientVolatileIntMemberField=0;
  /*not transient and volatile*/
  private              volatile int privateVolatileIntMemberField;
                    volatile int VolatileIntMemberField;
  protected             volatile int protectedVolatileIntMemberField;
  public               volatile int publicVolatileIntMemberField;
//  private  final          volatile int privateFinalVolatileIntMemberField=0;
//       final          volatile int finalVolatileIntMemberField=0;
//  protected final          volatile int protectedFinalVolatileIntMemberField=0;
//  public  final          volatile int publicFinalVolatileIntMemberField=0;
  private     static       volatile int privateStaticVolatileIntMemberField;
          static       volatile int staticVolatileIntMemberField;
  protected    static       volatile int protectedStaticVolatileIntMemberField;
  public     static       volatile int publicStaticVolatileIntMemberField;
//  private  final static       volatile int privateFinalStaticVolatileIntMemberField=0;
//       final static       volatile int finalStaticVolatileIntMemberField=0;
//  protected final static       volatile int protectedFinalStaticVolatileIntMemberField=0;
//  public  final static       volatile int publicFinalStaticVolatileIntMemberField=0;
  /*transient and not volatile*/
  private        transient      int privateTransientIntMemberField;
              transient      int transientIntMemberField;
  protected       transient      int protectedTransientIntMemberField;
  public         transient      int publicTransientIntMemberField;
  private  final    transient      int privateFinalTransientIntMemberField=0;
       final    transient      int finalTransientIntMemberField=0;
  protected final    transient      int protectedFinalTransientIntMemberField=0;
  public  final    transient      int publicFinalTransientIntMemberField=0;
  private     static transient      int privateStaticTransientIntMemberField;
          static transient      int staticTransientIntMemberField;
  protected    static transient      int protectedStaticTransientIntMemberField;
  public     static transient      int publicStaticTransientIntMemberField;
  private  final static transient      int privateFinalStaticTransientIntMemberField=0;
       final static transient      int finalStaticTransientIntMemberField=0;
  protected final static transient      int protectedFinalStaticTransientIntMemberField=0;
  public  final static transient      int publicFinalStaticTransientIntMemberField=0;
  /*not transient and not volatile*/
  private        int privateIntMemberField;
              int intMemberField;
  protected       int protectedIntMemberField;
  public         int publicIntMemberField;
  private  final    int privateFinalIntMemberField=0;
       final    int finalIntMemberField=0;
  protected final    int protectedFinalIntMemberField=0;
  public  final    int publicFinalIntMemberField=0;
  private     static int privateStaticIntMemberField;
          static int staticIntMemberField;
  protected    static int protectedStaticIntMemberField;
  public     static int publicStaticIntMemberField;
  private  final static int privateFinalStaticIntMemberField=0;
       final static int finalStaticIntMemberField=0;
  protected final static int protectedFinalStaticIntMemberField=0;
  public  final static int publicFinalStaticIntMemberField=0;
  /*constructors*/
  private  A(         ){}
       A(int i      ){}
  protected A(int i,int j   ){}
  public  A(int i,int j,int k){}
  /*methods*/
  private      final static synchronized native void privateFinalStaticSynchronizedNativeVoidMethod();
            final static synchronized native void    finalStaticSynchronizedNativeVoidMethod();
  protected     final static synchronized native void protectedFinalStaticSynchronizedNativeVoidMethod();
  public       final static synchronized native void publicFinalStaticSynchronizedNativeVoidMethod();
  private          static synchronized native void privateStaticSynchronizedNativeVoidMethod();
               static synchronized native void    staticSynchronizedNativeVoidMethod();
  protected         static synchronized native void protectedStaticSynchronizedNativeVoidMethod();
  public          static synchronized native void publicStaticSynchronizedNativeVoidMethod();
  private      final     synchronized native void privateFinalSynchronizedNativeVoidMethod();
            final     synchronized native void    finalSynchronizedNativeVoidMethod();
  protected     final     synchronized native void protectedFinalSynchronizedNativeVoidMethod();
  public       final     synchronized native void publicFinalSynchronizedNativeVoidMethod();
  private             synchronized native void privateSynchronizedNativeVoidMethod();
                   synchronized native void    synchronizedNativeVoidMethod();
  protected            synchronized native void protectedSynchronizedNativeVoidMethod();
  public              synchronized native void publicSynchronizedNativeVoidMethod();
  private      final static       native void privateFinalStaticNativeVoidMethod();
            final static       native void    finalStaticNativeVoidMethod();
  protected     final static       native void protectedFinalStaticNativeVoidMethod();
  public       final static       native void publicFinalStaticNativeVoidMethod();
  private          static       native void privateStaticNativeVoidMethod();
               static       native void    staticNativeVoidMethod();
  protected         static       native void protectedStaticNativeVoidMethod();
  public          static       native void publicStaticNativeVoidMethod();
  private      final           native void privateFinalNativeVoidMethod();
            final           native void    finalNativeVoidMethod();
  protected     final           native void protectedFinalNativeVoidMethod();
  public       final           native void publicFinalNativeVoidMethod();
  private                    native void privateNativeVoidMethod();
                         native void nativeVoidMethod();
  protected                   native void protectedNativeVoidMethod();
  public                    native void publicNativeVoidMethod();
  private      final static synchronized    void privateFinalStaticSynchronizedVoidMethod(){};
            final static synchronized    void    finalStaticSynchronizedVoidMethod(){};
  protected     final static synchronized    void protectedFinalStaticSynchronizedVoidMethod(){};
  public       final static synchronized    void publicFinalStaticSynchronizedVoidMethod(){};
  private          static synchronized    void privateStaticSynchronizedVoidMethod(){};
               static synchronized    void    staticSynchronizedVoidMethod(){};
  protected         static synchronized    void protectedStaticSynchronizedVoidMethod(){};
  public          static synchronized    void publicStaticSynchronizedVoidMethod(){};
  private      final     synchronized    void privateFinalSynchronizedVoidMethod(){};
            final     synchronized    void    finalSynchronizedVoidMethod(){};
  protected     final     synchronized    void protectedFinalSynchronizedVoidMethod(){};
  public       final     synchronized    void publicFinalSynchronizedVoidMethod(){};
  private             synchronized    void privateSynchronizedVoidMethod(){};
                   synchronized    void    synchronizedVoidMethod(){};
  protected            synchronized    void protectedSynchronizedVoidMethod(){};
  public              synchronized    void publicSynchronizedVoidMethod(){};
  private      final static           void privateFinalStaticVoidMethod(){};
            final static           void    finalStaticVoidMethod(){};
  protected     final static           void protectedFinalStaticVoidMethod(){};
  public       final static           void publicFinalStaticVoidMethod(){};
  private          static           void privateStaticVoidMethod(){};
               static           void    staticVoidMethod(){};
  protected         static           void protectedStaticVoidMethod(){};
  public          static           void publicStaticVoidMethod(){};
  private      final               void privateFinalVoidMethod(){};
            final               void    finalVoidMethod(){};
  protected     final               void protectedFinalVoidMethod(){};
  public       final               void publicFinalVoidMethod(){};
  private                       void privateVoidMethod(){};
                             void    voidMethod(){};
  protected                      void protectedVoidMethod(){};
  public                        void publicVoidMethod(){};
//  private  abstract final static synchronized native void privateAbstractFinalStaticSynchronizedNativeVoidMethod(){};
//       abstract final static synchronized native void    abstractFinalStaticSynchronizedNativeVoidMethod(){};
//  protected abstract final static synchronized native void protectedAbstractFinalStaticSynchronizedNativeVoidMethod(){};
//  public  abstract final static synchronized native void publicAbstractFinalStaticSynchronizedNativeVoidMethod(){};
//  private  abstract    static synchronized native void privateAbstractStaticSynchronizedNativeVoidMethod();
//       abstract    static synchronized native void    abstractStaticSynchronizedNativeVoidMethod();
//  protected abstract    static synchronized native void protectedAbstractStaticSynchronizedNativeVoidMethod();
//  public  abstract    static synchronized native void publicAbstractStaticSynchronizedNativeVoidMethod();
//  private  abstract final     synchronized native void privateAbstractFinalSynchronizedNativeVoidMethod(){};
//       abstract final     synchronized native void    abstractFinalSynchronizedNativeVoidMethod(){};
//  protected abstract final     synchronized native void protectedAbstractFinalSynchronizedNativeVoidMethod(){};
//  public  abstract final     synchronized native void publicAbstractFinalSynchronizedNativeVoidMethod(){};
//  private  abstract        synchronized native void privateAbstractSynchronizedNativeVoidMethod(){};
//       abstract        synchronized native void    abstractSynchronizedNativeVoidMethod(){};
//  protected abstract        synchronized native void protectedAbstractSynchronizedNativeVoidMethod(){};
//  public  abstract        synchronized native void publicAbstractSynchronizedNativeVoidMethod(){};
//  private  abstract final static       native void privateAbstractFinalStaticNativeVoidMethod(){};
//       abstract final static       native void    abstractFinalStaticNativeVoidMethod(){};
//  protected abstract final static       native void protectedAbstractFinalStaticNativeVoidMethod(){};
//  public  abstract final static       native void publicAbstractFinalStaticNativeVoidMethod(){};
//  private  abstract    static       native void privateAbstractStaticNativeVoidMethod(){};
//       abstract    static       native void    abstractStaticNativeVoidMethod(){};
//  protected abstract    static       native void protectedAbstractStaticNativeVoidMethod(){};
//  public  abstract    static       native void publicAbstractStaticNativeVoidMethod(){};
//  private  abstract final           native void privateAbstractFinalNativeVoidMethod(){};
//       abstract final           native void    abstractFinalNativeVoidMethod(){};
//  protected abstract final           native void protectedAbstractFinalNativeVoidMethod(){};
//  public  abstract final           native void publicAbstractFinalNativeVoidMethod(){};
//  private  abstract              native void privateAbstractNativeVoidMethod();
//       abstract              native void    abstractNativeVoidMethod();
//  protected abstract              native void protectedAbstractNativeVoidMethod();
//  public  abstract              native void publicAbstractNativeVoidMethod();
//  private  abstract final static synchronized    void privateAbstractFinalStaticSynchronizedVoidMethod();
//       abstract final static synchronized    void    abstractFinalStaticSynchronizedVoidMethod();
//  protected abstract final static synchronized    void protectedAbstractFinalStaticSynchronizedVoidMethod();
//  public  abstract final static synchronized    void publicAbstractFinalStaticSynchronizedVoidMethod();
//  private  abstract    static synchronized    void privateAbstractStaticSynchronizedVoidMethod();
//       abstract    static synchronized    void    abstractStaticSynchronizedVoidMethod();
//  protected abstract    static synchronized    void protectedAbstractStaticSynchronizedVoidMethod();
//  public  abstract    static synchronized    void publicAbstractStaticSynchronizedVoidMethod();
//  private  abstract final     synchronized    void privateAbstractFinalSynchronizedVoidMethod(){};
//       abstract final     synchronized    void    abstractFinalSynchronizedVoidMethod(){};
//  protected abstract final     synchronized    void protectedAbstractFinalSynchronizedVoidMethod(){};
//  public  abstract final     synchronized    void publicAbstractFinalSynchronizedVoidMethod(){};
//  private  abstract        synchronized    void privateAbstractSynchronizedVoidMethod();
//       abstract        synchronized    void    abstractSynchronizedVoidMethod();
//  protected abstract        synchronized    void protectedAbstractSynchronizedVoidMethod();
//  public  abstract        synchronized    void publicAbstractSynchronizedVoidMethod();
//  private  abstract final static           void privateAbstractFinalStaticVoidMethod;
//       abstract final static           void    abstractFinalStaticVoidMethod;
//  protected abstract final static           void protectedAbstractFinalStaticVoidMethod;
//  public  abstract final static           void publicAbstractFinalStaticVoidMethod;
//  private  abstract    static           void privateAbstractStaticVoidMethod();
//       abstract    static           void    abstractStaticVoidMethod();
//  protected abstract    static           void protectedAbstractStaticVoidMethod();
//  public  abstract    static           void publicAbstractStaticVoidMethod();
//  private  abstract final               void privateAbstractFinalVoidMethod();
//       abstract final               void    abstractFinalVoidMethod();
//  protected abstract final               void protectedAbstractFinalVoidMethod();
//  public  abstract final               void publicAbstractFinalVoidMethod();
//  private  abstract                  void privateAbstractVoidMethod();
       abstract                  void    abstractVoidMethod();
  protected abstract                  void protectedAbstractVoidMethod();
  public  abstract                  void publicAbstractVoidMethod();
}

ps：Java 修飾符

Java語言提供了很多修飾符，主要分為以下兩類：

• 訪問修飾符

• 非訪問修飾符
  

修飾符用來定義類、方法或者變量，通常放在語句的最前端。我們通過下面的例子來說明：

public class className {
  // ...
}
private boolean myFlag;
static final double weeks = 9.5;
protected static final int BOXWIDTH = 42;
public static void main(String[] arguments) {
  // 方法體
}

訪問控制修飾符

Java中，可以使用訪問控制符來保護對類、變量、方法和構造方法的訪問。Java 支持 4 種不同的訪問權限。

• default (即缺省，什么也不寫）: 在同一包內可見，不使用任何修飾符。使用對象：類、接口、變量、方法。

• private : 在同一類內可見。使用對象：變量、方法。 注意：不能修飾類（外部類）

• public : 對所有類可見。使用對象：類、接口、變量、方法

• protected : 對同一包內的類和所有子類可見。使用對象：變量、方法。 注意：不能修飾類（外部類）。

到此這篇關于怎么在java中利用枚舉對修飾符進行組合的文章就介紹到這了,更多相關怎么在java中利用枚舉對修飾符進行組合的內容請搜索億速云以前的文章或繼續瀏覽下面的相關文章希望大家以后多多支持億速云！