`

小谈java Enum的多态

    博客分类：
  • J2SE
JavaAppleJDKJVMBlog 
阅读更多
Enum+多态，我没说错，不过Enum是不可以被继承的，也不可以继承自别人，只是能实现接口而已，何谈多态？
不过还是先看看“现象”吧：
Java代码

   1. public enum Fruit { 
   2.     APPLE, PEAR, PEACH, ORANGE; 
   3. } 

public enum Fruit {
    APPLE, PEAR, PEACH, ORANGE;
}


以上是一个简单的enum,关于它，我要补充一点：
Fruit是java.lang.Enum的子类，准确地说，是Enum<Fruit>的子类，这里出现了一个继承关系，不过这个继承是编译器帮我们做的，我们不能显式地去做。不信的话我们可以试着用一个Enum<Fruit>的引用去指向一个APPLE，肯定是没问题的，我就不再试了。
为了更直观地说明这一点，我们来看看Fruit的反编译结果吧：
Java代码

   1. package test; 
   2.  
   3.  
   4. public final class Fruit extends Enum 
   5. { 
   6.  
   7.     private Fruit(String s, int i) 
   8.     { 
   9.         super(s, i); 
  10.     } 
  11.  
  12.     public static Fruit[] values() 
  13.     { 
  14.         Fruit afruit[]; 
  15.         int i; 
  16.         Fruit afruit1[]; 
  17.         System.arraycopy(afruit = ENUM$VALUES, 0, afruit1 = new Fruit[i = afruit.length], 0, i); 
  18.         return afruit1; 
  19.     } 
  20.  
  21.     public static Fruit valueOf(String s) 
  22.     { 
  23.         return (Fruit)Enum.valueOf(test/Fruit, s); 
  24.     } 
  25.  
  26.     public static final Fruit APPLE; 
  27.     public static final Fruit PEAR; 
  28.     public static final Fruit PEACH; 
  29.     public static final Fruit ORANGE; 
  30.     private static final Fruit ENUM$VALUES[]; 
  31.  
  32.     static  
  33.     { 
  34.         APPLE = new Fruit("APPLE", 0); 
  35.         PEAR = new Fruit("PEAR", 1); 
  36.         PEACH = new Fruit("PEACH", 2); 
  37.         ORANGE = new Fruit("ORANGE", 3); 
  38.         ENUM$VALUES = (new Fruit[] { 
  39.             APPLE, PEAR, PEACH, ORANGE 
  40.         }); 
  41.     } 
  42. } 

package test;


public final class Fruit extends Enum
{

    private Fruit(String s, int i)
    {
        super(s, i);
    }

    public static Fruit[] values()
    {
        Fruit afruit[];
        int i;
        Fruit afruit1[];
        System.arraycopy(afruit = ENUM$VALUES, 0, afruit1 = new Fruit[i = afruit.length], 0, i);
        return afruit1;
    }

    public static Fruit valueOf(String s)
    {
        return (Fruit)Enum.valueOf(test/Fruit, s);
    }

    public static final Fruit APPLE;
    public static final Fruit PEAR;
    public static final Fruit PEACH;
    public static final Fruit ORANGE;
    private static final Fruit ENUM$VALUES[];

    static
    {
        APPLE = new Fruit("APPLE", 0);
        PEAR = new Fruit("PEAR", 1);
        PEACH = new Fruit("PEACH", 2);
        ORANGE = new Fruit("ORANGE", 3);
        ENUM$VALUES = (new Fruit[] {
            APPLE, PEAR, PEACH, ORANGE
        });
    }
}


注意这几行：
Java代码

   1. public static final Fruit APPLE; 
   2.     public static final Fruit PEAR; 
   3.     public static final Fruit PEACH; 
   4.     public static final Fruit ORANGE; 

public static final Fruit APPLE;
    public static final Fruit PEAR;
    public static final Fruit PEACH;
    public static final Fruit ORANGE;


看来JDK Enum的实现也不过就是沿袭了Effective Java中提出的TypeSafeEnum模式，只不过是在编译器和JVM等更底层的级别上提供了支持。

至此，至少说明了Fruit和Enum的继承关系，但问题是：现在不能继续再从Fruit派生子类，那么哪来的多态呢？

还是再多写点代码吧：
Java代码

   1. public enum Fruit { 
   2.     APPLE { 
   3.  
   4.         public void test() { 
   5.             System.out.println("I am an apple."); 
   6.         } 
   7.     }, 
   8.     PEAR { 
   9.  
  10.         public void test() { 
  11.             System.out.println("I am a pear."); 
  12.         } 
  13.     }, 
  14.     PEACH { 
  15.  
  16.         public void test() { 
  17.             System.out.println("I am a peach."); 
  18.         } 
  19.     }, 
  20.     ORANGE; 
  21.  
  22.     public void test() { 
  23.         System.out.println("I am a fruit."); 
  24.     } 
  25. } 

public enum Fruit {
    APPLE {

        public void test() {
            System.out.println("I am an apple.");
        }
    },
    PEAR {

        public void test() {
            System.out.println("I am a pear.");
        }
    },
    PEACH {

        public void test() {
            System.out.println("I am a peach.");
        }
    },
    ORANGE;

    public void test() {
        System.out.println("I am a fruit.");
    }
}


其中，只有Orange没有Overide test()方法；
我们在主函数中调用它们：
Java代码

   1. public static void main(String[] args) { 
   2.         Fruit.APPLE.test(); 
   3.         Fruit.PEAR.test(); 
   4.         Fruit.PEACH.test(); 
   5.         Fruit.ORANGE.test(); 
   6.     } 

public static void main(String[] args) {
        Fruit.APPLE.test();
        Fruit.PEAR.test();
        Fruit.PEACH.test();
        Fruit.ORANGE.test();
    }


输出结果：
引用
I am an apple.
I am a pear.
I am a peach.
I am a fruit.

可以看到，重新定义了test方法的APPLE,PEAR,PEACH覆盖了从父类继承过来的默认行为，而未从新定义test方法的ORANGE却沿袭了父类的行为，多态性在这里展现出来了。

那么我们刚才明明看见过Fruit的反编译结果，没有任何新类继承自Fruit，那么这些多态行为是哪里冒出来的呢？说它是“多态”是否准确呢？
其实，Fruit类在这个时候已经发生了微妙的变化，一切都与JDK的Enum的实现有关，我们现在可以到编译结果目录下面看看：

怎么除了Fruit.class之外，还多了几个貌似是内部类的class文件？？也许看到这里我们能有点线索了，不过还是在这个时候在看看反编译结果吧，看看它到底在搞什么鬼：
Java代码

   1. // Decompiled by Jad v1.5.8e. Copyright 2001 Pavel Kouznetsov. 
   2. // Jad home page: http://www.geocities.com/kpdus/jad.html 
   3. // Decompiler options: packimports(3)  
   4. // Source File Name:   Fruit.java 
   5.  
   6. package test; 
   7.  
   8. import java.io.PrintStream; 
   9.  
  10. public class Fruit extends Enum 
  11. { 
  12.  
  13.     private Fruit(String s, int i) 
  14.     { 
  15.         super(s, i); 
  16.     } 
  17.  
  18.     public void test() 
  19.     { 
  20.         System.out.println("I am a fruit."); 
  21.     } 
  22.  
  23.     public static Fruit[] values() 
  24.     { 
  25.         Fruit afruit[]; 
  26.         int i; 
  27.         Fruit afruit1[]; 
  28.         System.arraycopy(afruit = ENUM$VALUES, 0, afruit1 = new Fruit[i = afruit.length], 0, i); 
  29.         return afruit1; 
  30.     } 
  31.  
  32.     public static Fruit valueOf(String s) 
  33.     { 
  34.         return (Fruit)Enum.valueOf(test/Fruit, s); 
  35.     } 
  36.  
  37.     Fruit(String s, int i, Fruit fruit) 
  38.     { 
  39.         this(s, i); 
  40.     } 
  41.  
  42.     public static final Fruit APPLE; 
  43.     public static final Fruit PEAR; 
  44.     public static final Fruit PEACH; 
  45.     public static final Fruit ORANGE; 
  46.     private static final Fruit ENUM$VALUES[]; 
  47.  
  48.     static  
  49.     { 
  50.         APPLE = new Fruit("APPLE", 0) { 
  51.  
  52.             public void test() 
  53.             { 
  54.                 System.out.println("I am an apple."); 
  55.             } 
  56.  
  57.         }; 
  58.         PEAR = new Fruit("PEAR", 1) { 
  59.  
  60.             public void test() 
  61.             { 
  62.                 System.out.println("I am a pear."); 
  63.             } 
  64.  
  65.         }; 
  66.         PEACH = new Fruit("PEACH", 2) { 
  67.  
  68.             public void test() 
  69.             { 
  70.                 System.out.println("I am a peach."); 
  71.             } 
  72.  
  73.         }; 
  74.         ORANGE = new Fruit("ORANGE", 3); 
  75.         ENUM$VALUES = (new Fruit[] { 
  76.             APPLE, PEAR, PEACH, ORANGE 
  77.         }); 
  78.     } 
  79. } 

// Decompiled by Jad v1.5.8e. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.geocities.com/kpdus/jad.html
// Decompiler options: packimports(3)
// Source File Name:   Fruit.java

package test;

import java.io.PrintStream;

public class Fruit extends Enum
{

    private Fruit(String s, int i)
    {
        super(s, i);
    }

    public void test()
    {
        System.out.println("I am a fruit.");
    }

    public static Fruit[] values()
    {
        Fruit afruit[];
        int i;
        Fruit afruit1[];
        System.arraycopy(afruit = ENUM$VALUES, 0, afruit1 = new Fruit[i = afruit.length], 0, i);
        return afruit1;
    }

    public static Fruit valueOf(String s)
    {
        return (Fruit)Enum.valueOf(test/Fruit, s);
    }

    Fruit(String s, int i, Fruit fruit)
    {
        this(s, i);
    }

    public static final Fruit APPLE;
    public static final Fruit PEAR;
    public static final Fruit PEACH;
    public static final Fruit ORANGE;
    private static final Fruit ENUM$VALUES[];

    static
    {
        APPLE = new Fruit("APPLE", 0) {

            public void test()
            {
                System.out.println("I am an apple.");
            }

        };
        PEAR = new Fruit("PEAR", 1) {

            public void test()
            {
                System.out.println("I am a pear.");
            }

        };
        PEACH = new Fruit("PEACH", 2) {

            public void test()
            {
                System.out.println("I am a peach.");
            }

        };
        ORANGE = new Fruit("ORANGE", 3);
        ENUM$VALUES = (new Fruit[] {
            APPLE, PEAR, PEACH, ORANGE
        });
    }
}


注意这段代码：
Java代码

   1. static  
   2.     { 
   3.         APPLE = new Fruit("APPLE", 0) { 
   4.  
   5.             public void test() 
   6.             { 
   7.                 System.out.println("I am an apple."); 
   8.             } 
   9.  
  10.         }; 
  11.         PEAR = new Fruit("PEAR", 1) { 
  12.  
  13.             public void test() 
  14.             { 
  15.                 System.out.println("I am a pear."); 
  16.             } 
  17.  
  18.         }; 
  19.         PEACH = new Fruit("PEACH", 2) { 
  20.  
  21.             public void test() 
  22.             { 
  23.                 System.out.println("I am a peach."); 
  24.             } 
  25.  
  26.         }; 
  27.         ORANGE = new Fruit("ORANGE", 3); 

static
    {
        APPLE = new Fruit("APPLE", 0) {

            public void test()
            {
                System.out.println("I am an apple.");
            }

        };
        PEAR = new Fruit("PEAR", 1) {

            public void test()
            {
                System.out.println("I am a pear.");
            }

        };
        PEACH = new Fruit("PEACH", 2) {

            public void test()
            {
                System.out.println("I am a peach.");
            }

        };
        ORANGE = new Fruit("ORANGE", 3);


这个时候的APPLE，PEAR，PEACH已经以匿名内部类的方式对Fruit进行了Overide，自然体现出了多态，多出的那三个疑似内部类的class文件也就是它们！而ORANGE，没有重写test方法，仍然以一个Fruit实例的形式出现。

关于Enum为什么会有多态大概也就这么点猫腻了，那我们来考虑一下它有多大价值吧？

我们或许可以利用这一点来改造Strategy模式，传统的Strategy会产生出稍微多一些的父类、子类，而如果用Enum的话，“一个类 ”（对程序作者来讲）就能搞定，能简化一下类层次，再说了，用枚举来表示区分各种不同策略也是很合情理的，所以，Java Enum的这点小小特性感觉还是比较有前途发挥一些作用的，起码在代码组织上；
更多应用可能或是局限性就还需要逐步在实际应用中摸索。

转自:http://pf-miles.iteye.com/blog/187155
分享到：
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    java中enum枚举的详细用法

    Java中的枚举（enum）类型是在JDK 1.5版本引入的一个强大的特性，它用于定义一组相关的常量。在C/C++等语言中，枚举通常用来表示一组具有固定值的常量集合，但在Java中，枚举不仅限于此，它提供了更多的功能和灵活性...

    Java中enum的用法.pdf

    Java中的枚举（enum）类型是在JDK 1.5版本引入的一种强大的特性，它用于定义一组相关的常量。在C/C++等早期语言中，枚举通常是一种基本的数据类型，而在Java中，枚举是一种类，具有更多的功能和灵活性。 1. **什么...

    Java 实例 - Enum（枚举）构造函数及方法的使用源代码-详细教程.zip

    在Java编程语言中，枚举（Enum）是一种特殊的类，用于定义一组固定的常量。它在许多场景下比常量集合或字符串常量更安全、更方便。本教程将深入探讨Java枚举的构造函数及方法的使用，帮助开发者更好地理解和运用这一...

    Enum的用法

    通过上述分析，可以看出`Enum`不仅是一种数据类型，更是一种设计模式，它集成了封装、继承和多态等面向对象编程的核心概念，为开发者提供了强大的工具箱，用以处理固定集合的常量。然而，`Enum`的使用也需要遵循一定...

    java枚举实例代码

    Java枚举（enum）是Java语言中的一种特殊数据类型，用于定义一组有限的常量，这些常量在程序中作为固定的值使用。枚举在Java中被引入，目的是为了更好地管理和使用常量，提高代码的可读性和安全性。在本实例代码中，...

    javaenum源码-chapter_19_enum_think_in_java:chapter_19_enum_think_in_javac

    Java枚举（Enum）是Java语言中的一个特殊类，它在`java.lang`包下，是面向对象编程中的一种常量表示方式。本章节将深入探讨Java枚举的源码和《Thinking in Java》第十九章中关于枚举的内容。 在Java中，枚举是一种...

    Java详细复习提纲

    - 枚举（enum）：Java的枚举类型用于定义一组固定值的常量集合。 - 泛型（Generics）：提供类型安全的容器，减少类型转换错误。 - 异常处理（Exception Handling）：通过try-catch-finally语句处理程序运行时可能...

    Java软件开发实战 Java基础与案例开发详解 9-7 枚举 共10页.pdf

    - 所有枚举类型都是`java.lang.Enum`的子类。 2. **方法介绍**： - `values()`：返回包含所有枚举常量的数组。 - `valueOf(String name)`：根据名称获取对应的枚举常量。 - 示例代码： ```java for (Train t ...

    Java语言程序设计 基础篇 第10版 梁勇 答案

    Java程序的编写基于类和对象，通过封装、继承和多态等面向对象特性实现代码复用和模块化。 2. **Java语法**：Java语法严谨，包括数据类型（如整型、浮点型、字符型、布尔型）、变量声明、运算符、控制结构（如if...

    java小风扇程序，java作业

    Java小风扇程序是一种基于Java编程语言实现的控制模拟设备的应用，通常用于教学或个人实践，以帮助初学者更好地理解和运用面向对象编程的概念。这个“java作业”可能涉及到基础的类设计、事件处理以及用户交互。 在...

    《新编Java语言程序设计》（清华出版社）习题参考答案.rar

    1. 面向对象：Java支持类、对象、继承、封装和多态等面向对象的特性，使得代码更易于维护和扩展。 2. 自动内存管理：通过垃圾回收机制，Java自动处理内存分配和释放，避免了常见的内存泄漏问题。 3. 异常处理：Java...

    Java-Java面向对象多态性教程

    5. 枚举（Enum）与多态：Java枚举可以被视为单例类的特殊形式，它们也支持多态。枚举类型的每个实例可以有自己的方法，这些方法可以被其他类的引用调用，实现多态行为。 总之，Java的面向对象多态性使得程序设计...

    java面向对象要点概括

    Java是一种广泛使用的面向对象编程语言，其核心特性包括封装、继承、多态和抽象等概念。下面是对这些关键面向对象概念的详细解释。 1. **封装**：封装是面向对象编程的基本原则之一，它指的是将数据（属性）和操作...

    达内JAVA TTS5.0 PDF----JAVA面向对象

    9. 枚举（Enum）：枚举是Java中的一种特殊类，用于表示有限集合的固定值。枚举类型可以提供比常量更强大的功能，包括方法的定义和继承。 10. 内部类（Inner Class）：内部类是定义在一个类内部的类，它可以访问外部...

    JAVA學習手冊

    1. **JAVA语法基础**：了解JAVA的基本结构，如类、对象、封装、继承和多态等面向对象编程概念。学习如何声明变量、数据类型、控制流程（如if语句、循环）以及异常处理。 2. **类与对象**：深入理解类的定义、构造...

    最新Java面试题及答案（Java基础、设计模式、Java虚拟机（jvm))

    随着版本的更新，从Java 5开始，`switch`语句还可以接受`enum`类型；从Java 7开始，又支持了`String`类型。但值得注意的是，`long`类型一直不被支持。 **1.6 计算方法** - 使用位运算进行乘法运算：`2 相当于`2 * ...

    Java选择题武汉大学JAVA基础.pdf

    Java Applet是运行在浏览器中的小Java应用程序，而Java Application是独立运行的Java程序。Java Applet已经过时并被弃用。 10. Java的访问修饰符 包括public、protected、private和默认访问（没有修饰符）。 11. ...

    Java100例 Java100例

    14. **枚举（Enum）**：Java中的枚举是一种特殊的类，用于定义常量，例子将演示其用法。 15. **设计模式**：如单例、工厂、观察者、装饰器等经典设计模式，例子将阐述如何在Java中实现这些模式。 这些例子是学习和...

    达内java讲义02_oop

    - 枚举（Enum）：Java中的枚举类型是一种特殊的类，用于定义一组固定的值，常用于表示有限集合。 - 内部类：在Java中，类可以嵌套在另一个类内部，提供更高级别的封装。 - 接口的默认方法和静态方法：Java 8引入的新...

    codes_java_疯狂java讲义源码_principler6q_elevenfza_

    2. **面向对象编程**：Java的核心特性是面向对象，压缩包中的代码展示了类、对象、封装、继承、多态等概念。你可以看到如何定义类、创建对象，以及如何通过继承和接口实现多态性。 3. **异常处理**：Java的异常处理...

Magicbox
Global site tag (gtag.js) - Google Analytics