怎么在java中利用枚举对修饰符进行组合

这篇文章主要介绍了怎么在java中利用枚举对修饰符进行组合，此处通过实例代码给大家介绍的非常详细，对大家的学习或工作具有一定的参考价值，需要的朋友可以参考下：

创新互联公司-专业网站定制、快速模板网站建设、高性价比南明网站开发、企业建站全套包干低至880元,成熟完善的模板库,直接使用。一站式南明网站制作公司更省心,省钱,快速模板网站建设找我们，业务覆盖南明地区。费用合理售后完善，10多年实体公司更值得信赖。

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中利用枚举对修饰符进行组合的内容请搜索创新互联以前的文章或继续浏览下面的相关文章希望大家以后多多支持创新互联！


新闻标题：怎么在java中利用枚举对修饰符进行组合
文章位置：http://cdiso.cn/article/pppgpp.html

其他资讯

联系小谭

企业微信号
友情链接： 重庆网络营销   全网营销   成都微商城   成都网站维护   成都展柜制作   做网站的公司   微信小程序   自贡电信机房   八点广告   雨棚定制   

123ABC 成都网站建设，成都定制网站建设——全心全意建网站公司