黑马程序员技术交流社区

标题: 枚举 [打印本页]
作者: 刘晶    时间: 2014-4-11 14:55
标题: 枚举
哪位大神能帮我写一个枚举的例子，带注释，主要体现枚举的思想就行
作者: leon_hm    时间: 2014-4-11 15:03
  1. public enum TrafficLamp {
  2.         RED(30) {
  3.                 public TrafficLamp nextLamp() {
  4.                         return GREEN;
  5.                 }
  6.         },
  7.         GREEN(45) {
  8.                 public TrafficLamp nextLamp() {
  9.                         return YELLOW;
  10.                 }
  11.         },
  12.         YELLOW(5) {
  13.                 public TrafficLamp nextLamp() {
  14.                         return RED;
  15.                 }
  16.         };
  17.         int time;

  19.         private TrafficLamp(int time) {
  20.                 this.time = time;
  21.         }

  23.         public abstract TrafficLamp nextLamp();
  24. }
复制代码

可以看看基础加强的视频，里面有详细讲解
作者: 491138002    时间: 2014-4-11 15:16
//枚举定义星期
  1. enum EnumDemo {
  2. 星期一,
  3. 星期二,
  4. 星期三,
  5. 星期四,
  6. 星期五,
  7. 星期六,
  8. 星期日
  9. }
  10. public class Enum {

  12. public static void main(String[] args) {
  13. //得到枚举数组
  14. EnumDemo[] en = EnumDemo.values();

  16. //迭代枚举
  17. for (EnumDemo enumDemo : en) {
  18. switch2(enumDemo);//switch2(EnumDemo.星期一);
  19. }
  20. }

  22. public static void switch2(EnumDemo e) {
  23. switch (e) {
  24. case 星期一:
  25. System.out.println(e.toString() + "<-->" + e.ordinal());
  26. break;
  27. case 星期二:
  28. System.out.println(e.toString() + "<-->" + e.ordinal());
  29. break;
  30. case 星期三:
  31. System.out.println(e.toString() + "<-->" + e.ordinal());
  32. break;
  33. case 星期四:
  34. System.out.println(e.toString() + "<-->" + e.ordinal());
  35. break;
  36. case 星期五:
  37. System.out.println(e.toString() + "<-->" + e.ordinal());
  38. break;
  39. case 星期六:
  40. System.out.println(e.toString() + "<-->" + e.ordinal());
  41. break;
  42. case 星期日:
  43. System.out.println(e.toString() + "<-->" + e.ordinal());
  44. break;
  45. default:
  46. break;
  47. }
  48. }
  49. }
复制代码


作者: H._张_♂    时间: 2014-4-11 15:18
这个是老师的经典例子，我加了我的理解，你可以认真看看，不懂继续问我。

public class EnmuTest{

        /**
         * @param args
         */
        public static void main(String[] args) throws Exception{
                // TODO Auto-generated method stub
               
                Trafficlamp trafficlamp1 =Trafficlamp.Red;
                Trafficlamp trafficlamp2= Trafficlamp.Red.nextLamp();               
               
               
                System.out.println(trafficlamp1.getTime());
                System.out.println(trafficlamp2.getTime());
               
        }
        public enum Trafficlamp{
                Red(30){//这个Red(30)其实就是父类的子类，传入构造函数30,复写父类抽象方法。可以这么理解
                        public Trafficlamp nextLamp() {
                                return Green;
                        }//new一个新对象，使用父类带构造参数的构造方法创建一个带time值为30的子类实例，对其覆写父类的抽象方法。
                },
                Yellow(5){
                        public Trafficlamp nextLamp(){
                                return Red;
                        }
                },
                Green(40){
                        public Trafficlamp nextLamp(){
                                return Red;
                        }
                };
               
                public abstract Trafficlamp nextLamp();//定义父类的抽象方法，子类都必须实现他
                private Trafficlamp(){};//父类的构造方法。子类用着个构造方法new对象
                private int time;//父类的变量
                private Trafficlamp(int time){
                        this.time=time;
                }//指定父类构造方法中带参数
                public int getTime(){
                        return time;
                }//定义一个公用的获取子类构造时的参数time
        }
       
}
作者: demown    时间: 2014-4-11 15:58
没有那么复杂 其实很简单  给你个单例你看看就知道了
    单例 基础视频看完了才理解好的单例  
       class  single
      {
          private single(){}//  私有一个构造方法。
         private static single  s = new single();//私有对象.
          public static single  getInstance()//对外提供访问对象的方法.
          {
             return s ;
           }
      }
        上面代码是单例 的饿汉式  这个方法完全特别容易理解单例的好处。 所谓单例就是 给你们提供一个对象 你们所有人只能访问这个一个对象。
如果不是单例模式 访问他时候new的对象就是一个新的。就是大个比方说 ， 现在我是卖苹果的 ，你们new一个对象 我给你们一个给你一个苹果。
但是有些人呢（比如小孩 吃不完）怎么办那就简单了 用单例 你们俩只能new一个对象 也就是说只能得到一个苹果 这样你们就能共享这个苹果了。
资源共享了.
   上面写的是单例 最简单的单例就是枚举类中就一个元素。所以枚举就是一种特殊的类，其中每个元素都是该类的一个实例对象。枚举内部其实就是把一个构造方法（记住是构造方法不是构造函数）私有然后分别将每个元素分别用一个公有的静态成员变量来表示，他可以有若干个公有方法或者抽象方法。如果是构造函数话 就要把这些封装的构造函数对象放在 构造方法后面 每个构造方法一次排列在调用构造方法对象调用构造函数的时候用（）；（构造函数的排列次位 在java中是0是第一位置）
在白话些就是 枚举把一些方法封装成一个对象来表示，其实单例就是这样的。 然后可以用封装好的对象直接使用。最简单单例，格式： public enum 枚举名字{元素名字}}例：   public enum enumnume{   element }



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2