枚举java语言中的修饰符组合

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语言中的修饰符组合的更多相关文章

JAVA语言中的修饰符
JAVA语言中的修饰符 -----------------------------------------------01--------------------------------------- ...
关于Java语言中那些修饰符
一.在java中提供的一些修饰符,这些修饰符可以修饰类.变量和方法,在java中常见的修饰符有:abstract(抽象的).static(静态的).public(公共的).protected(受保护的 ...
C#语言中的修饰符
public:公有访问.不受任何限制. private:私有访问.只限于本类成员访问,子类和实例都不能访问. protected:保护访问.只限于本类和子类访问,实例不能访问. internal:内部 ...
2020重新出发，JAVA入门，标识符&修饰符
标识符(Identifier ) 标识符是程序员用来命名变量,方法,类或标签的单词,其实就是我们在开发过程中凡是自己可以命名的一些单词就是标识符标识符命名规则标识符由字母(a-z,A-Z),数字( ...
Java语言中的访问权限修饰符
一个Java应用有很多类,但是有些类,并不希望被其他类使用.每个类中都有数据成员和方法成员,但是并不是每个数据和方法,都允许在其他类中调用.如何能做到访问控制呢?就需要使用访问权限修饰符. Java语 ...
Java中访问修饰符public、private、protecte、default
Java中访问修饰符public.private.protecte.default的意义讲解:public: Java语言中访问限制最宽的修饰符,一般称之为“公共的”.被其修饰的类.属性以及方法不仅 ...
Java中的修饰符
java中的修饰符分为类修饰符,字段修饰符,方法修饰符. 根据功能的不同,主要分为以下几种. 1.权限访问修饰符访问权限的控制常被称为具体实现的隐藏把数据和方法包进类中,以及具体实现的隐藏,常共 ...
Java中final修饰符深入研究
一.开篇本博客来自:http://www.cnblogs.com/yuananyun/ final修饰符是Java中比较简单常用的修饰符,同时也是一个被"误解"较多的修饰符.对很 ...
Java中各种修饰符与访问修饰符
Java中各种修饰符与访问修饰符类: 访问修饰符修饰符 class 类名称 extends 父类名称 implement 接口名称 (访问修饰符与修饰符的位置可以互换) 访问修饰符名称说明备 ...

随机推荐

request.getAttribute()和request.getParameter()两个方法的区别
request.getAttribute()获得的数据必须曾经有过setAttibute()过: 而request.getParameter()获得是客户端POST或者GET请求时所携带的参数的值 g ...
dubbo源码阅读笔记-如何引用远程服务，变成invoker
1 消费端如何通过注册中心获取远程服务的invoker? RegistryDirectory.subscribe从注册中心中获取provider的url,通过DubboProtocol的refer方法 ...
java期末总结
java期末总结: java语言特点:1.简洁有效 2.可移植性 3.面向对象 4.解释型 5.适合分布式计算 6.拥有较好的性能 7.健壮.防患于未然 8.具有多线程处理能力 9.具有较高的安全性 ...
How to solve the error "Field service in com.xx.xxx.xxxx required a bean of type 'com.aa.bb.cc' that could not be found."
When runung a SpringBoot demo, I got a error as following: *************************** APPLICATION ...
关于Oracle报表
1.存储过程中的WHEN OTHERS THEN是什么意思. 异常分很多种类,如NO_FOUND.OTHERS处本应该写异常名称,如果不想把异常分得那么细,可以笼统一点用OTHERS来捕获,即所有异常 ...
代码实现:一个数如果恰好等于它的因子之和，这个数就称为"完数"。例如6=1＋2＋3.第二个完全数是28， //它有约数1、2、4、7、14、28，除去它本身28外，其余5个数相加, //编程找出1000以内的所有完数。
import java.util.ArrayList; import java.util.List; //一个数如果恰好等于它的因子之和,这个数就称为"完数".例如6=1+2+3. ...
Java-Logger日志
<转载于--https://www.cnblogs.com/yorickLi/p/6158405.html> Java中关于日志系统的API,在 java.util.logging 包中, ...
Java Array数组遍历四种方式（包含 Lambda 表达式遍历）
示例代码如下: package com.miracle.luna.lambda; import java.util.Arrays; /** * @Author Miracle Luna * @Date ...
如何实现在Eclipse导入Apache Commons
Apache Commons https://en.wikipedia.org/wiki/Apache_Commons 右键项目->Properties->Java Build Path- ...
缓存融合（Cache Fusion）介绍
概念简单地说,缓存融合就是把Oracle RAC数据库中所有数据库缓存作为一个共享的数据库缓存,并被RAC中的所有节点共享.它是实现RAC的基本技术. 缓存融合主要有如下四个功能: (1) 提供扩展 ...

枚举java语言中的修饰符组合

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

随机推荐

热门专题