精华内容
下载资源
问答
  • java枚举类型初始化

    2021-06-19 15:42:23
    Buffer在java.nio中被定义为抽象类: 我们可以将Buffer理解为一个数组的封装,我们最常用的ByteBuffer对应的数据结构就是byte[] 属性 Buffer中有4个非常重要的属性:capacity、limit、position、mark Java高频面试...

    前言

    kafka的外在表现很像消息系统,允许发布和订阅消息流,但是它和传统的消息系统有很大的差异:

    • 首先,kafka是个现代分布式系统,以集群的方式运行,可以自由伸缩

    • 其次,kafka可以按照要求存储数据,保存多久都可以

    • 第三,流式处理将数据处理的层次提示到了新高度,消息系统只会传递数据。kafka的流式处理能力可以让我们用很少的代码就能动态的处理派生流和数据集。所以,kafka不仅仅是个消息中间件

    kafka不仅仅是个消息中间件,同时它是个流平台,这个平台上可以发布和订阅数据流(kafka的流,有一个单独的包stream的处理),并把它们保存起来,进行处理,这个就是kafka作者的设计理念。今天之所以要聊Kafka,是因为前不久我们公司来了位阿里P8大神,在看完他的手写“Kafka笔记”,我只能用两个字来形容:膜拜!崇拜!

    image.png

    一、网络编程基础回顾

    1. Socket

    Socket本身有“插座”的意思,不是Java中特有的概念,而是一个语言无关的标准,任何可以实现网络编程的编程语言都有Socket。在Linux环境下,用于表示进程间网络通信的特殊文件类型,其本质为内核借助缓冲区形成的伪文件。既然是文件,那么理所当然的,我们可以使用文件描述符引用套接字。

    与管道类似的,Linux系统将其封装成文件的目的是为了统一接口,使得读写套接字和读写文件的操作一致。区别是管道主要应用于本地进程间通信,而套接字多应用于网络进程间数据的传递。

    可以这么理解:Socket就是网络上的两个应用程序通过一个双向通信连接实现数据交换的编程接口API。

    Socket通信的基本流程具体步骤如下所示:

    (1)服务端通过Listen开启监听,等待客户端接入。

    (2)客户端的套接字通过Connect连接服务器端的套接字,服务端通过Accept接收客户端连接。在connect-accept过程中,操作系统将会进行三次握手。

    (3)客户端和服务端通过writeread发送和接收数据,操作系统将会完成TCP数据的确认、重发等步骤。

    (4)通过close关闭连接,操作系统会进行四次挥手。

    针对Java编程语言,java.net包是网络编程的基础类库。其中ServerSocketSocket是网络编程的基础类型。

    SeverSocket是服务端应用类型。Socket是建立连接的类型。当连接建立成功后,服务器和客户端都会有一个Socket对象示例,可以通过这个Socket对象示例,完成会话的所有操作。对于一个完整的网络连接来说,Socket是平等的,没有服务器客户端分级情况。

    2. IO模型介绍

    对于一次IO操作,数据会先拷贝到内核空间中,然后再从内核空间拷贝到用户空间中,所以一次read操作,会经历两个阶段:

    (1)等待数据准备

    (2)数据从内核空间拷贝到用户空间

    基于以上两个阶段就产生了五种不同的IO模式。

    1. 阻塞IO:从进程发起IO操作,一直等待上述两个阶段完成,此时两阶段一起阻塞。
    2. 非阻塞IO:进程一直询问IO准备好了没有,准备好了再发起读取操作,这时才把数据从内核空间拷贝到用户空间。第一阶段不阻塞但要轮询,第二阶段阻塞。
    3. 多路复用IO:多个连接使用同一个select去询问IO准备好了没有,如果有准备好了的,就返回有数据准备好了,然后对应的连接再发起读取操作,把数据从内核空间拷贝到用户空间。两阶段分开阻塞。
    4. 信号驱动IO:进程发起读取操作会立即返回,当数据准备好了会以通知的形式告诉进程,进程再发起读取操作,把数据从内核空间拷贝到用户空间。第一阶段不阻塞,第二阶段阻塞。
    5. 异步IO:进程发起读取操作会立即返回,等到数据准备好且已经拷贝到用户空间了再通知进程拿数据。两个阶段都不阻塞。

    这五种IO模式不难发现存在这两对关系:同步和异步、阻塞和非阻塞。那么稍微解释一下:

    同步和异步

    • 同步: 同步就是发起一个调用后,被调用者未处理完请求之前,调用不返回。
    • 异步: 异步就是发起一个调用后,立刻得到被调用者的回应表示已接收到请求,但是被调用者并没有返回结果,此时我们可以处理其他的请求,被调用者通常依靠事件,回调等机制来通知调用者其返回结果。

    同步和异步的区别最大在于异步的话调用者不需要等待处理结果,被调用者会通过回调等机制来通知调用者其返回结果。

    阻塞和非阻塞

    • 阻塞: 阻塞就是发起一个请求,调用者一直等待请求结果返回,也就是当前线程会被挂起,无法从事其他任务,只有当条件就绪才能继续。
    • 非阻塞: 非阻塞就是发起一个请求,调用者不用一直等着结果返回,可以先去干其他事情。

    阻塞和非阻塞是针对进程在访问数据的时候,根据IO操作的就绪状态来采取的不同方式,说白了是一种读取或者写入操作方法的实现方式,阻塞方式下读取或者写入函数将一直等待,而非阻塞方式下,读取或者写入方法会立即返回一个状态值。

    如果组合后的同步阻塞(blocking-IO)简称BIO、同步非阻塞(non-blocking-IO)简称NIO和异步非阻塞(asynchronous-non-blocking-IO)简称AIO又代表什么意思呢?

    • BIO (同步阻塞I/O模式): 数据的读取写入必须阻塞在一个线程内等待其完成。这里使用那个经典的烧开水例子,这里假设一个烧开水的场景,有一排水壶在烧开水,BIO的工作模式就是, 叫一个线程停留在一个水壶那,直到这个水壶烧开,才去处理下一个水壶。但是实际上线程在等待水壶烧开的时间段什么都没有做。
    • NIO(同步非阻塞): 同时支持阻塞与非阻塞模式,但这里我们以其同步非阻塞I/O模式来说明,那么什么叫做同步非阻塞?如果还拿烧开水来说,NIO的做法是叫一个线程不断的轮询每个水壶的状态,看看是否有水壶的状态发生了改变,从而进行下一步的操作。
    • AIO(异步非阻塞I/O模型): 异步非阻塞与同步非阻塞的区别在哪里?异步非阻塞无需一个线程去轮询所有IO操作的状态改变,在相应的状态改变后,系统会通知对应的线程来处理。对应到烧开水中就是,为每个水壶上面装了一个开关,水烧开之后,水壶会自动通知我水烧开了。

    java 中的 BIONIOAIO理解为是 Java 语言在操作系统层面对这三种 IO 模型的封装。程序员在使用这些 封装API 的时候,不需要关心操作系统层面的知识,也不需要根据不同操作系统编写不同的代码,只需要使用Java的API就可以了。由此,为了使读者对这三种模型有个比较具体和递推式的了解,并且和本文主题NIO有个清晰的对比,下面继续延伸。

    Java BIO

    BIO编程方式通常是是Java的上古产品,自JDK 1.0-JDK1.4就有的东西。编程实现过程为:首先在服务端启动一个ServerSocket来监听网络请求,客户端启动Socket发起网络请求,默认情况下SeverSocket会建立一个线程来处理此请求,如果服务端没有线程可用,客户端则会阻塞等待或遭到拒绝。服务器实现模式为一个连接一个线程,即客户端有连接请求时服务器端就需要启动一个线程进行处理。大致结构如下:

    如果要让 BIO 通信模型能够同时处理多个客户端请求,就必须使用多线程(主要原因是 socket.accept()socket.read()socket.write() 涉及的三个主要函数都是同步阻塞的),也就是说它在接收到客户端连接请求之后为每个客户端创建一个新的线程进行链路处理,处理完成之后,通过输出流返回应答给客户端,线程销毁。这就是典型的 一请求一应答通信模型 。我们可以设想一下如果这个连接不做任何事情的话就会造成不必要的线程开销,不过可以通过线程池机制改善,线程池还可以让线程的创建和回收成本相对较低。使用线程池机制改善后的 BIO 模型图如下:

    BIO方式适用于连接数目比较小且固定的架构,这种方式对服务器资源要求比较高,并发局限于应用中,是JDK1.4以前的唯一选择,但程序直观简单易懂。Java BIO编程示例网上很多,这里就不进行coding举例了,毕竟后面NIO才是重点。

    Java NIO

    NIO(New IO或者No-Blocking IO),从JDK1.4 开始引入的非阻塞IO,是一种非阻塞+ 同步的通信模式。这里的No Blocking IO用于区分上面的BIO

    NIO本身想解决 BIO的并发问题,通过Reactor模式的事件驱动机制来达到Non Blocking的。当 socket 有流可读或可写入 socket 时,操作系统会相应的通知应用程序进行处理,应用再将流读取到缓冲区或写入操作系统。

    也就是说,这个时候,已经不是一个连接就 要对应一个处理线程了,而是有效的请求,对应一个线程,当连接没有数据时,是没有工作线程来处理的。

    当一个连接创建后,不需要对应一个线程,这个连接会被注册到 多路复用器上面,所以所有的连接只需要一个线程就可以搞定,当这个线程中的多路复用器 进行轮询的时候,发现连接上有请求的话,才开启一个线程进行处理,也就是一个请求一个线程模式。

    NIO提供了与传统BIO模型中的SocketServerSocket相对应的SocketChannelServerSocketChannel两种不同的套接字通道实现,如下图结构所示。这里涉及的Reactor设计模式、多路复用SelectorBuffer等暂时不用管,后面会讲到。

    NIO 方式适用于连接数目多且连接比较短(轻操作)的架构,比如聊天服务器,并发局 限于应用中,编程复杂,JDK1.4 开始支持。同时,NIO和普通IO的区别主要可以从存储数据的载体、是否阻塞等来区分:

    Java AIO

    NIO 不同,当进行读写操作时,只须直接调用 API 的 readwrite 方法即可。这两种方法均为异步的,对于读操作而言,当有流可读取时,操作系统会将可读的流传入 read 方 法的缓冲区,并通知应用程序;对于写操作而言,当操作系统将 write 方法传递的流写入完毕时,操作系统主动通知应用程序。即可以理解为,read/write 方法都是异步的,完成后会主动调用回调函数。在 JDK7 中,提供了异步文件通道和异步套接字通道的实现,这部分内容被称作 NIO.

    AIO 方式使用于连接数目多且连接比较长(重操作)的架构,比如相册服务器,充分调用 OS 参与并发操作,编程比较复杂,JDK7 开始支持。

    目前来说 AIO 的应用还不是很广泛,Netty 之前也尝试使用过 AIO,不过又放弃了。

    二、NIO核心组件介绍

    1. Channel

    NIO中,基本所有的IO操作都是从Channel开始的,Channel通过Buffer(缓冲区)进行读写操作。

    read()表示读取通道中数据到缓冲区,write()表示把缓冲区数据写入到通道。

    Channel有好多实现类,这里有三个最常用:

    • SocketChannel:一个客户端发起TCP连接的Channel
    • ServerSocketChannel:一个服务端监听新连接的TCP Channel,对于每一个新的Client连接,都会建立一个对应的SocketChannel
    • FileChannel:从文件中读写数据

    其中SocketChannelServerSocketChannel是网络编程中最常用的,一会在最后的示例代码中会有讲解到具体用法。

    2. Buffer

    概念

    Buffer也被成为内存缓冲区,本质上就是内存中的一块,我们可以将数据写入这块内存,之后从这块内存中读取数据。也可以将这块内存封装成NIO Buffer对象,并提供一组常用的方法,方便我们对该块内存进行读写操作。

    Bufferjava.nio中被定义为抽象类:

    我们可以将Buffer理解为一个数组的封装,我们最常用的ByteBuffer对应的数据结构就是byte[]

    属性

    Buffer中有4个非常重要的属性:capacity、limit、position、mark

    Java高频面试专题合集解析:

    阿里Java岗面试百题:Spring 缓存 JVM 微服务 数据库 RabbitMQ等

    当然在这还有更多整理总结的Java进阶学习笔记和面试题未展示,在这也是免费分享给那些有需要的朋友,其中囊括了Dubbo、Redis、Netty、zookeeper、Spring cloud、分布式、高并发等架构资料和完整的Java架构学习进阶导图!

    这些资料都以整理成了PDF文档,如果有需要可以狂戳这里免费下载即可!

    阿里Java岗面试百题:Spring 缓存 JVM 微服务 数据库 RabbitMQ等

    更多Java架构进阶资料展示

    阿里Java岗面试百题:Spring 缓存 JVM 微服务 数据库 RabbitMQ等

    阿里Java岗面试百题:Spring 缓存 JVM 微服务 数据库 RabbitMQ等

    bFJ1cmN1R2dB)即可!**

    [外链图片转存中…(img-5apPZdWF-1624088540605)]

    更多Java架构进阶资料展示

    [外链图片转存中…(img-bzcIcn26-1624088540606)]

    [外链图片转存中…(img-EW8ImMV6-1624088540607)]

    阿里Java岗面试百题:Spring 缓存 JVM 微服务 数据库 RabbitMQ等

    展开全文
  • java 枚举类型分析

    2021-02-12 20:49:02
    最近做android开发,需要用到枚举值,这样可以连续赋值,我按之前c++那样书写,如下所示:public enumColorSelect {RED_BAGE= 0,GREEN_BAGE,BLUE_BAGE;}编译不过。我将赋值语句修改了以后,如下所示:public ...

    最近做android开发,需要用到枚举值,这样可以连续赋值,我按之前c++那样书写,如下所示:

    public enumColorSelect {

    RED_BAGE= 0,

    GREEN_BAGE,

    BLUE_BAGE;

    }

    编译不过。

    我将赋值语句修改了以后,如下所示:

    public enumColorSelect {

    RED_BAGE ,

    GREEN_BAGE,

    BLUE_BAGE;

    }

    编译通过。说明C++那样的赋值方法不适用java。所以,我需要弄清楚的是:

    1. 在java平台上,如何初始化枚举值。

    2.像上述那样的枚举类型ColorSelect,没有赋值,为什么switch(ColorSelect) 可以运行?它是通过字符串还是整数值来匹配枚举类型。

    为了弄清楚上述问题,我自己就写了个示范程序,将该程序编译后,看看结果,是否可以找到答案。

    一. 如何初始化枚举值

    下面是我的示范程序:

    自己定义的枚举类:

    public enum ColorSelect { //定义枚举类ColorSelect

    RED_BAGE , //定义三个枚举对象

    GREEN_BAGE,

    BLUE_BAGE;

    }

    通过反编译,这段代码反编译后的程序是:

    public final class ColorSelect extendsEnum

    {public static ColorSelect valueOf(String s) //公有函数,该方法通过字符串获取对应的ColorSelect 对象

    {return (ColorSelect)Enum.valueOf(test/Enum/TestEnum$ColorSelect, s);

    }public static ColorSelect[] values() //公有函数该方法获取所有的ColorSelect对象

    {

    ColorSelect acolorselect[]= ENUM$VALUES; //ENUM$VALUES是ColorSelect数组,下面的代码会将其进行初始化

    int i =acolorselect.length;

    ColorSelect acolorselect1[]= newColorSelect[i];

    System.arraycopy(acolorselect,0, acolorselect1, 0, i);returnacolorselect1;

    }public static final ColorSelect BLUE_BAGE; //定义公共成员BLUE_BAGE,属于ColorSelect对象

    private static final ColorSelect ENUM$VALUES[]; //定义私有成员ENUM$VALUES[],属于ColorSelect数组

    public static final ColorSelect GREEN_BAGE; //定义公共成员GREEN_BAGE,属于ColorSelect对象

    public static final ColorSelect RED_BAGE; //定义公共成员RED_BAGE,属于ColorSelect对象

    static{//static里面这段代码,将上面定义的是三个公共成员ColorSelect对象进行初始化,然后将他们全部赋值给ENUM$VALUES

    RED_BAGE = new ColorSelect("RED_BAGE", 0); //初始化BLUE_BAGE

    GREEN_BAGE = new ColorSelect("GREEN_BAGE", 1); //初始化GREEN_BAGE

    BLUE_BAGE = new ColorSelect("BLUE_BAGE", 2); //初始化BLUE_BAGE

    ColorSelect acolorselect[] = new ColorSelect[3];

    ColorSelect colorselect=RED_BAGE;

    acolorselect[0] =colorselect;

    ColorSelect colorselect1=GREEN_BAGE;

    acolorselect[1] =colorselect1;

    ColorSelect colorselect2=BLUE_BAGE;

    acolorselect[2] =colorselect2;

    ENUM$VALUES=acolorselect;

    }private ColorSelect(String s, int i) //私有函数,调用父类进行初始化ColorSelect对象

    {super(s, i);

    }

    }

    从该反编译的代码看,有两个公有成员函数:

    public static ColorSelect valueOf(String s);  该方法通过字符串获取对应的ColorSelect 对象

    public static ColorSelect[] values();  该方法获取所有的ColorSelect 对象

    这两种方法,在java里面可以直接调用。

    下面的是ColorSelect的数据成员。

    public static finalColorSelect BLUE_BAGE;private static finalColorSelect ENUM$VALUES[];public static finalColorSelect GREEN_BAGE;public static final ColorSelect RED_BAGE;

    公有数据就是BLUE_BAGE,GREEN_BAGE,RED_BAGE,它们本身属性就是ColorSelect类。所以,从这里可以看到枚举类定义的成员变量也是类。后续的代码:

    RED_BAGE = new ColorSelect("RED_BAGE", 0);

    GREEN_BAGE= new ColorSelect("GREEN_BAGE", 1);

    BLUE_BAGE= new ColorSelect("BLUE_BAGE", 2);

    这三行相当于初始化这三个类,并且每个类分配唯一的序号,按定义时的顺序从0递增。我们在java代码,可以调用ColorSelect.BLUE_BAGE.ordinal()来得到对应的序号值。

    通过以上分析,java枚举是一个类,不是语言本身实现的,而是编译器实现的,我们可以直接调用里面的方法。Enum 本身就是个普通的 class, 可以有很多自定义方法用来实现不同的功能。如果我们不自定义里面的方法,编译器就能初始化,默认顺序从0递增。我们也可以自定义方法,这样就能随便赋值。

    下面是我们自定义的java枚举类型,可以赋值。

    public enumTemp {/*通过括号赋值,而且必须有带参构造器和一属性跟方法,否则编译出错

    * 赋值必须是都赋值或都不赋值,不能一部分赋值一部分不赋值

    * 如果不赋值则不能写构造器,赋值编译也出错*/absoluteZero(-459), freezing(32),boiling(212), paperBurns(451);private final intvalue;public intgetValue() {returnvalue;

    }//构造器默认也只能是private, 从而保证构造函数只能在内部使用

    Temp(intvalue) {this.value =value;

    }

    }

    这就是一个枚举类,自定义方法来赋值。java不像C++那样简便,初始第一个值,后续值递增。赋值必须是都赋值或都不赋值,不能一部分赋值一部分不赋值。如果不赋值则不能写构造器,赋值编译也出错。

    Temp temp = null;

    Log.i("Temp##",temp.freezing.getValue()+"");

    在主函数中,我们调用temp.freezing.getValue(),得到对应的值32。

    如果大家感觉自定义枚举类麻烦,其实也可以用别的方法来代替自定义枚举类。如下所示:

    public classColorSelect {private static final int RED_BAGE = 1;private static final int GREEN_BAGE = 3;private static final int BLUE_BAGE = 5;

    }

    这种方法也比较方便。

    二. 第一个疑问搞清楚了,我们现在要解决第二个问题。Switch到底通过字符串,还是整型来分辨枚举变量。

    下面是java代码段:

    ColorSelect test =ColorSelect.BLUE_BAGE;switch(test){caseRED_BAGE:

    Log.i("TEST####1","a");break;caseGREEN_BAGE:

    Log.i("TEST####2","b");break;caseBLUE_BAGE:

    Log.i("TEST####3","c");break;default:

    Log.i("TEST####4","d");

    }

    Log.i("TEST####ret", "e");

    反编译后的代码:

    { //主函数

    ColorSelect colorselect =ColorSelect.BLUE_BAGE;

    ai= $SWITCH_TABLE$test$Enum$TestEnum$ColorSelect(); //调用子函数$SWITCH_TABLE$test$Enum$TestEnum$ColorSelect(),返回数组赋值给ai

    i = colorselect.ordinal(); //得到该枚举类型BLUE_BAGE的序号

    ai[i]; //switch根据ai[i]值来进行判断

    JVM INSTR tableswitch 1 3: default 56 //1 3是ai[i]的取值范围//1 73//2 84//3 95;

    goto_L1 _L2 _L3 _L4

    _L1:

    Log.i("TEST####4", "d");

    _L6:

    Log.i("TEST####ret", "e");return;

    _L2:

    Log.i("TEST####1", "a");continue; /*Loop/switch isn't completed*/_L3:

    Log.i("TEST####2", "b");continue; /*Loop/switch isn't completed*/_L4:

    Log.i("TEST####3", "c");if(true) goto _L6; else goto_L5

    _L5:

    }private static int$SWITCH_TABLE$test$Enum$TestEnum$ColorSelect[];

    }//子函数

    static int[] $SWITCH_TABLE$test$Enum$TestEnum$ColorSelect() //{int ai[] =$SWITCH_TABLE$test$Enum$TestEnum$ColorSelect;if(ai == null)

    {

    ai= new int[ColorSelect.values().length];try //下面的代码,将每一个枚举类型的序号值作为数组ai的下标,然后赋一个整数值

    {int i =ColorSelect.BLUE_BAGE.ordinal();

    ai[i]= 3;

    }catch(NoSuchFieldError nosuchfielderror2) { }try{int j =ColorSelect.GREEN_BAGE.ordinal();

    ai[j]= 2;

    }catch(NoSuchFieldError nosuchfielderror1) { }try{int k =ColorSelect.RED_BAGE.ordinal();

    ai[k]= 1;

    }catch(NoSuchFieldError nosuchfielderror) { }

    $SWITCH_TABLE$test$Enum$TestEnum$ColorSelect=ai;

    }returnai;

    }

    子函数$SWITCH_TABLE$test$Enum$TestEnum$ColorSelect()的功能:

    通过int i = ColorSelect.BLUE_BAGE.ordinal()得到该类的唯一序号,作为数组下标,并且赋值给ai[i]。这样,每一个枚举类对应都有唯一的整数对应。然后返回数组ai[]。这个功能是编译器实现的。我感觉,子函数的功能有些多余,其实可以直接用之前初始化枚举类的时候的下标号,直接作为标识符也行,就不用再给每个枚举类重新赋整数值。

    主函数里面,调用子函数$SWITCH_TABLE$test$Enum$TestEnum$ColorSelect(),switch()里面的参数是ai[i],根据这个整数值来判断分支。Java里面枚举值通过编译器给每个枚举类型赋整型数值,然后Switch通过识别这些整数来进行判断分支,这就解决了第二个疑问。

    同时我们通过对比switch的java代码和反编译的代码,可以得到大概下面的结论。

    1.每个标志位的"continue"说明该分支break。

    2.最后一个分支的标志是if (true) goto _Lx,else goto _x。

    同时我们通过对比switch的java代码和反编译的代码,可以得到大概下面的结论。

    1.每个标志位的"continue"说明该分支break。

    2.最后一个分支的标志是if (true) goto _Lx,else goto _x。

    同时,还有些疑问,没弄明白?

    我写了好几个switch的例子,反编译出来的代码有一个共同规律。

    反编译代码1:

    JVM INSTR tableswitch 1 3: default 56

    //1 73//2 84//3 95;

    goto _L1 _L2 _L3 _L4

    反编译代码2:

    JVM INSTR tableswitch 0 2: default 60

    //0 77//1 88//2 99;

    goto _L1 _L2 _L3 _L4

    这两个,标明 1, 2,3相互之间数值都相差11。第二个也是。这个搞不懂?同时,这些数值代表什么?

    如果以上哪些不对的地方,请大家指正。

    
     
    
     
    
     
    
     
    
     
    
     
    
     
    
     
    
     
    
     
    
     
    
     
    
     
    
     
    
     
    
     
    
     
    
     
    
     
    
     
    
     
    
     
    
     
    
     
    
     
    
     

    (转自:http://blog.csdn.net/bage1988320/article/details/6690845)

    展开全文
  • 想像下面的枚举:import java.awt.Color;public class test {/*** @param args*/public static void main(String[] args) {System.out.println(MyEnum.CONSTANT1.get());System.out.println(MyE...

    我偶然发现了一个非常奇怪的错误,我无法解释为什么会这样.想像下面的枚举:

    import java.awt.Color;

    public class test {

    /**

    * @param args

    */

    public static void main(String[] args) {

    System.out.println(MyEnum.CONSTANT1.get());

    System.out.println(MyEnum.CONSTANT2.get());

    }

    private enum MyEnum {

    CONSTANT1(staticMethod1()),CONSTANT2(staticMethod2());

    private static final Color WHY_AM_I_NULL = new Color(255,255,255);

    private final Color color;

    private MyEnum(Color color) {

    this.color = color;

    }

    public Color get() {

    return color;

    }

    private static Color staticMethod1() {

    return new Color(100,100,100);

    }

    private static Color staticMethod2() {

    return WHY_AM_I_NULL;

    }

    }

    }

    运行这些的结果是:

    java.awt.Color[r=100,g=100,b=100]

    null

    问题是,为什么第二个是空的?

    Ammendment:

    如果将WHY_AM_I_NULL放在枚举中的私有静态类中,那么它将被初始化.

    展开全文
  • 今天我们来了解三个方面的内容:数组初始化、可变参数列表、枚举类型。 一、数组初始化 数组是将相同类型的对象封装到一起的序列。 定义数组只需在类型后方加上 [ ] 即可, 拥有两种表示方式: /** * 第一种(符合...

    今天我们来了解三个方面的内容:数组初始化、可变参数列表、枚举类型。

    一、数组初始化

    数组是将相同类型的对象封装到一起的序列。

    定义数组只需在类型后方加上 [ ] 即可, 拥有两种表示方式:

        /**
         * 第一种(符合大多数人的编程习惯,推荐使用此种)
         */
        int[] array1;
        /**
         * 第二种
         */
        int array2[];
    

    此时定义的数组 array 尚未进行初始化,数组在初始化时,必须指定数组长度,数组的初始化也拥有两种选择:

    (1)在定义的时候直接进行初始化并赋值

    (2)先定义指定长度的空数组,通过数组的下标,对数组内的元素赋值

        public static void main(String[] args) {
            int[] array1 = {1, 2, 3, 4, 5};
    
            int[] array2 = new int[5];
    
            for (int i = 0; i < 5; i++) {
                array2[i] = i + 1;
            }
            System.out.println(Arrays.toString(array1));
            System.out.println(Arrays.toString(array2));
        }
    
    [1, 2, 3, 4, 5]
    [1, 2, 3, 4, 5]
    

    数组的下标从 0 开始,最大的下标为 (数组的长度-1),可以通过 length 函数来获取数组的长度。

        public static void main(String[] args) {
            int[] array = {1, 2, 3, 4, 5};
            System.out.println(array.length);
        }
    
    5
    

    二、可变参数列表

    可变参数列表用于参数个数未知或者参数类型未知(所有的对象都可以用 object 接收)的场合。

        public static void printArray(Object... args) {
            System.out.println("开始打印");
            for (Object arg : args) {
                System.out.println(arg);
            }
        }
    
        public static void main(String[] args) {
            printArray(new Integer(1), new Double(4.2), "str");
            printArray();
        }
    
    开始打印
    1
    4.2
    str
    开始打印
    
    

    编译器会将可变参数填充为数组进行传参,从以上列子还可得出:可变参数传0个参数也是可行的。

    但使用可变参数进行方法重载的时候,可能会产生歧义。

    在这里插入图片描述
    这是因为可变参数可以传递0个参数,会导致编译器无法知道调用哪个方法。不过,为2个方法增加1个非可变参数即可解决问题。

    在这里插入图片描述

    三、枚举类型

    在编码过程中,通常会将一些特定类型的值定义为常量,例如:不同类型的学历层次。

        public static final String PRIMARY_SCHOOL = "primarySchool";
    
        public static final String JUNIOR_HIGH_SCHOOL = "juniorHighSchool ";
    
        public static final String SENIOR_HIGH_SCHOOL = "seniorHighSchool";
    

    但有时我们需要为常量拓展一些特性,比如:绑定每个学历层级的教育年限。那么光使用常量就无法满足需求了,这时推荐使用枚举类型。

    枚举类型是一个特殊的类,关键字不用 class 而是 enum 表示。

    
    
        PRIMARY_SCHOOL("primarySchool", 6), JUNIOR_HIGH_SCHOOL("juniorHighSchool", 3), SENIOR_HIGH_SCHOOL(
                "seniorHighSchool", 3);
    
        String name;
    
        int year;
    
        EducationEnum(String name, int year) {
            this.name = name;
            this.year = year;
        }
    
        public String getName() {
            return name;
        }
    
        public int getYear() {
            return year;
        }
    
        @Override
        public String toString() {
            return "学历:" + name + ";教育年限:" + year;
        }
    

    枚举类可以自定义多个属性,但枚举包含的所有类型,必须初始化在枚举类中,每个枚举类型都可以当做为一个对象,还可以重写枚举的方法,定制符合需要的业务。

            String name = EducationEnum.PRIMARY_SCHOOL.getName();
            System.out.println("name==="+name);
            int year = EducationEnum.PRIMARY_SCHOOL.getYear();
            System.out.println("year==="+year);
            System.out.println(EducationEnum.PRIMARY_SCHOOL.toString());
    
    name===primarySchool
    year===6
    学历:primarySchool;教育年限:6
    

    此外,枚举自身也提供一些API供开发者调用,如:获取枚举类型位于第几顺位使用 ordinal() ;

            int ordinal = EducationEnum.PRIMARY_SCHOOL.ordinal();
            System.out.println("ordinal==="+ordinal);
    
    ordinal===0
    

    本次分享至此结束,希望本文对你有所帮助,若能点亮下方的点赞按钮,在下感激不尽,谢谢您的【精神支持】。

    若有任何疑问,也欢迎与我交流,若存在不足之处,也欢迎各位指正!

    展开全文
  • 理解Java枚举类型

    2021-02-12 16:29:42
    1、原理:对编译后的class文件javap反编译可以看出,定义的枚举类继承自java....示例:1 //定义枚举类型2 enumDay {3 MONDAY, TUESDAY, WEDNESDAY,4 THURSDAY, FRIDAY, SATURDAY, SUNDAY5 }67 //对应的完整内容8 //...
  • 今天遇到一个问题,就是设计了两个枚举,一个是状态枚举(EnumA)一个是动作枚举(EnumB),状态枚举定义了当前状态的可以进行的操作,操作枚举定义了执行了此操作后的下一个状态。具体代码如下:public enum EnumA {...
  • 原文网址:http://iaiai.iteye.com/blog/18435531 背景在java语言中还没有引入枚举类型之前,表示枚举类型的常用模式是声明一组具有int常量。之前我们通常利用public final static 方法定义的代码如下,分别用1 表示...
  • 为了可以更好的支持枚举类型java.util当中添加了2个新类,一个是EnumMap另外一个就是EnumSet,使用他们的话能够更加高效的操作枚举类型,那么下面的我们就来先讲一下EnumMap。EnumMap类EnumMap是专门为枚举类型量...
  • import ...import java.util.HashMap;import java.util.List;import java.util.Map;public enum StandardOperationEntityType {CREATE("CODELIST", "数据字典"),DELETE("CODELIST_ITEM", "...
  • OnJava8_初始化和清理

    2021-03-08 07:35:43
    Java对象初始化通过构造器,清理通过垃圾收集器(Garbage Collector, GC)构造器无参构造函器,有参构造器如果创建一个类,没有自定义构造器,编译器会自动创建一个无参构造器方法重载函数名相同,参数个数或者参数...
  • Java中的枚举类型

    2021-03-22 10:33:05
    java 枚举值比较用 == 和 equals 方法没啥区别,两个随便用都是一样的效果。因为枚举 Enum 类的 equals 方法默认实现就是通过 == 来比较的;类似的 Enum 的 compareTo 方法比较的是 Enum 的 ordinal 顺序大小;类似...
  • Java枚举类型

    2021-01-19 01:26:58
    本篇简单介绍Java中的枚举。 在枚举出现以前,一般使用接口... 枚举类型在static块中初始化,因此是线程安全的,这也是枚举类型实现的单例模式是线程安全的原因。 笔者再想到关于枚举的本篇文章没提到的会随时更新。
  • 本文转载自博客 - Java枚举类型, 博主对原文内容及结构作了一定的修改.1 枚举类的编译特性从JDK 5开始, Java中多了一个关键字 —— enum: 可以将一组具有名称的值(包括String、Integer等)的有限集合创建为一种新的...
  • 枚举类型中的值就是当前枚举类型 常用枚举类型.valueof()来转换枚举类型和字符串型 可以有构造方法,但不能通过构造方法创建对象 因为值全是常量,因此非常安全 包装类 装箱:把基本数据类型封装成包装类型 ...
  • Java集合是常用的数据类型,在此详细分析接口和实现类。整个集合框架就围绕一组标准接口而设计,学习集合框架有助开发实践。框架体系图1.Collection 接口Collection 是最基本的集合接口,一个 Collection 代表一组 ...
  • Java枚举类型的用法

    2021-12-08 13:40:14
    现在好了,有了枚举,可以把相关的常量分组到一个枚举类型里,而且枚举提供了比常量更多的方法。而且枚举类型可以帮助我们检测许多的编译失误。 例如: package enumTest; public enum Color { RED,BLAN...
  • Java枚举

    千次阅读 2021-03-06 21:46:49
    一、背景所属包java.lang包jdk1.5后引入的新特性二、基本使用(一)、 创建一个枚举public enum TestEnum {A,B,C;}以上,创建了一个简单的枚举,这个枚举里有三个枚举项,分别是A,B,C。需要注意的是:A,B,C每一个都...
  • java 枚举类型 Enum

    2021-02-12 09:17:26
    在现实社会中,有些类的实例对象是固定的。例如季节,只有春夏秋冬。如果你创建了一个season类,你当然有义务维护这个类的.../*** 枚举类的后缀建议为Enum,枚举类型的实例对象建议全大写(这样做符合JAVA的规范)*/...
  • 众所周知,与enum其他编程语言相比,Java枚举类型更强大。基本上enum是类类型的,因此它可以具有构造函数,方法和字段。在下面的示例中,您将看到如何在枚举类型中定义字段。因为Fruit枚举的每个常量值Fruit都是其...
  • 我必须创建一个包装器类来保存任何原始数据类型.我创建了该类,该类可用于除布尔值以外的所有内容.这是我的代码:byte a; // the byte in primitiveshort b; // the shortint c, j; // int c is is int, j is the ...
  • .lang.Enum的类,而我们定义的每个枚举值都会在类的初始化阶段被实例化为我们所定义的枚举类的一个对象。 在枚举类被编译之后,有一些方法是编译器在编译阶段写入的,那这些方法有什么特点?枚举类中还有一些继承来...
  • java Enum 使用示例:public enum EnumTest {FRANK("The given name of me"),LIU("The family name of me");private String context;private String getContext(){return this.context;}private EnumTest(String ...
  • java枚举接口

    2021-03-04 02:42:08
    java中的枚举类枚举类(enum),与class和interface关键字地位相同。枚举类是一个特殊的类,可以有自己的成员变量、方法、构造器,可以实现一个或...文章云栖-lxl2015-03-06458浏览量Java枚举Java枚举有如下特点:枚举...
  • 1、枚举类型1.1.含义:如果一个变量只有几种可能的值,则可以定义为枚举类型。例如enum Color{red,yellow,blue,white,black};声明了一个枚举类型然后可以用此类型来定义变量,如enum Color color1,color2枚举类型 ...
  • Java从JDK1.5开始支持枚举,也就是说,Java一开始是不支持枚举的,就像泛型一样,都是JDK1.5才加入的新特性。通常一个特性如果在一开始没有提供,在语言发展后期才添加,会遇到一个问题,就是向后兼容性的问题。像...
  • java-中的静态初始化

    2021-03-05 20:23:50
    java-中的静态初始化当我试图写这样的东西:public interface MyInterface {static {System.out.println("Hello!");}}编译器无法编译它。但是当我写这样的东西时:interface MyInterface {Integer iconst = Integer....
  • JDK 1.5 之前需要自定义枚举类JDK 1.5 新增的enum关键字用于定义枚举类若枚举...Java枚举类型背后的基本想法非常简单:她们就是通过共有的静态final域为每个枚举常量导出实际的类。因为没有可以访问的构造器,所以枚...
  • JAVA枚举

    2021-03-17 12:45:35
    一、什么是枚举枚举是由一组固定的常量组成的合法值。通过这一定义,我们可以看出枚举的核心在于常量,而且常量是固定的。这里的“固定”,我的理解是:数目固定,内容固定。也就是说常量的数量是固定的,而且常量...
  • 反编译分析Java枚举类型的实现...Enum...
  • 上一篇文章用用两种方式包装了SQLServer、MySQL、Oracle三种数据库的对应连接获取方式,这篇文章将通过JAVA枚举类做一个包装,使得通过枚举类也可以获取数据库连接。附上代码:package com.jdbc;import java.sql....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 81,113
精华内容 32,445
关键字:

java枚举类型初始化

java 订阅