package model;

/*22:37 2019/7/20*/

/*

top class的修饰符组合

abstract final public

   2    *  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的修饰符组合

4        *    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的修饰符组合

4         *   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();

}

枚举java语言中的修饰符组合的更多相关文章

  1. JAVA语言中的修饰符

    JAVA语言中的修饰符 -----------------------------------------------01--------------------------------------- ...

  2. 关于Java语言中那些修饰符

    一.在java中提供的一些修饰符,这些修饰符可以修饰类.变量和方法,在java中常见的修饰符有:abstract(抽象的).static(静态的).public(公共的).protected(受保护的 ...

  3. C#语言中的修饰符

    public:公有访问.不受任何限制. private:私有访问.只限于本类成员访问,子类和实例都不能访问. protected:保护访问.只限于本类和子类访问,实例不能访问. internal:内部 ...

  4. 2020重新出发，JAVA入门，标识符&修饰符

    标识符(Identifier ) 标识符是程序员用来命名变量,方法,类或标签的单词,其实就是我们在开发过程中凡是自己可以命名的一些单词就是标识符 标识符命名规则 标识符由字母(a-z,A-Z),数字( ...

  5. Java语言中的访问权限修饰符

    一个Java应用有很多类,但是有些类,并不希望被其他类使用.每个类中都有数据成员和方法成员,但是并不是每个数据和方法,都允许在其他类中调用.如何能做到访问控制呢?就需要使用访问权限修饰符. Java语 ...

  6. Java中访问修饰符public、private、protecte、default

    Java中访问修饰符public.private.protecte.default的意义讲解:public: Java语言中访问限制最宽的修饰符,一般称之为“公共的”.被其修饰的类.属性以及方法不 仅 ...

  7. Java中的 修饰符

    java中的修饰符分为类修饰符,字段修饰符,方法修饰符. 根据功能的不同,主要分为以下几种. 1.权限访问修饰符  访问权限的控制常被称为具体实现的隐藏 把数据和方法包进类中,以及具体实现的隐藏,常共 ...

  8. Java中final修饰符深入研究

    一.开篇 本博客来自:http://www.cnblogs.com/yuananyun/ final修饰符是Java中比较简单常用的修饰符,同时也是一个被"误解"较多的修饰符.对很 ...

  9. Java中各种修饰符与访问修饰符

    Java中各种修饰符与访问修饰符 类: 访问修饰符 修饰符 class 类名称 extends 父类名称 implement 接口名称 (访问修饰符与修饰符的位置可以互换) 访问修饰符 名称 说明 备 ...

随机推荐

  1. Value '0000-00-00' can not be represented as java.sql.Date解决办法

    java.sql.SQLException: Value '0000-00-00 00:00:00' can not be represented as java.sql.Timestamp 问题描述 ...

  2. akka 的集群访问方式

    akka  中采用startProxy分区代理 访问 ,跟使用shardRegion 来访问的区别 这两种访问方式是不是重了呢. 而另外这是一个单例代理 private fun startUniver ...

  3. 20175212童皓桢 实验四 Android程序设计

    20175212童皓桢 实验四 Android程序设计 实验内容 参考<Java和Android开发学习指南(第二版)(EPUBIT,Java for Android 2nd)>并完成相关 ...

  4. DS博客作业08—课程总结

    1.当初你是如何做出选择计算机专业的决定的? 开始时我选择的专业就是网络/物联网,计算机专业是一个充满创造性的专业 2.对比开篇博客,哪些方面还存在哪些不足? 这个人就像戏台上的老将军,全身插满fla ...

  5. 引用&指针交换函数实践

    实践如下: #include <iostream> using namespace std; // 普通交换,注意这里的ab值,在具体调用时是基本数据的拷贝,原始数据不会变化 // 因此这 ...

  6. android 给控件使用自定义字体Typeface

    第一步:将字体资源放在assets 资源文件夹下: 第二步:获取字体资源 Typeface mTf = Typeface.createFromAsset(c.getAssets(), "Op ...

  7. 如何解决错误【selenium.common.exceptions.SessionNotCreatedException】

    如何解决错误[selenium.common.exceptions.SessionNotCreatedException]   [问题起因] 2018年12月26日晚,启动我的pycharm准备学习s ...

  8. 通过Precision/Recall判断分类结果偏差极大时算法的性能

    当我们对某些问题进行分类时,真实结果的分布会有明显偏差. 例如对是否患癌症进行分类,testing set 中可能只有0.5%的人患了癌症. 此时如果直接数误分类数的话,那么一个每次都预测人没有癌症的 ...

  9. 【3】火狐中: radio被点击以后，重刷页面，不会选择默认的radio

    1.问题:火狐中radio (单选框)点击以后,重新刷新页面,不会选择默认的radio 解决:form表单中添加:autocomplete="off" autocomplete 属 ...

  10. Nova rebuild for boot from volume issue

    目录 文章目录 目录 Nova boot from volume Rebuild Instance Rebuild for boot from volume Nova boot from volume ...