JAVA 深入理解 枚举类型 多路分发

最新推荐文章于 2020-05-04 14:43:13 发布
最新推荐文章于 2020-05-04 14:43:13 发布
阅读量790 收藏 1
点赞数 1
分类专栏： Java 深入理解 文章标签： java 枚举 多路并发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33960882/article/details/86490024
版权

JAVA 深入理解 枚举类型 多路分发

枚举分析

Values 方法是编译器自动添加的 而不是父类继承的

package 枚举分析;

import java.lang.reflect.Method;
import java.lang.reflect.Type;
import java.util.Set;
import java.util.TreeSet;

enum Explore {HERE, THERE};

public class Reflection {

    public static Set<String> analyze(Class<?> enumClass){
        System.out.println("--------------Analyzing "+enumClass+"----------------");
        System.out.println("Interfaces: ");
        for(Type t: enumClass.getGenericInterfaces()){
            System.out.print(t);
        }
        System.out.println("Base :"+ enumClass.getAnnotatedSuperclass());
        System.out.println("Methods: ");

        Set<String> methods =new TreeSet<>();
        for(Method m: enumClass.getMethods()){
            methods.add(m.getName());
        }
        System.out.println(methods);
        return  methods;
    }

    public static void main(String [] argv){
        Set<String> ExploreMethods = analyze(Explore.class);
        //[compareTo, equals, getClass, getDeclaringClass, hashCode, name, notify, notifyAll, ordinal, toString, valueOf, values, wait]
        Set<String> enumExploreMethods = analyze(Enum.class);
        //[compareTo, equals, getClass, getDeclaringClass, hashCode, name, notify, notifyAll, ordinal, toString, valueOf, wait]
        ExploreMethods.containsAll(enumExploreMethods);
    }
}

getEnumConstants() 父类方法 获得所有枚举类型

enum Search{HITHER,YON};
public class UpcastNume {
    public static void main(String [] argv){
        Search[] vals = Search.values();//Values 方法是编译自动添加的 而不是从父类继承的
        System.out.println(Arrays.deepToString(vals));

        Enum e = Search.HITHER;
        for(Enum en: e.getClass().getEnumConstants()){ //父类获得类型的方法
            System.out.println(en + ", ");
        }

        System.out.println("================================");
        Class<Integer> intClass = Integer.class;
        try{
            for(Object en: intClass.getEnumConstants()){//父类方法定义在Class类中，注意使用方法
                System.out.println(en);
            }
        }catch (Exception ex){
            System.out.println(ex.toString());
        }

    }
}

枚举覆盖父类方法

package 枚举分析;

public enum OverrideConstantSpecific {
    NUT,
    BOLT,
    WHAHER{
        void f(){
            System.out.println("Overridden method");//覆盖
        }
    };

    void f(){
        System.out.println("default behavior");
    }

    public static void main(String [] argv){
        for(OverrideConstantSpecific ocs: values()){
            System.out.print(ocs + ": ");
            ocs.f();
        }
    }
}
----->>>
NUT: default behavior
BOLT: default behavior
WHAHER: Overridden method

抽象方法

package 枚举分析;

import java.text.DateFormat;
import java.util.Date;

public enum  ConstantSpecificMethod {
    DATA_TIME{
        @Override
        String getInfo() {
            return DateFormat.getDateInstance().format(new Date());
        }
    },
    ClASSPAHT{
        @Override
        String getInfo() {
            return "CLASSPATH";
        }
    },
    VERSION{
        @Override
        String getInfo() {
            return System.clearProperty("java.version");
        }
    };

    abstract String getInfo();

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

基础知识综合小例子

洗车

package 枚举分析;
import java.util.EnumSet;
public class CarWash {
    public enum Cycle{
        UNDERBODY{
            @Override
            void action() {
                System.out.println("Spraying the underbody");
            }
        },
        WHEELWACH{
            @Override
            void action() {
                System.out.println("Washing the wheels");
            }
        },
        PREWASH{
            @Override
            void action() {
                System.out.println("Loosening the dirt");
            }
        },
        BASIC{
            @Override
            void action() {
                System.out.println("The basic wash");
            }
        },
        HOTWAX{
            @Override
            void action() {
                System.out.println("Applying hot wax");
            }
        },
        RINSE{
            @Override
            void action() {
                System.out.println("Rinsing");
            }
        },
        BLOWDRY{
            @Override
            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();
        }
    }

    @Override
    public String toString() {
        return cycles.toString();
    }

    public static void main(String [] argv){
        CarWash wash = new CarWash();
        System.out.println(wash);
        wash.washCar();

        //Order of addition is unimportant:
        wash.add(Cycle.BLOWDRY);
        wash.add(Cycle.RINSE);
        wash.add(Cycle.HOTWAX);
        wash.add(Cycle.BLOWDRY);
        wash.add(Cycle.BLOWDRY);

        System.out.println(wash);
        wash.washCar();
    }
}

来点高端的 枚举多路并发

猜拳例子

//自限定
public interface Competitor <T extends Competitor<T>>{
    OutCome compete(T competitor);
}

public class Enums {
    private static Random rand = new Random(40);
    public static <T extends Enum<T> & Competitor<T>> T random(Class<T> resbClass) {
        T[] es = resbClass.getEnumConstants();
        return es[rand.nextInt(es.length)];
    }
}
public enum  OutCome {
    WIN{  public String toString() {    return "胜";}     },
    LOSE {   public String toString() {    return "败";   }     },
    DRAW {   public String toString() {  return "平";   }    }; 
    public  abstract String toString();
    public  String  OutComeInfo(){
        return "游戏结果";
    }
}

public class RoShamBo { 
    public static <T extends Competitor<T>> void match(T a, T b){
        System.out.println(a + "  vs. " + b +": " + a.compete(b));
    }
    public static <T extends Enum<T> & Competitor<T>> void play(Class<T> resbClass, int size){
        for(int i = 0; i< size; i++){
            match(Enums.random(resbClass), Enums.random(resbClass));
        }
    }
}

最菜的实现的方式

import static 猜拳游戏.OutCome.DRAW;
import static 猜拳游戏.OutCome.LOSE;
import static 猜拳游戏.OutCome.WIN;

//通过函数重载实现分发
interface Item{
    OutCome compete(Item it);
    OutCome eval(Paper p);
    OutCome eval(Scissors s);
    OutCome eval(Rock r);
}

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

class Scissors implements Item{
    @Override
    public OutCome compete(Item it) {
        return it.eval(this);
    }
    @Override
    public OutCome eval(Paper p) {
        return LOSE;
    }
    @Override
    public OutCome eval(Scissors s) {
        return DRAW;
    }
    @Override
    public OutCome eval(Rock r) {
        return WIN;
    }
    @Override
    public String toString() {
        return "Scissors";
    }
}
class Rock implements Item{
    @Override
    public OutCome compete(Item it) {
        return it.eval(this);
    }
    @Override
    public OutCome eval(Paper p) {
        return WIN;
    }
    @Override
    public OutCome eval(Scissors s) {
        return LOSE;
    }
    @Override
    public OutCome eval(Rock r) {
        return DRAW;
    }
    @Override
    public String toString() {
        return "Rock";
    }
}
public class RoshamBo1 {
    static final int SIZE = 20;
    private static Random rand = new Random(40);
    public static Item newItem(){
        switch (rand.nextInt(3)){
            default:return null;
            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 [] argv) {
        for (int i=0; i < SIZE; i++) {
                match(newItem(), newItem());
        }
    }
}

结果和代码绑定

package 猜拳游戏;

import static 猜拳游戏.OutCome.*;

public enum RoshamBo2 implements Competitor<RoshamBo2> {
    PAPER(DRAW, LOSE, WIN){
        @Override
        public String toString() {
            return "布 ";
        }
    },
    SCISSORS(WIN, DRAW, LOSE) {
        @Override
        public String toString() {
            return "剪刀";
        }
    },
    ROCK(LOSE, WIN, DRAW) {
        @Override
        public String toString() {
            return "石头";
        }
    };

    public abstract String toString();

    private  OutCome vPAPER, vSICISSOR, vROCK;
    RoshamBo2(OutCome paper, OutCome scissors, OutCome rcok){
        this.vPAPER = paper;
        this.vSICISSOR = scissors;
        this.vROCK = rcok;
    }

    @Override
    public OutCome compete(RoshamBo2 it) {
        switch (it){
            default: return null;
            case PAPER:return vPAPER;
            case SCISSORS:return vSICISSOR;
            case ROCK:return vROCK;
        }
    }

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

枚举与switch 结合

package 猜拳游戏;


import static 猜拳游戏.OutCome.*;

public enum RoShamBo3 implements Competitor<RoShamBo3> {
    PAPER{
        public OutCome compete(RoShamBo3 it){
            switch (it){
                default:
                case  PAPER: return DRAW;
                case SCISSORS:return LOSE;
                case ROCK: return WIN;
            }
        }
    },
    SCISSORS{
        public OutCome compete(RoShamBo3 it){
            switch (it){
                default:
                case  PAPER: return WIN;
                case SCISSORS:return DRAW;
                case ROCK: return LOSE;
            }
        }
    },
    ROCK{
        public OutCome compete(RoShamBo3 it){
            switch (it){
                default:
                case  PAPER: return LOSE;
                case SCISSORS:return WIN;
                case ROCK: return DRAW;
            }
        }
    };

    @Override
    public  abstract OutCome compete(RoShamBo3 competitor);

    public static void main(String [] argv){
        RoShamBo.play(RoShamBo3.class, 20);
    }
}

这个方法感觉比较优秀

package 猜拳游戏;


public enum RoShamBo4 implements Competitor<RoShamBo4> {
    PAPER{
        public OutCome compete(RoShamBo4 it){
            return compete(ROCK, it);
        }
    },
    SCISSORS{
        public OutCome compete(RoShamBo4 it){
            return compete(PAPER, it);
        }
    },
    ROCK{
        public OutCome compete(RoShamBo4 it) {
            return compete(SCISSORS, it);
        }
    };

    public OutCome compete(RoShamBo4 loser, RoShamBo4 opponent) {
        return ((opponent == this)? OutCome.DRAW:((opponent == loser)? OutCome.WIN:OutCome.LOSE));
    }

    @Override
    public   OutCome compete(RoShamBo4 competitor){
        return null;
    }

    public static void main(String [] argv){
        RoShamBo.play(RoShamBo4.class, 20);
    }
}

使用EnumMap

package 猜拳游戏;

import java.util.EnumMap;

import static 猜拳游戏.OutCome.*;

public enum RoShamBo5 implements Competitor<RoShamBo5> {
    PARER, SCISSORS, ROCK;

    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(PARER, DRAW, LOSE, WIN);
        initRow(SCISSORS, WIN, DRAW, LOSE);
        initRow(ROCK, LOSE, WIN, DRAW);
    }

    private static void initRow(RoShamBo5 it, OutCome vPARER, OutCome vSCISSORS, OutCome vROCK) {
        EnumMap<RoShamBo5, OutCome> row = RoShamBo5.table.get(it);
        row.put(RoShamBo5.PARER, vPARER);
        row.put(RoShamBo5.SCISSORS, vPARER);
        row.put(RoShamBo5.ROCK, vROCK);
    }

    @Override
    public OutCome compete(RoShamBo5 competitor) {
        return table.get(this).get(competitor);
    }

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

}

结合数组 （很高效）

package 猜拳游戏;

import static 猜拳游戏.OutCome.*;

public enum RoShamBo6 implements Competitor<RoShamBo6> {
    PARER, SCISSORS, ROCK;

    private static OutCome[][] table = {
            {DRAW, LOSE, WIN},
            {WIN, DRAW, LOSE},
            {LOSE, WIN, DRAW}
    };

    @Override
    public OutCome compete(RoShamBo6 competitor) {
        return table[this.ordinal()][competitor.ordinal()];
    }

    public static void main(String [] argv){
        RoShamBo.play(RoShamBo6.class, 20);
    }

}
青山不改&绿水长流
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
使用枚举实现策略模式实现多路分发
weixin_44168259的博客
03-03 314
创建一个抽象父类需要子类实现其抽象方法 public abstract class extendsTest { public abstract String print(); } //子类需要继承并实现父类的抽象方法 模拟不同的分发 public class Test1 extends ExtendsTest { @Override public String print() { return getClass().getName(); } } //---------------------
java实现多路分发
chivalry
08-24 7841
http://blog.csdn.net/godwanglong/article/details/7937668 多路分发就是指在调用a.plus(b)，a和b都不知道确切类型，也能让他们正常交互。     如果想使用两路分发，那么必须有两个方法调用，第一个方法调用决定第一个未知类型，第二个方法调用决定第二个未知类型。要利用多路分发，程序员必须为每一个类型提供给一个实际的方法调用。一般而言
java单分派与多分派（多路分发和单路分发）
管子（zero）的杂乱空间
02-20 212
1.分派的概念 变量被声明时的类型叫做变量的静态类型(Static Type) 又叫明显类型(Apparent Type)。变量所引用的对象的真实类型又叫做变量的实际类型(Actual Type)。 根据对象的类型而对方法进行的选择,就是分派(Dispatch)。根据分派发生的时期，可以将分派分为两种，即分派分静态分派和动态分派。 静态分派(Static Dispatch) 发生在编译时期，...
JavaNote 2.3枚举、分支、循环
LetsStudy的博客
04-25 299
一、枚举
多路分发
我本颠坤
10-29 1658
何为多路分发: java只持单路分发,即如果要执行的操作包含不止一个类型未知的对象时, 那么动态绑定机制只能处理处中的一个类型， 如果需要处理两个类型,可以使用多路分发, 如果想使用两路分发，就必须要有两个方法调用： 第一个方法调用决定第一个未知类型， 第二个方法调用决定第二个未知类型 基于接口实现 Item package c
multiplatform-distribution:Java应用程序的多平台分发
05-18
Java应用程序的多平台分发 该示例演示了如何为Java 10中的应用程序创建多平台发行版。 要求 编译和包创建 对于Windows和macOS ： mvn clean package -P native-deploy 对于Linux ： mvn clean package -P native...
Java 的双重分发与 Visitor 模式实例详解
08-27
Java 中的双重分发（Double Dispatch）是一种机制，允许在运行时确定方法的调用，而不仅仅是根据方法的接收者，还受参数类型的决定。这种机制可以实现面向对象的多态。 在 Java 中，静态分发（Single Dispatch）是...
智能驾驶电子地图路侧分发机制
最新发布
05-13
主要用于针对高精地图面向车路协同场景下完成地图数据的分发。 本文件规定了整体智能驾驶电子地图路侧分发的工作内容及流程，本文件的目的是针对不同智能驾驶场景，提供地图分发策略，明确路车交互方式，向车端提供...
JAVA爬虫分发控制端源代码
10-26
本代码为上市公司JAVA原代码，有maven构建，主要功能是接受存在Redis内的任务，通过计算路径权重，分配不同的采集通道，启动不同的采集代码。
Java源码打包分发源码 打包免签分发平台+搭建说明
04-09
打包分发源码_ 还没泛滥的一款打包免签分发平台+搭建说明 搭建需要一点技术-Java 的有点麻烦-不过暂时还没泛滥，含简单说明，自行研究，不提供技术服务。
JAVA枚举类型的用法详解
09-12
JAVA枚举类型的用法详解 例举了JAVA 枚举类型常见用法
java enum多路分发下浅识表驱动式编程
weixin_34355881的博客
05-20 138
由于java的动态绑定只能处理一个类型,所以如果要执行的操作包含不止一个类型未知的对象时,就需要使用多路分发.其中多路分发使用了多态机制,所以只能发生在方法调用时.以石头,剪刀,布的例子说明 1 使用enum分发 定义返回结果: package enumeration; public enum Outcome { WIN,LOSE,D...
枚举类型（6）：多路分发
游王子的博客
05-04 363
当你要处理多种交互类型时，程序可能会变得相当杂乱。举例来说，如果一个系统要分析和执行数学表达式。我们可能会声明Number.plus(Number)、Number.multiple(Number)等等，其中Number是各种数字对象的超类。然而，当你声明a-plus(b)时，你并不知道a或b的确切类型，那你如何能让它们正确的交互呢？ 你可能从未思考过这个问题的答案。java只支持...
多路分发-枚举类型
Asmots的专栏
11-13 1126
java只支持单路并发
多路分发2[使用enum分发]
racingcof的专栏
02-05 166
直接将RoShamBo1.java翻译为基于enum的版本是有问题的，因为enum实例不是类型， 不能将enum实例作为参数的类型，所以无法重载eval方法。   利用构造器来初始化每个enum实例，并以"一组"结果作为参数。二者放在一块，形成了 类似查询表的结构。   public interface Competitor&lt;T extends Competito...
java基础总结 --- enum枚举实现多路分发 石头、剪刀、布游戏示例
zghwaicsdn的专栏
02-11 2555
多路分发： 当你处理多种交互类型时，程序可能会变得相当杂乱。举例来说，如果一个系统要分析 和执行数学表达式。我们可能会声明Number.plus(Number)、Number.mulitple(Number)等等， 其中Number是各种数字对象的超类。然而，当你声明a.plus(b)时，你并不知道a或者b的确切类型，那你如何能让它们正确交互呢？ 你可能从未思考过这个问题的答案。Jav
Java之 枚举
C_U_N_Z的博客
04-11 198
1.1实际上枚举就是一种高级的多例设计模式。 eg：基于枚举开发 enum Color { RED,GREEN,BLUE } public class TestDemo { public static void main(String[] args) { System.out.println(Color.BLUE); ...
JAVA 枚举详解(枚举基本使用高级用法枚举扩展)
热门推荐
July_whj
03-02 1万+
JAVA 枚举详解 ​ java 枚举类型的基本想法非常简单：这些类通过共有的静态final域为每个枚举常量导出一个实例。枚举类型没有可以访问的构造器，所以它是真的final类。客户端不能创建枚举类型的实例，也不能对它进行扩展，因此不存实例，而只存在声明过程的枚举常量。也就是枚举类型是实例受控的。它们是单例（Singleton）的范型化，本质上是单元素的枚举。 ​ 枚举类型保证了编译时的类型安全。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值