Java核心 --- 枚举

时间:2022-09-18 10:08:43

Java核心 --- 枚举

枚举把显示的变量与逻辑的数字绑定在一起
在编译的时候,就会发现数据不合法
也起到了使程序更加易读,规范代码的作用

一、用普通类的方式实现枚举

新建一个终态类Season,把构造方法设为私有,因为枚举值不能随意增加
因为不能new出这个类的对象,所以需要定义成员变量,把new写在类的内部
这样,就可以在类的外部通过访问类的静态成员变量的方式访问到枚举值
通过这样的方式,只能在类的外部使用在枚举类的内部定义的枚举值

类Season里面是可以有方法的,我们设置地球又公转了四分之一
方法的返回值是Season,对应的这个类里面的所有枚举值将转动四分之一
重写方法toString(),打印枚举的值
测试一下,打印一个枚举值的next后的值,再经过toString后输出

/Enumeration/src/yuki/core/enumeration/imitation/SeasonTest.java

package yuki.core.enumeration.imitation;

public class SeasonTest {

    public static void main(String[] args) {
        Season season = Season.AUTUMN;
        System.out.println(season.nextQuarter());
    }
}

/Enumeration/src/yuki/core/enumeration/imitation/Season.java

package yuki.core.enumeration.test;

public final class Season {
    //私有构造方法
    private Season(){}

    //定义静态成员常量
    public final static Season SPRING = new Season();
    public final static Season SUMMER = new Season();
    public final static Season AUTUMN = new Season();
    public final static Season WINTER = new Season();

    //定义地球又公转了四分之一
    public Season nextQuarter(){
        Season ret = null;
        if(this == WINTER)
            ret = SPRING;
        else if(this == SPRING)
            ret = SUMMER;
        else if(this == SUMMER)
            ret = AUTUMN;
        else if(this == AUTUMN)
            ret = WINTER;
        return ret;
    }

    //打印枚举的值
    @Override
    public String toString(){
        return this == WINTER ? "Winter" : (
               this == SPRING ? "Spring" : (
               this == SUMMER ? "Summer" : "Autumn"));
    }

}

可以看到程序中出现了大量的if-else,这样似乎不太好
可以把每一个元素的nextQuarter写成自己独立的方法
这需要定义成抽象的nextQuarter来使要新建对象就必须先实现这个方法
拥有抽象方法的类也必须是抽象的
这时,直接使用new来新建对象的方式就会报红,使用它的子类创建实例对象
定义为抽象的类需要子类来实现它的抽象方法,这是需要去掉final修饰符
在每个枚举值得类中实现抽象方法nextQuarter(),再次测试
在这里,把统一的if-else语句转化为了一个个独立的类

/Enumeration/src/yuki/core/enumeration/imitation/Season.java

package yuki.core.enumeration.imitation;

public abstract class Season {
    //私有构造方法
    private Season(){}

    //定义静态成员常量
    public final static Season SPRING = new Season(){
        @Override
        public Season nextQuarter() {
            return SUMMER;
        }
    };
    public final static Season SUMMER = new Season(){
        @Override
        public Season nextQuarter() {
            return AUTUMN;
        }
    };
    public final static Season AUTUMN = new Season(){
        @Override
        public Season nextQuarter() {
            return WINTER;
        }
    };
    public final static Season WINTER = new Season(){
        @Override
        public Season nextQuarter() {
            return SPRING;
        }
    };

    public abstract Season nextQuarter();

    //打印枚举的值
    @Override
    public String toString(){
        return this == WINTER ? "Winter" : (
               this == SPRING ? "Spring" : (
               this == SUMMER ? "Summer" : "Autumn"));
    }

}

运行结果如下:

Winter

二、一个基本的枚举类
这里把枚举放在类里定义,作为测试类的一个成员内部类
枚举里的一个元素就相当于类里的一个对象
对于枚举这种类型的对象,它自动的帮我们实现了toString方法
打印出的是枚举值的接收引用的名称

方法name()获得接收引用的名称
方法ordinal()获得枚举值在枚举中所在的位置,下表从0开始
静态方法valueOf(String)可以通过枚举值的名称得到枚举值
从浏览器获得的请求参数值就可以通过这种方式编程枚举值对象
静态方法values()可以获得枚举里的所有枚举值

/Enumeration/src/yuki/core/enumeration/construction/SquareVertexTest.java

package yuki.core.enumeration.construction;

public class SquareVertexTest {

    public static void main(String[] args) {
        SquareVertex vertex = SquareVertex.A;
        System.out.println(vertex);
        System.out.println(vertex.name());
        System.out.println(vertex.ordinal());
        System.out.println(SquareVertex.valueOf("D"));
        System.out.println(SquareVertex.values().length);
    }

    /**
     * 正方形的四个顶点
     */
    public enum SquareVertex{
        A, B, C, D
    }
}

运行结果如下:

A
A
0
D
4

三、带有构造方法的枚举
枚举是一个类,所以应该可以定义自己的构造方法
构造方法必须放在元素列表之后,并在元素列表之后加上分号
构造方法必须是私有的,默认调用的是无参构造
所有的枚举值在第一次用到枚举类时全部初始化

在枚举元素后加圆括号指定参数列表,可以调用对应的构造方法
在枚举元素后加上没有内容的圆括号,调用的方法也是无参构造方法

/Enumeration/src/yuki/core/enumeration/construction/DirectionTest.java

package yuki.core.enumeration.construction;

public class DirectionTest {

    public static void main(String[] args) {
        @SuppressWarnings("unused")
        Direction direction = Direction.W;
    }

    public enum Direction{
        E(1), S(), W, N;
        private Direction(){
            System.out.println("无参构造方法");
        }
        private Direction(int direct){
            System.out.println("Direction(int direct)");
        }

    }
}

运行结果如下:

Direction(int direct)
无参构造方法
无参构造方法
无参构造方法

四、实现带有抽象方法的枚举
添加一个抽象方法返回类型是枚举类本身
在枚举元素后添加花括号实现这个抽象方法

/Enumeration/src/yuki/core/enumeration/abstraction/ColorTest.java

package yuki.core.enumeration.abstraction;

public class ColorTest {

    public static void main(String[] args) {

    }

    public enum TrafficLamp{
        RED{
            @Override
            public TrafficLamp nextLamp() {
                return GREEN;
            }
        },
        GREEN{
            @Override
            public TrafficLamp nextLamp() {
                return YELLOW;
            }
        },
        YELLOW{
            @Override
            public TrafficLamp nextLamp() {
                return RED;
            }
        };
        public abstract TrafficLamp nextLamp();

    }
}

在bin目录下可以看到枚举的每个元素都生成了class文件
D:\Workspaces\Eclipse\Enumeration\bin\yuki\core\enumeration\abstraction

Java核心 --- 枚举

为灯指定一个时间,这时需要在枚举元素的后面加上构造参数

/Enumeration/src/yuki/core/enumeration/abstraction/LampTest.java

package yuki.core.enumeration.abstraction;

public class LampTest {
    public static void main(String[] args) {

    }

    public enum TrafficLamp{
        RED(30){
            @Override
            public TrafficLamp nextLamp() {
                return GREEN;
            }
        },
        GREEN(45){
            @Override
            public TrafficLamp nextLamp() {
                return YELLOW;
            }
        },
        YELLOW(5){
            @Override
            public TrafficLamp nextLamp() {
                return RED;
            }
        };
        public abstract TrafficLamp nextLamp();
        @SuppressWarnings("unused")
        private int time;
        private TrafficLamp(int time){
            this.time = time;
        }
    }
}

在新建父类的匿名子类对象时,可以指定调用父类的构造方法

/Enumeration/src/yuki/core/enumeration/abstraction/ConstructorTest.java

package yuki.core.enumeration.abstraction;

public class ConstructorTest {

    public static void main(String[] args) {

        Supper supper = new Supper(1234){
            @Override public String toString(){
                return "子类的toString方法";
            }
        };
        System.out.println(supper);
    }

    public static class Supper{
        public Supper() {
            System.out.println("无参构造被调用");
        }
        public Supper(int i){
            System.out.println("有参构造被调用");
        }
    }
}

运行结果如下:

有参构造被调用
子类的toString方法

如果枚举只有一个成员,可以作为一种单例模式的实现方式
更多内容请参考:[张孝祥Java高新技术_枚举]

五、为枚举提供的功能和演示
1. 枚举与switch-case
switch中匹配枚举值时,只需要写出不带枚举类型的枚举值就可以了

/Enumeration/src/yuki/core/enumeration/switch_case/QuarkTest.java

package yuki.core.enumeration.switch_case;

public class QuarkTest {

    public static void main(String[] args) {
        Quark quark = Quark.C;
        String name = null;
        switch(quark){
        case U:
            name = "上夸克";
            break;
        case D:
            name = "下夸克";
            break;
        case C:
            name = "粲夸克";
            break;
        case S:
            name = "奇夸克";
            break;
        case T:
            name = "顶夸克";
            break;
        case B:
            name = "底夸克";
            break;
        }
        System.out.println(name);
    }

    private enum Quark{
        U, D, C, S, T, B;
    }
}

运行结果如下:

粲夸克

2. 定制自己的枚举字符串
这样就可以不用public static final String variable_name = string_value;

/Enumeration/src/yuki/core/enumeration/const_string/WebsiteTest.java

package yuki.core.enumeration.const_string;

public class WebsiteTest {

    private enum Website{
        GOOGLE("https://www.google.com.hk/?gws_rd=ssl"),
        AMAZON("http://www.amazon.cn/");

        //网址
        private String address;
        //构造函数
        private Website(String address){
            this.address = address;
        }
        //获取地址的方法
        public String address() {
            return address;
        }
    }

    public static void main(String[] args) {

        Website amazon = Website.AMAZON;
        System.out.println(amazon);
        System.out.println(amazon.address());
    }

}

运行结果如下:

AMAZON
http://www.amazon.cn/

3. EnumSet和EnumMap

JDK5.0 中在增加 Enum 类的同时,也增加了两个工具类 EnumSet 和 EnumMap,
这两个类都放在 java.util 包中。

/Enumeration/src/yuki/core/enumeration/enum_util/EnumSetTest.java

package yuki.core.enumeration.enum_util;

import java.util.EnumSet;

/**
 * JDK5.0 中在增加 Enum 类的同时,也增加了两个工具类 EnumSet 和 EnumMap,
 * 这两个类都放在 java.util 包中。
 *
 * EnumSet 是一个针对枚举类型的高性能的 Set 接口实现。
 * EnumSet 中装入的所有枚举对象都必须是同一种类型,
 * 在其内部,是通过bit-vector 来实现,也就是通过一个 long 型数。
 * EnumSet 支持在枚举类型的所有值的某个范围中进行迭代。
 *
 * @author yuki
 *
 */
public class EnumSetTest {

    private enum WeekDay{
        Mon, Tue, Wed, Thu, Fri, Sat, Sun;
    }

    public static void main(String[] args) {
//        EnumSet<WeekDay> weekDays = EnumSet.of(WeekDay.Fri, WeekDay.Tue);
        EnumSet<WeekDay> weekDays = EnumSet.range(WeekDay.Tue, WeekDay.Fri);
        for(WeekDay day : weekDays){
            System.out.println(day);
        }
    }

}

运行结果如下:

Tue
Wed
Thu
Fri

/Enumeration/src/yuki/core/enumeration/enum_util/EnumMapTest.java

package yuki.core.enumeration.enum_util;

import java.util.EnumMap;
import java.util.Map;

/**
 * 与EnumSet 类似,EnumMap 也是一个高性能的 Map 接口实现,
 * 用来管理使用枚举类型作为 keys 的映射表,内部是通过数组方式来实现。
 * EnumMap 将丰富的和安全的 Map 接口与数组快速访问结合到一起,
 * 如果你希望要将一个枚举类型映射到一个值,你应该使用 EnumMap。
 *
 * @author yuki
 *
 */
public class EnumMapTest {

    //卦值
    private enum Divination{
        KAN, XUN, QIAN, DUI, LI, ZHENG, KUN, GEN
    }
    //自然值
    private enum Nature{
        SHUI, FENG, TIAN, ZE, HUO, LEI, DI, SHAN
    }

    public static void main(String[] args) {
        //将卦值与自然值对应起来
        Map<Divination, Nature> schema = new EnumMap<>(Divination.class);
        for(int i = 0; i < Divination.values().length; ++i){
            schema.put(Divination.values()[i], Nature.values()[i]);
        }
        for(Map.Entry<Divination, Nature> entry : schema.entrySet()){
            System.out.println(entry.getKey() + "\t->\t" + entry.getValue());
        }
    }

}

运行结果如下:

KAN    ->    SHUI
XUN    ->    FENG
QIAN    ->    TIAN
DUI    ->    ZE
LI    ->    HUO
ZHENG    ->    LEI
KUN    ->    DI
GEN    ->    SHAN

更多疑问请参考:[Java 语言中 Enum 类型的使用介绍]:
http://www.ibm.com/developerworks/cn/java/j-lo-enum/index.html

六、反编译工具jdecompiler
下载地址:http://jd.benow.ca/ ,点击下载JD-Eclipse>Offline installation

Java核心 --- 枚举
按照提示的步骤安装,把下载文件解压到以压缩包名为文件名的文件夹
Help>InstallNewSoftware...>Add>AddRepository>选择文件夹jdeclipse_update_site
Name=jdeclipse; Location=C:\Users\yuki\Downloads\jdeclipse_update_site
点击OK,列表中出现Java Decompiler Eclipse Plug-in>勾选它>Next
这时鼠标的指针变为等待,显示Calculating requirements and dependencies
额,这好像要等好久,我去吃饭了,~~,哦,只是前面慢而已,点击Next
选择I accept the terms of the license agreement>Finish
显示InstallSoftware的弹出窗,这里又好慢
再按照提示添加EmmanuelDupuy>选中>Finish>安装完成>restart Eclipse

打开Perferences>Java>Decompile,表明已经安装成功,
当然下载的svn也是上面格式的文件,所以应该也可以用上面的方式安装
General>Editor>FileAssociation>点击*.class without source
看到默认是用ClassFileEditor打开的,从它的图标不难看出,
它就是把class文件反编译为java文件格式打开的编辑器

Java核心 --- 枚举

在很多情况下我们是有源码的,当源码在maven库中对应的位置时
maven工具就会自动下载源码,并用ClassFileViewer打开
在设为默认后,重新打开Eclipse会发现默认的class打开方式还是反编译打开
点击General>StartupAndShutdown,这里有一个检查项JD-Eclipse Plug-in
取消它的勾选就可以了

Java核心 --- 枚举

七、反编译枚举类的类文件
bin目录下的内容按照Eclipse的设定是不显示的
在src下的class文件也是默认不显示的
写一个枚举类PlatonicSolid,里面有五种元素

package yuki.core.enumeration.decompiler;

public enum PlatonicSolid {

    FOUR, EIGHT, TWENTY, SIX, TWELVE
}

打开\Enumeration\bin\yuki\core\enumeration\decompiler\
复制PlatonicSolid.class到根目录下
打开后,文件以为自己是有源码的,所以这里反编译不起作用

Java核心 --- 枚举

访问http://jd.benow.ca/ 下载JD-GUI,
证明这个反编译器打不开编译后的枚举类文件
额,不是要下载右边那个,左边那个是稳定版

Java核心 --- 枚举
打开后反编译的结果就仅仅是源码去掉了注释
看起来软件升级了,看不到想要看的内容了

Java核心 --- 枚举

反编译网站:http://www.findmaven.net/decompile ,同样的结果
反编译网站:http://www.showmycode.com/ 反编译结果如下

Java核心 --- 枚举

经过我的排板后的文件如下:因为编译不通过,所以用Ctrl+Shift+F排版是不行的

/Enumeration/src/yuki/core/enumeration/decompiler/platonic_solid/PlatonicSolid.java

package yuki.core.enumeration.decompiler.platonic_solid;

public final class PlatonicSolid extends Enum<Enum<E>> {
    private PlatonicSolid(String s, int i) {
        super(s, i);
    }
    public static PlatonicSolid[] values() {
        PlatonicSolid aplatonicsolid[];
        int i;
        PlatonicSolid aplatonicsolid1[];
        System.arraycopy(aplatonicsolid = enum$VALUES, 0,
        aplatonicsolid1 = new PlatonicSolid[i = aplatonicsolid.length], 0, i);
        return aplatonicsolid1;
    }
    public static PlatonicSolid valueOf(String s) {
        return (PlatonicSolid)enum.valueOf(yuki/core/enumeration/decompiler/PlatonicSolid, s);
    }
    public static final PlatonicSolid FOUR;
    public static final PlatonicSolid EIGHT;
    public static final PlatonicSolid TWENTY;
    public static final PlatonicSolid SIX;
    public static final PlatonicSolid TWELVE;
    private static final PlatonicSolid enum$VALUES[];

    static {
        FOUR = new PlatonicSolid("FOUR", 0);
        EIGHT = new PlatonicSolid("EIGHT", 1);
        TWENTY = new PlatonicSolid("TWENTY", 2);
        SIX = new PlatonicSolid("SIX", 3);
        TWELVE = new PlatonicSolid("TWELVE", 4);
        enum$VALUES = (new PlatonicSolid[] { FOUR, EIGHT, TWENTY, SIX, TWELVE });
    }

}

但是Enum是无法被继承的,具体请见:
http://www.zhihu.com/question/19908744
http://pf-miles.iteye.com/blog/187155
后一篇文章所说的内容就是,枚举的多态是由属性的类继承枚举类实现的

枚举类的声明如下:

public abstract class Enum<E extends Enum<E>> implements Comparable<E>, Serializable

这里的E继承了Enum<E>, 而枚举E又是枚举类的泛型参数,如果可以继承
public final class PlatonicSolid extends Enum<Enum<E>>
那么就必须要拥有一个继承了枚举的枚举类,
这又回到了刚才的问题,所以问题无解

八、构造方法,方法,变量
枚举类型的每一个值都将映射到protected Enum(String name, int ordinal)构造函数中
在这里,每个值的名称都被转换成一个字符串,并且序数设置表示了每个设置的优先值。
换句话说,enum Size {Small, Medium, Large} 将映射到清单 2 中所示的构造函数调用中:
new Enum<Size>("Small", 0);
new Enum<Size>("Medium", 1);
new Enum<Size>("Large", 2);

更多疑问请参考:[驯服 Tiger: 深入研究枚举类型]:
http://www.ibm.com/developerworks/cn/java/j-tiger04195/

九、实现接口与使用接口组织枚举
所有的枚举都继承自java.lang.Enum类。
由于Java 不支持多继承,所以枚举对象不能再继承其他类。

/Enumeration/src/yuki/core/enumeration/interfaces/PlanetTest.java

package yuki.core.enumeration.interfaces;

import java.util.Arrays;
import java.util.List;

public class PlanetTest {

    private interface Move{
        void move();
    };

    private enum Planet implements Move{
        SOLAR,
        EARTH{
            @Override
            public void move() {
                System.out.println("rounding...center:" + SOLAR);
            }
        },
        MOON{
            @Override
            public void move() {
                System.out.println("rounding...center:" + EARTH);
            }
        };

        @Override
        public void move() {
            System.out.println("rounding...");
        }
    }

    public static void main(String[] args) {

        List<Planet> planets = Arrays.asList(Planet.values());
        for(Planet planet : planets){
            System.out.print(planet + " : ");
            planet.move();
        }
    }

}

运行结果如下:

SOLAR : rounding...
EARTH : rounding...center:SOLAR
MOON : rounding...center:EARTH

使用接口也可以管理枚举,并且可以在接口内部再定义接口

/Enumeration/src/yuki/core/enumeration/interfaces/Shape.java

package yuki.core.enumeration.interfaces;

public interface Shape {

    enum Circle implements Shape {
        Center, Radius
    }

    interface RegularPolygon extends Shape {
        enum Triangle implements RegularPolygon {
            Angel, Length
        }
        enum Square implements RegularPolygon {
            Point, Area
        }
    }
}

/Enumeration/src/yuki/core/enumeration/interfaces/ShapeTest.java

package yuki.core.enumeration.interfaces;

public class ShapeTest {

    public static void main(String[] args) {

        Shape circle = Shape.Circle.Radius;
        System.out.println(circle);

        Shape squre = Shape.RegularPolygon.Square.Area;
        System.out.println(squre);
    }

}

运行结果如下:

Radius
Area

更多疑问请参考:[Java 枚举7常见种用法]:
http://softbeta.iteye.com/blog/1185573
http://www.cnblogs.com/happyPawpaw/archive/2013/04/09/3009553.html

更多好文请查看:http://www.cnblogs.com/kodoyang/

点击下方的红色按钮“  关注我  ”吧!

孔东阳

2014/10/2

Java核心 --- 枚举的更多相关文章

  1. Java核心 --- 注解

    Java核心——注解 注解是jdk5以后的新特性,Spring和Hibernate等框架提供了注解的配置方式使用, 本文参考了浪曦风中叶的注解讲解,主要讲解jdk内置注解的用法,注解的声明和定义,以及 ...

  2. Java核心编程快速学习

    Java核心编程部分的基础学习内容就不一一介绍了,本文的重点是JAVA中相对复杂的一些概念,主体内容如下图所示. 反射reflect是理解Java语言工作原理的基础,Java编译器首先需要将我们编写的 ...

  3. Java核心编程快速入门

    Java核心编程部分的基础学习内容就不一一介绍了,本文的重点是JAVA中相对复杂的一些概念,主体内容如下图所示. 反射reflect是理解Java语言工作原理的基础,Java编译器首先需要将我们编写的 ...

  4. Java核心编程快速学习&lpar;转载&rpar;

    http://www.cnblogs.com/wanliwang01/p/java_core.html Java核心编程部分的基础学习内容就不一一介绍了,本文的重点是JAVA中相对复杂的一些概念,主体 ...

  5. 万字长文,62道Java核心面试题,一次性打包送给积极向上的你

    先看再点赞,给自己一点思考的时间,微信搜索[沉默王二]关注这个靠才华苟且的程序员.本文 GitHub github.com/itwanger 已收录,里面还有一线大厂整理的面试题,以及我的系列文章. ...

  6. Java核心类

    Java核心类的学习: 常用类库 io流 集合 多线程 网络编程 调试与优化 XML和JSON 枚举.注解和反射 设计模式

  7. 深入Java核心 Java中多态的实现机制&lpar;1&rpar;

    在疯狂java中,多态是这样解释的: 多态:相同类型的变量,调用同一个方法时,呈现出多中不同的行为特征, 这就是多态. 加上下面的解释:(多态四小类:强制的,重载的,参数的和包含的) 同时, 还用人这 ...

  8. Java核心:类加载和JVM内存的分配

    类的加载: 指的是将class文件的二进制数据读入到运行时数据区(JVM在内存中划分的) 中,并在方法区内创建一个class对象. 类加载器: 负责加载编译后的class文件(字节码文件)到JVM(J ...

  9. 深入Java核心 Java内存分配原理精讲

    深入Java核心 Java内存分配原理精讲 栈.堆.常量池虽同属Java内存分配时操作的区域,但其适用范围和功用却大不相同.本文将深入Java核心,详细讲解Java内存分配方面的知识. Java内存分 ...

随机推荐

  1. JavaScript如何使用this

    学习this的使用必须牢记以下两点 1.this是一个只能在函数内部使用的关键字 2.this指向调用函数的那个对象 下面我们来具体讨论一下this的具体使用方法 第一种:通过函数调用的方式----- ...

  2. MongoDB常用操作总结

    ====================================MGDB的操作====================================== 0.创建数据库时使用(use 数据库 ...

  3. Javascript操纵Cookie--转

    引用地址:http://www.imkevinyang.com/2009/06/javascript%E6%93%8D%E7%BA%B5cookie.html 在讲如何使用Javascript操纵Co ...

  4. jQuery鼠标事件

    鼠标事件是在用户移动鼠标光标或者使用任意鼠标键点击时触发的.   (1):click事件:click事件于用户在元素敲击鼠标左键,并在相同元素上松开左键时触发.        $('p').click ...

  5. 同时存在两个或多个homestead 虚拟box

    开发中发现,不同版本的homestead 里面的环境各不相同,里面的node,npm等版本都不一致,如果需要添加 不同版本的homestead同时存在可以按照以下办法处理. tips: 提供可以离线下 ...

  6. mysql-connector-python

    wget http://cdn.mysql.com//Downloads/Connector-Python/mysql-connector-python-2.1.3.tar.gz tar mysql- ...

  7. JPA字段映射(uuid&comma;日期,枚举&comma;&commat;Lob)

    转:http://www.cnblogs.com/tazi/archive/2012/01/04/2311588.html 主键: JPA主键的生成策略不像Hibernate那么丰富. @Id @Ge ...

  8. 【3】python核心编程 第五章-数字

    1.用大写字母 “L”表示长整数 尽管 Python 也支持用小写字母 L 标记的长整型,但是我们郑重推荐您仅使用大写的 “L”, 这样能有效避免数字1 和小写L 的混淆.Python 在显示长整数类 ...

  9. MyBatis3系列&lowbar;&lowbar;02接口式编程

    hello world MyBatis3支持面向接口编程: 具体做法如下,将helloWorld中的EmployeeMapper.xml文件进行更改: <?xml version="1 ...

  10. 聊聊阿里社招面试,谈谈&OpenCurlyDoubleQuote;野生”Java程序员学习的道路

    引言 很尴尬的是,这个类型的文章其实之前笔者就写过,原文章里,笔者自称LZ(也就是楼主,有人说是老子的简写,笔者只想说,这位同学你站出来,保证不打死你,-_-),原文章名称叫做<回答阿里社招面试 ...