欧美bbbwbbbw肥妇,免费乱码人妻系列日韩,一级黄片

枚舉java語(yǔ)言中的修飾符組合的實(shí)例代碼

 更新時(shí)間：2019年07月21日 09:56:57   作者：返回主頁(yè) 張星爍  
這篇文章主要介紹了枚舉java語(yǔ)言中的修飾符組合，本文通過(guò)實(shí)例代碼給大家介紹的非常詳細(xì)，具有一定的參考借鑒價(jià)值,需要的朋友可以參考下

枚舉java語(yǔ)言中的修飾符組合，代碼如下所示：

package model;
/*22:37 2019/7/20*/
/*
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{}
關(guān)于constructor的修飾符組合
abstract [DEFAULT] protected public
關(guān)于field的修飾符組合
    *  2   *   2   *   2     *  2
權(quán)限           靜態(tài)的     瞬態(tài)的     同步的
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
關(guān)于method的修飾符組合
    *  2     *  2   *   2   *    2     *  2
權(quán)限                   靜態(tài)的       同步的     本地的
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
*/
/**
 * 這個(gè)類(lèi)列舉了所有的用于字段的修飾符組合
 *         ├構(gòu)造器的修飾符組合
 *         └方法的修飾符組合
 * @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語(yǔ)言提供了很多修飾符，主要分為以下兩類(lèi)：

  • 訪問(wèn)修飾符
  • 非訪問(wèn)修飾符

修飾符用來(lái)定義類(lèi)、方法或者變量，通常放在語(yǔ)句的最前端。我們通過(guò)下面的例子來(lái)說(shuō)明：

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

訪問(wèn)控制修飾符

Java中，可以使用訪問(wèn)控制符來(lái)保護(hù)對(duì)類(lèi)、變量、方法和構(gòu)造方法的訪問(wèn)。Java 支持 4 種不同的訪問(wèn)權(quán)限。

  • default (即缺省，什么也不寫(xiě)）: 在同一包內(nèi)可見(jiàn)，不使用任何修飾符。使用對(duì)象：類(lèi)、接口、變量、方法。
  • private : 在同一類(lèi)內(nèi)可見(jiàn)。使用對(duì)象：變量、方法。 注意：不能修飾類(lèi)（外部類(lèi)）
  • public : 對(duì)所有類(lèi)可見(jiàn)。使用對(duì)象：類(lèi)、接口、變量、方法
  • protected : 對(duì)同一包內(nèi)的類(lèi)和所有子類(lèi)可見(jiàn)。使用對(duì)象：變量、方法。 注意：不能修飾類(lèi)（外部類(lèi)）。

總結(jié)

以上所述是小編給大家介紹的枚舉java語(yǔ)言中的修飾符組合的實(shí)例代碼，希望對(duì)大家有所幫助，如果大家有任何疑問(wèn)歡迎給我留言，小編會(huì)及時(shí)回復(fù)大家的！

相關(guān)文章

  • SpringBoot利用jackson格式化時(shí)間的三種方法

    SpringBoot利用jackson格式化時(shí)間的三種方法

    日常開(kāi)發(fā)過(guò)程中經(jīng)常會(huì)使用json進(jìn)行數(shù)據(jù)的傳輸,這就涉及到了對(duì)象和json的相互轉(zhuǎn)化,常用的解決方案有：Jackson（推薦）、谷歌的Gson、阿里的Fastjson,這篇文章主要給大家介紹了關(guān)于SpringBoot如何利用jackson格式化時(shí)間的相關(guān)資料,需要的朋友可以參考下
    2021-06-06
  • Spring框架基于注解開(kāi)發(fā)CRUD詳解

    Spring框架基于注解開(kāi)發(fā)CRUD詳解

    這篇文章主要為大家詳細(xì)介紹了Spring框架基于注解開(kāi)發(fā)CRUD，文中示例代碼介紹的非常詳細(xì)，具有一定的參考價(jià)值，感興趣的小伙伴們可以參考一下
    2022-08-08
  • spring bean標(biāo)簽的primary屬性用法講解

    spring bean標(biāo)簽的primary屬性用法講解

    這篇文章主要介紹了spring bean標(biāo)簽的primary屬性用法講解，具有很好的參考價(jià)值，希望對(duì)大家有所幫助。如有錯(cuò)誤或未考慮完全的地方，望不吝賜教
    2021-09-09
  • Java 深入淺出分析Synchronized原理與Callable接口

    Java 深入淺出分析Synchronized原理與Callable接口

    Synchronized關(guān)鍵字解決的是多個(gè)線程之間訪問(wèn)資源的同步性，synchronized關(guān)鍵字可以保證被它修飾的方法或者代碼塊在任意時(shí)刻只能有一個(gè)線程執(zhí)行，Runnable是執(zhí)行工作的獨(dú)立任務(wù)，但是不返回任何值。如果我們希望任務(wù)完成之后有返回值，可以實(shí)現(xiàn)Callable接口
    2022-03-03
  • IntelliJ IDEA 部署 Web 項(xiàng)目,看這一篇夠了！

    IntelliJ IDEA 部署 Web 項(xiàng)目,看這一篇夠了！

    這篇文章主要介紹了IntelliJ IDEA 部署 Web 項(xiàng)目的圖文教程，本文通過(guò)圖文并茂的形式給大家介紹的非常詳細(xì)，對(duì)大家的學(xué)習(xí)或工作具有一定的參考借鑒價(jià)值,需要的朋友可以參考下
    2020-05-05
  • Java中的HashMap集合深度解析

    Java中的HashMap集合深度解析

    這篇文章主要介紹了Java中的HashMap集合深度解析, HashMap可以說(shuō)是Java中最常用的集合類(lèi)框架之一,是Java語(yǔ)言中非常典型的數(shù)據(jù)結(jié)構(gòu),我們總會(huì)在不經(jīng)意間用到它,很大程度上方便了我們?nèi)粘ｉ_(kāi)發(fā),需要的朋友可以參考下
    2023-09-09
  • 使用Java通過(guò)OAuth協(xié)議驗(yàn)證發(fā)送微博的教程

    使用Java通過(guò)OAuth協(xié)議驗(yàn)證發(fā)送微博的教程

    這篇文章主要介紹了使用Java通過(guò)OAuth協(xié)議驗(yàn)證發(fā)送微博的教程,使用到了新浪微博為Java開(kāi)放的API weibo4j,需要的朋友可以參考下
    2016-02-02
  • JavaWeb文件上傳開(kāi)發(fā)實(shí)例

    JavaWeb文件上傳開(kāi)發(fā)實(shí)例

    這篇文章主要為大家詳細(xì)介紹了JavaWeb文件上傳開(kāi)發(fā)實(shí)例，如何進(jìn)行文件上傳操作，感興趣的小伙伴們可以參考一下
    2016-08-08
  • Java大文件分片上傳超詳細(xì)教程(minio版)

    Java大文件分片上傳超詳細(xì)教程(minio版)

    Minio是一個(gè)開(kāi)源的分布式對(duì)象存儲(chǔ)系統(tǒng),它允許用戶(hù)在存儲(chǔ)服務(wù)上存儲(chǔ)和檢索數(shù)據(jù),下面這篇文章主要給大家介紹了關(guān)于Java大文件分片上傳(minio版)的相關(guān)資料,文中通過(guò)代碼介紹的非常詳細(xì),需要的朋友可以參考下
    2024-08-08
  • Spring RestTemplate簡(jiǎn)化HTTP通信實(shí)現(xiàn)功能探究

    Spring RestTemplate簡(jiǎn)化HTTP通信實(shí)現(xiàn)功能探究

    這篇文章主要為大家介紹了Spring框架中的RestTemplate，如果你是個(gè)Java程序員，那么你肯定知道Spring框架的重要性，在Spring的眾多工具中，RestTemplate是用來(lái)簡(jiǎn)化HTTP通信的一個(gè)強(qiáng)大工具
    2024-01-01

最新評(píng)論