Thinking in Java Ch19 枚举

最新推荐文章于 2023-05-24 11:17:56 发布
最新推荐文章于 2023-05-24 11:17:56 发布
阅读量308 收藏
点赞数
分类专栏： 学习笔记 文章标签： Thinking in Java Thinking in Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Y172_85_0/article/details/79537913
版权

19.1 基本enum特性

package Ch19;

import static net.mindview.util.Print.print;
import static net.mindview.util.Print.printnb;

enum Shrubbery{ GROUND, CRAWLING, HANGING }

public class EnumClass {
    public static void main(String[] args) {
        for(Shrubbery s : Shrubbery.values()){
          //ordinal()方法返回enum实例声明时的次序。
            print(s+" ordianl: "+s.ordinal());
            printnb(s.equals(Shrubbery.CRAWLING)+" ");
            print(s==Shrubbery.CRAWLING);
          //返回声明时的类
            print(s.getDeclaringClass());
          //enum实例的名字
            print(s.name());
            print("-------------------");
        }

        for(String s : "HANGING CRAWLING GROUND".split(" ")){
          //静态方法valueOf，返回enum类中给的名字的实例
            Shrubbery shrub = Enum.valueOf(Shrubbery.class, s);
            print(shrub);
        }
    }

}
  /*GROUND ordianl: 0
false false
class Ch19.Shrubbery
GROUND
-------------------
CRAWLING ordianl: 1
true true
class Ch19.Shrubbery
CRAWLING
-------------------
HANGING ordianl: 2
false false
class Ch19.Shrubbery
HANGING
-------------------
HANGING
CRAWLING
GROUND
*/

19.1.1 将静态导入用于enum

//非静态导入
package Ch19;

enum Spiciness{NOT, MILD, MEDIUM, HOT, FLAMING}

public class Burrito {
    Spiciness degree;
    public Burrito(Spiciness degree){this.degree = degree;}
    public String toString() {return "Burrito is "+degree;}

    public static void main(String[] args) {
        System.out.println(new Burrito(Spiciness.NOT));
        System.out.println(new Burrito(Spiciness.MEDIUM));
        System.out.println(new Burrito(Spiciness.HOT));
    }
}

package Ch19;

public enum Spiciness{NOT, MILD, MEDIUM, HOT, FLAMING}

package Ch19;
import static enumerated.Spiciness.*;

public class Burrito {
    Spiciness degree;
    public Burrito(Spiciness degree){this.degree = degree;}
    public String toString() {return "Burrito is "+degree;}

    public static void main(String[] args) {
        System.out.println(new Burrito(NOT));
        System.out.println(new Burrito(MEDIUM));
        System.out.println(new Burrito(HOT));
    }
}
/*Burrito is NOT
Burrito is MEDIUM
Burrito is HOT*/

19.2 向enum中添加新方法

不能继承enum。enum和class是同级关键词。

19.3 switch语句中的enum

package Ch19;

import static tools.Print.print;

enum Signal{GREEN,YELLOW,RED}
public class TrafficLight {
    Signal color = Signal.RED;
    public void change() {
        switch (color) {
            case RED: color = Signal.GREEN;
                        break;
            case GREEN: color = Signal.YELLOW;
                        break;
            case YELLOW: color = Signal.RED;
                break;
        }
    }

    public String toString() {
        return "The traffic light is "+color;
    }

    public static void main(String[] args) {
        TrafficLight t = new TrafficLight();
        for(int i = 0; i<7; i++) {
            print(t);
            t.change();
        }
    }
}

19.4 values的神秘之处

19.5 实现而非继承

package Ch19;

import Ch15.Generator;

import java.util.*;

import Ch7.Cartoon;
import net.mindview.util.*;

enum CartoonCharacter implements Generator<CartoonCharacter>{
    SLAPPY,SPANKY,PUNCHY,SILLY,BOUNCY,NUTTY,BOB;
    private Random rand = new Random(47);
    public CartoonCharacter next() {
        return values()[rand.nextInt(values().length)];
        }
}
public class EnumImplementation {
    public static<T> void printNext(Generator<T> rg){
        System.out.print(rg.next()+". ");
    }

    public static void main(String[] args) {
        CartoonCharacter cc = CartoonCharacter.BOB;
        for(int i=0; i<10; i++)
            printNext(cc);
    }
}
/*BOB. PUNCHY. BOB. SPANKY. NUTTY. PUNCHY. SLAPPY. NUTTY. NUTTY. SLAPPY. */

19.6 随机选取

package Ch19;

import java.util.Random;

public class Enums {
    private static Random rand = new Random(47);
  // <T extends Enum<T>>表示T是enum的一个实例
    public static <T extends Enum<T>> T random(Class<T> ec){
        return random(ec.getEnumConstants());
    }
    public static <T> T random(T[] values){
        return values[rand.nextInt(values.length)];
    }
}

package Ch19;

enum Activity{ SITTING, LYING, STANDING, HOPPING, RUNNING, DODGING, JUMPING, FALLING,FLYING}

public class RandomTest {
    public static void main(String[] args) {
        for(int i=0; i<3; i++)
            System.out.print(Enums.random(Activity.class)+" ");
    }
}

19.7 使用接口组织枚举

package Ch19;
    public interface Food {
        enum Appetizer implements Food {
            sALAD, SOUP, SPRING_ROLL5;
        }
        enum MainCourse implements Food {
            LASAGNE,BURRITO;
        }
    }
package Ch19;

public class TypeOfFood {
    public static void main(String[] args) {
        Food food = Food.Appetizer.sALAD;
        food = Food.MainCourse.LASAGNE;
    }
}
package Ch19;

public enum Course { APPETIZER(Food.Appetizer.class),MAINCOURESE(Food.MainCourse.class),COFFEE(Food.Coffee.class);
    private Food[] values;
    //构造器
    private Course(Class<? extends Food> kind) {
      // 方法返回枚举的实例
        values = kind.getEnumConstants();
    }

    public Food randomSelection(){
      //随机返回数组中元素
        return Enums.random(values);
    }
}

public class Meal {
    public static void main(String[] args) {
        for(int i=0; i<5; i++){
            for(Course course : Course.values()){
                Food food = course.randomSelection();
                System.out.println(food);
            }
            System.out.println("---");
        }
    }
}
/*
SPRING_ROLL5
VINDALOO
HERB_TEA
---
SPRING_ROLL5
BURRITO
ESPRESSO
---
SOUP
PAD_THAT
TEA
---
SOUP
LASAGNE
TEA
---
sALAD
BURRITO
LATTE
---
*/


/*将一个enum嵌套在另外一个enum内*/
package Ch19;
import net.mindview.util.*;

public enum SecurityCategory {
    STOCK(Security.Stock.class), BOND(Security.Bond.class);
    Security[] values;
    //构造器
    SecurityCategory(Class<? extends Security> kind) {
        values = kind.getEnumConstants();
    }
    //将Stock和Bond组织成公共类型。
    interface Security {
        enum Stock implements Security {SHORT, LONG, MARGIN}
        enum Bond implements Security {MUNICIPAL, JUNK}
    }

    public Security randomSelection() {
        return Enums.random(values);
    }

    public static void main(String[] args) {
        for(int i= 0; i<10; i++){
          //
            SecurityCategory category = Enums.random(SecurityCategory.class);
            System.out.println(category+": "+category.randomSelection());
        }
    }
}
/*BOND: MUNICIPAL
BOND: MUNICIPAL
STOCK: MARGIN
STOCK: MARGIN
BOND: JUNK
STOCK: SHORT
STOCK: LONG
STOCK: LONG
BOND: MUNICIPAL
BOND: JUNK
*/

19.8 使用EnumSet替代标志

EnumSet的基础是long，一个long有64位，而一个enum实例只需一位表示存在。最多使用不超过64个元素的enum（实际可以）。

package Ch19;

import java.util.*;
import static Ch19.AlarmPoints.*;
import static net.mindview.util.Print.print;

public class EnumSets {
    public static void main(String[] args) {
        EnumSet<AlarmPoints> points = EnumSet.noneOf(AlarmPoints.class);
        points.add(BATHROOM);
        print(points);
        points.addAll(EnumSet.of(STAIR1,STAIR2,KITCHEN));
        print(points);
        points = EnumSet.allOf(AlarmPoints.class);
        print(points);
        points.removeAll(EnumSet.of(STAIR1, STAIR2, KITCHEN));
        print(points);
        points = EnumSet.complementOf(points);
        print(points);
    }
}
/*[BATHROOM]
[STAIR1, STAIR2, BATHROOM, KITCHEN]
[STAIR1, STAIR2, LOBBY, OFFICE1, OFFICE2, OFFICE3, OFFICE4, BATHROOM, UTILITY, KITCHEN]
[LOBBY, OFFICE1, OFFICE2, OFFICE3, OFFICE4, BATHROOM, UTILITY]
[STAIR1, STAIR2, KITCHEN]*/

19.9 使用EnumMap

package Ch19;

import java.util.*;


import static Ch19.AlarmPoints.*;
import static net.mindview.util.Print.*;

interface Command {void action();}

public class EnumMaps {
    public static void main(String[] args) {
      //EnumMap要求Key必须来自一个enum，EnumMao内部是用数组实现。
        EnumMap<AlarmPoints,Command> em = new EnumMap<>(AlarmPoints.class);

        em.put(KITCHEN, new Command(){
            public void action(){
                print("Kitchen fire!");
            }
        });

        em.put(BATHROOM, new Command(){
            public void action(){
                print("Bathroom alert!");
            }
        });

        for(Map.Entry<AlarmPoints,Command> e : em.entrySet()){
            printnb(e.getKey() +": ");
            e.getValue().action();
        }

        try {
            em.get(UTILITY).action();
        }catch (Exception e){
            print(e);
        }
    }
}
/*BATHROOM: Bathroom alert!
KITCHEN: Kitchen fire!
java.lang.NullPointerException*/
抛出的空指针异常源于enum实例作为一个键总是存在，默认值为null

19.10 常量相关方法

enum允许为enum实例编写方法。需要你为enum定义一个或多个abstract方法，如何为每个enum实例实现该抽象方法。

package Ch19;
// table-driven-code 通过相应的enum实例，可以调用其上的方法。
import java.text.DateFormat;
import java.util.Date;

public enum ConstantSpecificMethod {
    DATE_TIME {
        String getInfo() {
            return DateFormat.getDateInstance().format(new Date());
        }
    },

    CLASSPATH{
      String getInfo(){
          return System.getenv("CLASSPATH");
      }
    },

    VERSION {
        String getInfo() {
            return System.getProperty("java.version");
        }
    };

    abstract String getInfo();

    public static void main(String[] args) {
        for(ConstantSpecificMethod csm : values())
            System.out.println(csm.getInfo());
    }

}
/*2017-11-17
F:\TIJ4\code;
1.8.0_131*/

package Ch19;

import java.util.EnumSet;

public class CarWash {
    public enum Cycle {
        UNDERBODY{
            void action(){
                System.out.println("Spraying");
            }
        },
        WHEELWASH{
            void action(){
                System.out.println("Washing");
            }
        },
        PREWASH{
            void action(){
                System.out.println("Loosening");
            }
        },
        BASIC{
            void action(){
                System.out.println("The basic wash");
            }
        },
        HOTWAX{
            void action(){
                System.out.println("Applying");
            }
        },
        RINSE{
            void action(){
                System.out.println("Rinsing");
            }
        },
        BLOWDRY{
            void action(){
                System.out.println("Blowing dry");
            }
        };
        abstract void action();
    }
    EnumSet<Cycle> cycles = EnumSet.of(Cycle.BASIC,Cycle.RINSE);
    public void add(Cycle cycle){cycles.add(cycle);}
    public void washCar(){
        for(Cycle c : cycles)
            c.action();
    }
    //CarWash的toString调用了cyclyes的toString方法。
    public String toString(){return  cycles.toString();}

    public static void main(String[] args) {
        CarWash wash = new CarWash();
        System.out.println(wash);
        wash.washCar();
        wash.add(Cycle.BLOWDRY);
      //Set重复调用被忽略
        wash.add(Cycle.BLOWDRY);
        wash.add(Cycle.RINSE);
        wash.add(Cycle.HOTWAX);
        System.out.println(wash);
        wash.washCar();
    }
}
/*[BASIC, RINSE]
The basic wash
Rinsing
[BASIC, HOTWAX, RINSE, BLOWDRY]
The basic wash
Applying
Rinsing
Blowing dry*/

19.10.1 使用enum的职责链（chain of Responsibility）

职责链，程序员以多种不同方法来解决一个问题，然后把他们链接在一起。当一个请求到来时，它遍历这个链，直到链中某个解决方法能够处理该请求。

package Ch19;
import java.util.Iterator;
//定义邮件
class Mail {
  //定义邮件可以确认的信息属性。
    enum GeneralDelivery{YES,NO1,NO2,NO3,NO4,NO5}
    enum Scannability{UNSCANNABLE,YES1,YES2,YES3,YES4}
    enum Readability {ILLEGIBLE,YES1,YES2,YES3,YES4}
    enum Address{INCORRECT,OK1,OK2,OK3,OK4,OK5,OK6}
    enum ReturnAddress{MISSING,OK1,OK2,OK3,OK4,OK5}
  // Mail的属性，留待初始化。
    GeneralDelivery generalDelivery;
    Scannability scannability;
    Readability readability;
    Address address;
    ReturnAddress returnAddress;
    static long counter = 0;
    long id = counter++;
    public String toString(){return "Mail "+id;}
  //打印初始化的信息。
    public String details(){
        return toString() +
                ", General Delivery: "+generalDelivery
                +", Address Scanability: "+scannability
                +", Address Readablity: "+readability
                +", Address Address: "+address
                +", Return address: "+returnAddress;
    }
    //不是类名的初始化函数。利用Enums的random函数。
    public static Mail randomMail() {
        Mail m = new Mail();
        m.generalDelivery = Enums.random(GeneralDelivery.class);
        m.scannability = Enums.random(Scannability.class);
        m.readability = Enums.random(Readability.class);
        m.address = Enums.random(Address.class);
        m.returnAddress = Enums.random(ReturnAddress.class);
        return m;
    }
    //generato对象生成器。调用上面random函数。
    public static Iterable<Mail> generator(final int count) {
        return new Iterable<Mail>() {
            int n = count;
            public Iterator<Mail> iterator() {
                return new Iterator<Mail>(){
                    public boolean hasNext(){return n-- >0;}
                    public Mail next() {return randomMail();}
                    public void remove(){throw  new UnsupportedOperationException();}
                };
            }
        };
    }
}
//邮局
public class PostOffice {
  //将不同的邮件的处理方法组织成职责链。
    enum MailHandler {
        GENERAL_DELIVERY {
            boolean handle(Mail m){
                switch(m.generalDelivery) {
                    case YES:
                        System.out.println("Using general delivery for "+m);
                        return true;
                    default:return false;
                }
            }
        },
        MACHINE_SCAN{
            boolean handle(Mail m) {
                switch(m.scannability) {
                    case UNSCANNABLE:return false;
                    default:
                        switch (m.address) {
                            case INCORRECT:return false;
                            default:
                                System.out.println("Delivering "+m+ " automatically");
                                return true;
                        }
                }
            }
        },
        VISUAL_INSPECTION {
            boolean handle(Mail m) {
                switch (m.readability){
                    case ILLEGIBLE:return false;
                    default:
                        switch (m.address) {
                            case INCORRECT:return false;
                            default:
                                System.out.println("Delivering "+m+" normally");
                                return true;
                        }
                }
            }
        },
        RETURN_TO_SENDER {
            boolean handle(Mail m) {
                switch (m.returnAddress){
                    case MISSING : return false;
                    default:
                        System.out.println("Returning "+m+" to sender");
                        return true;
                }
            }
        };

        abstract boolean handle(Mail m);
    }
    //对于每一封邮件，按照职责链匹配职责。
    static void handle(Mail m) {
        for(MailHandler handler : MailHandler.values())
            if(handler.handle(m))
                return;
        System.out.println(m+" is a dead letter");
    }
    //测试
    public static void main(String[] args) {
        for(Mail mail : Mail.generator(3)) {
            System.out.println(mail.details());
            handle(mail);
            System.out.println("*****");
        }
    }

}
/*Mail 0, General Delivery: NO2, Address Scanability: UNSCANNABLE, Address Readablity: YES3, Address Address: OK1, Return address: OK1
Delivering Mail 0 normally
*****
Mail 1, General Delivery: NO5, Address Scanability: YES3, Address Readablity: ILLEGIBLE, Address Address: OK5, Return address: OK1
Delivering Mail 1 automatically
*****
Mail 2, General Delivery: YES, Address Scanability: YES3, Address Readablity: YES1, Address Address: OK1, Return address: OK5
Using general delivery for Mail 2
*****
*/

19.10.2 使用enum状态机？？

枚举类型非常适合用来创建状态机

19.11 多路分发

Java只支持单路分发–也就是说，如果要执行的操作包含了不止一个类型未知的对象时，那么Java的动态绑定机制只能处理其中一个的类型。你必须自己判断其他的类型，从而实现自己的动态绑定行为。

解决方法–多路分发，必须为每个类型提供一个实际的方法调用。

package Ch19;
//所谓类型未知，常指一个基类有很多导出类，调用方法时，不知具体导出类型，只知道基类。
//变量被声明时的类型叫做变量的静态类型(Static Type) 又叫明显类型(Apparent Type)。变量所引用的对象的真实类型又叫做变量的实际类型(Actual Type)。
import static Ch19.Outcome.*;
import java.util.*;

interface Item{
    Outcome compete(Item it);
    Outcome eval(Paper p);
    Outcome eval(Scissors s);
    Outcome eval(Rock r);
}

class Paper implements Item {
  //compete方法解决调用方法的动态绑定，实现第一次分发。内部再调用eval方法，
  //通过参数的重载实现第二次分发

  /*
  方法重载是静态分派（多发）（java中静态绑定），方法重写是动态分派（单发）（java中通过动态绑定实现）。
  如果想要实单发，则compete(par)调用时，par必须是实际类型，将compete重载为三个函数。且同时要求nextitem重写为3个函数，以产生明确的导出类类型。

 a.compete(b)
 a是item，b是item。这样提供一个item接口，避免重载上述compete和nextItem方法。
 先根据a的实际类型选择具体compete方法（动态）。 然后调用eval(b)，（eval重载为三个导出类类型），在调用eval的时候就必须根据b的具体类型来调用（静态）。
  */
    public Outcome compete(Item it){return it.eval(this);}
    public Outcome eval(Paper p){return DRAW;}
    public Outcome eval(Scissors s){return WIN;}
    public Outcome eval(Rock r){return  LOSE;}
    public String toString(){return "Paper";}
}

class Scissors implements Item {
    public Outcome compete(Item it){return it.eval(this);}
    public Outcome eval(Paper p){return LOSE;}
    public Outcome eval(Scissors s){return DRAW;}
    public Outcome eval(Rock r){return  WIN;}
    public String toString(){return "Scissors";}
}

class Rock implements Item{
    public Outcome compete(Item it){return it.eval(this);}
    public Outcome eval(Paper p){return WIN;}
    public Outcome eval(Scissors s){return LOSE;}
    public Outcome eval(Rock r){return  DRAW;}
    public String toString(){return "Rock";}
}

public class RoShaBo1 {
    static final int SIZE = 5;
    private static Random rand = new Random(47);
    public static Item nextItem(){
        switch (rand.nextInt(3)){
            default:
            case 0: return new Scissors();
            case 1: return new Paper();
            case 2: return new Rock();
        }
    }

    public static void match(Item a, Item b) {
        System.out.println(a+" vs. "+b+": "+a.compete(b));
    }

    public static void main(String[] args) {
        for(int i = 0; i<SIZE; i++)
            match(nextItem(),nextItem());
    }
}
/*Rock vs. Rock: DRAW
Paper vs. Rock: WIN
Paper vs. Rock: WIN
Paper vs. Rock: WIN
Scissors vs. Paper: WIN*/

19.11.1 使用enum分发

““java
package Ch19;

import static Ch19.Outcome.*;

public enum RoshamBo2
implements Competitor
{
PAPER(DRAW,LOSE, WIN), SCISSORS(LOSE,WIN,DRAW), ROCK(LOSE,WIN,DRAW);

private Outcome vPAPER;
private Outcome vSCISSORS;
private Outcome vROCK;

RoshamBo2(Outcome paper, Outcome scissors, Outcome rock){
    this.vSCISSORS = scissors;
    this.vPAPER = paper;
    this.vROCK = rock;
}
public Outcome compete(RoshamBo2 it)
{
    switch (it) {
        default:
        case PAPER:
            return this.vROCK;
        case SCISSORS:
            return this.vPAPER;
        case ROCK:
            return this.vSCISSORS;
    }
}

public static void main(String[] args)
{
    RoShamBo.play(RoshamBo2.class, 5);
}

}
/*ROCK vs. ROCK: WIN
SCISSORS vs. ROCK: WIN
SCISSORS vs. ROCK: WIN
SCISSORS vs. ROCK: WIN
PAPER vs. SCISSORS: DRAW
*/
““

19.11.3 使用EnumMap分发

package Ch19;

import java.util.EnumMap;
import static Ch19.Outcome.*;

public enum RoShamBo5 implements Competitor<RoShamBo5>{
    PAPER,SCISSORS,ROCK;
  //EnumMap中定义了final static keyType变量，必须在构造器中初始化。
  //所以有RoShamBo.class
    static EnumMap<RoShamBo5,EnumMap<RoShamBo5,Outcome>> table = new EnumMap<RoShamBo5, EnumMap<RoShamBo5, Outcome>>(RoShamBo5.class);
    static {
      //第一次分发，
        for(RoShamBo5 it : RoShamBo5.values())
            table.put(it,new EnumMap<RoShamBo5,Outcome>(RoShamBo5.class));
      //第二次分发
            initRow(PAPER,DRAW,LOSE,WIN);
            initRow(SCISSORS,WIN,DRAW,LOSE);
            initRow(ROCK,LOSE,WIN,DRAW);
    }

    static void initRow(RoShamBo5 it, Outcome vPAPER, Outcome vSCISSORS, Outcome vROCK){
        EnumMap<RoShamBo5 ,Outcome> row = RoShamBo5.table.get(it);
        row.put(RoShamBo5.PAPER,vPAPER);
        row.put(RoShamBo5.SCISSORS,vSCISSORS);
        row.put(RoShamBo5.ROCK,vROCK);
    }

    public Outcome compete(RoShamBo5 it){
        return table.get(this).get(it);
    }

    public static void main(String[] args) {
        RoShamBo.play(RoShamBo5.class,5);
    }

}//本质也是多维数组
/*ROCK vs. ROCK: DRAW
SCISSORS vs. ROCK: LOSE
SCISSORS vs. ROCK: LOSE
SCISSORS vs. ROCK: LOSE
PAPER vs. SCISSORS: LOSE*/

19.11.4 使用二维数组

数组不安全。

Y172_85_0
关注
专栏目录
Java编程思想---枚举类型
Coder_py的博客
01-12 473
Java编程思想—枚举类型 基本enum特性 调用enum的values()方法，可以遍历enum实例，values方法返回enum实例数组，而且该数组中的元素严格保持在enum中声明时的顺序 public enum Shrubbery { GROUND, CRAWLING, HANGING } public class EnumClass { public...
Thinking in java4（中文高清版）-java的'圣经'
11-20
类型信息 第15章 泛型 第16章 数组 第17章 容器深入研究 第18章 Java I/O系统 第19章 枚举类型 第20章 注解 第21章 并发 第22章 图形化用户界面 附录A 补充材料 可下载的补充材料 Thinking in C：Java的基础 Java...
Java编程思想读书笔记（六）第19章-枚举类型
leonliu06的博客
01-06 1035
所有的enum类都继承自java.lang.Enum类。由于Java不支持多重继承，所以你的enum类不能再继其他类，然而，在我们创建一个新的enum时，可以同时实现一个或多个接口。通过相应的enum实例，我们可以调用其上的方法。这通常也称为表驱动的代码（table-driven code，请注意它与前面提到的命令模式的相似之处）。编译器将枚举类（enum）标记为final类，所以enum类无法被继承。与EnumSet一样，enum实例定义时的次序决定了其在EnumMap中的顺序。
枚举——摘抄自《java编程思想》
luoshaochuan1993的专栏
03-29 473
/*枚举类型enum:当我们需要使用一个只能取特定值的集合时，枚举为我们 *提供了方便，由于枚举类型的实例是常量，所以习惯用大写字母表示 */ enum Spiciness{ NOT,MILD,MEDIUM,HOT,FLAMING } /*public class Test{ public static void main(String[] args){ Spiciness s=Spic
Java编程思想之枚举类型
qq_33403693的博客
08-30 474
1.     关键字enum可以将一组具名的值的有限集合创建为一种新的类型。这些具名的值为该枚举类型的实例对象。 2.     创建enum时，编译器生成一个继承了java.lang.Enum的类。Enum类实现了Comparable接口，所以具有compareTo()方法，还是实现了Serializable接口。 3.     使用static import能够将enum实例的标识符带入当前
Java编程思想笔记——枚举类型
花开不合阳春暮
05-23 697
关键字enum可以将一组具名的值的有限集合创建为一种新的类型，而这些具名的值可以作为常规的程序组件使用。 基本enum特性 values()返回enum实例的数组，而且保持声明的顺序： enum Shrubbery {GROUND, CRAWLING, HANGING} public class EnumClass { public static void main(Strin...
Thinking in Java 4 源码 导入IDEA可直接运行
12-28
《Thinking in Java》是Bruce Eckel的经典之作，第四版（TIJ4）更是Java程序员必读的书籍之一。这本书深入浅出地介绍了Java语言的核心概念和技术，包括面向对象编程、集合框架、多线程、网络编程等众多主题。源码是...
Thinking In Java 源码
03-02
《Thinking in Java》是Bruce Eckel的经典Java编程书籍，它深入浅出地讲解了Java语言的核心概念和技术。这本书不仅适合初学者，也对有经验的程序员提供了深入理解Java的宝贵资源。现在，我们有机会免费下载这本书的...
Java思考，第三版Thinking in Java, 3rd Edition
11-15
大量的教程涵盖了该语言的许多细节，每节都有示例练习，您可以尝试并扩展Java知识。
Thinking in Java 4th Edition Annotated Solutions Guide
08-25
根据提供的文件信息，以下是对文件《Thinking in Java 4th Edition Annotated Solutions Guide》中所包含知识点的详细解释： 首先，文件标题《Thinking in Java 4th Edition Annotated Solutions Guide》指出了这是...
Java编程思想 枚举类型总结
勤劳的搬运工
11-01 394
关键字enum可以将一组具名的值的有限集合创建为一种新的类型 而这些具名的值可以作为常规的程序组件使用 这是一种非常有用的功能 基本enum特性 创建enum时 编译器会为你生成一个相关的类 这个类继承自java.lang.Enum 下面的例子演示了Enum提供的一些功能 将静态导入用于enum Burrito.java的另一个版本 使用static import能够将enum实例的标识符带...
使用vue-print-nb插件实现打印功能。
前端开发小白9527
05-08 1491
使用vue-print-nb插件实现打印功能。
java中的printnb_18 java I/O 系统
weixin_30868873的博客
02-13 275
流的类继承结构我们首先看看流的类继承结构，有助于理解下个标签的内容InputStreamOutputStreamReaderWriterFile类File类技能表示一个特定文件的名称，又能代表一个目录下的一组文件的名称。如果它指的是一个文件集，我们就可以对此集合调用list()方法，这个方法会返回一个字符数组。如果我们想取得不同的目录列表，只需要再创建一个不同的File对象就可以了。实际上，Fil...
java中的printnb_java编程思想之并发(认识多线程)
weixin_42363874的博客
02-25 295
并发编程可以使程序执行速度得到极大的提高，或者为设计某些类型的程序提供更简单的模型。学习并发编程就像进入一个全新的领域，有点类似于学习一门新的编程语言，或者是学习一整套新的语言概念。要理解并发编程与理解面向对象编程差不多。要想真正的掌握它的实质，就需要深入的学习和理解。并发的多面性并发编程令人困惑的一个重要原因是：使用并发时需要解决的问题有多个，而实现并发的方式也有多种，并且这两者之间没有明显的映...
java中的printnb_java 数据类型
weixin_27207591的博客
02-25 334
//: initializtion/PrimitiveOverLoading.javapackageobject;import static net.mindview.util.Print.*;public classPrimitiveOverLoading{void f1(char x){printnb("f1(char)");}void f1(byte x){printnb("f1(byte)...
java高级部分_Java高级部分总结
weixin_30889555的博客
02-12 424
1、数据结构Java工具包提供了强大的数据结构。在Java中的数据结构主要包括以下几种接口和类：枚举、位集合、向量、栈、字典、哈希表、属性。枚举 Enumeration类Enumeration接口定义了一些方法，通过这些方法可以枚举(一次获得一个)对象集合中的元素。下面总结了一些Enumeration声明的方法：1、boolean hasMoreElements( )测试此枚举是否包含更多的元素。...
笔记5
myloveprogrmming的博客
10-15 284
public static void main(String[] args) { for(int i=0;i128;i++) { if(Character.isLowerCase(i))//Characater类位于java.lang包中。isLowerCase(char或int)用于判断char或int类型的参数是否为小写字母
【Java系列】深入解析枚举类型
最新发布
颜淡慕潇
05-24 2万+
Java 枚举（Enum）是一种特殊的数据类型，它是一组预定义的常量，每个常量都有一个名称和一个值。 枚举类型在 Java 中被广泛使用，它可以用来代替常量、标志位、状态码等，使代码更加清晰、易读和易维护。
深入理解Java：Thinking in Java解析
"《Thinking in Java》是一本由Bruce Eckel撰写的关于Java编程的权威书籍，专注于教授Java语言的核心概念和高级特性。" 《Thinking in Java》是面向初学者和有一定经验的程序员的一本经典教程，它不仅仅关注Java...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值