黑马程序员技术交流社区

标题: 关于enum的构造函数与abstract方法的关系 [打印本页]

---

作者: First    时间: 2013-6-17 09:22
标题: 关于enum的构造函数与abstract方法的关系
package test;
import java.lang.reflect.Constructor;
import java.util.Vector;
public class Demo {
/**
  * @param args
  */
public static void main(String[] args) {
  // TODO Auto-generated method stub
  //WeekDay
  int [] is = new int[10];
  //Vector<Integer>  vs [] = new Vector<Integer>[10];  这是什么原因？？
  Class clazz = WeekDay.MON.getClass();//@0   用getClass()获得的构造函数是一个  
  //？1： 为何是一个？ 为何会少掉构造函数？少掉了哪些构造函数？
  Constructor[] cons = clazz.getDeclaredConstructors();
  System.out.println("共有 "+cons.length+" 个构造函数");
  for (Constructor con : cons) {
   System.out.println(con.toGenericString());
  }
  
  Class clazz1 = WeekDay.class;//@1   与@0 相比 用 .class 的方法却获得3个。  
  //？2： 为何是3个 ，多出来的那个构造函数是什么意思？   ？3： 为何与@0 不同？
  Constructor[] cons1 = clazz1.getDeclaredConstructors();
  System.out.println("共有 "+cons1.length+" 个构造函数");
  for (Constructor con : cons1) {
   System.out.println(con.toGenericString());
  }
  
  System.out.println();
  //Weekday1
  Class clazz2 = Weekday1.MON.getClass();//@2  与@0 相比 该方法enum 没有 abstract 方法， 获得的构造函数却是2个
  Constructor[] cons2 = clazz2.getDeclaredConstructors();
  System.out.println("共有 "+cons2.length+" 个构造函数");
  for (Constructor con : cons2) {
   System.out.println(con.toGenericString());
  }
  
  Class clazz3 = Weekday1.class;//@3  比较WeekDay 和 Weekday1,WeekDay仅多了一个abstract方法。
  //说明WeekDay 之所以会多出或少掉构造函数是因为 abstract 方法
  //？4：为何WeekDay 和 Weekday1 会有这样的差异？或者为何abstract方法会造成这样的差异
  Constructor[] cons3 = clazz3.getDeclaredConstructors();
  System.out.println("共有 "+cons3.length+" 个构造函数");
  for (Constructor con : cons3) {
   System.out.println(con.toGenericString());
  }
   
}
}

enum WeekDay{
    SUN(){
            public WeekDay nextDay(){
                    return MON;
            }
    },MON(){
            public WeekDay nextDay(){
                    return SUN;
            }
    };
   
    WeekDay(){
            System.out.println("first");
    }
    WeekDay(int x){
            System.out.println("second");
    }
   
    public abstract WeekDay nextDay();
}
enum Weekday1{
    SUN,MON;
   
    Weekday1(){
            System.out.println("first");
    }
    Weekday1(int x){
            System.out.println("second");
    }
   
}

/*输出结果为：
first
first
共有 1 个构造函数
test.WeekDay$2(java.lang.String,int)
共有 3 个构造函数
private test.WeekDay(java.lang.String,int,int)
private test.WeekDay(java.lang.String,int)
test.WeekDay(java.lang.String,int,test.WeekDay)
first
first
共有 2 个构造函数
private test.Weekday1(java.lang.String,int,int)
private test.Weekday1(java.lang.String,int)
共有 2 个构造函数
private test.Weekday1(java.lang.String,int,int)
private test.Weekday1(java.lang.String,int)
*/

下面是一样的内容，为了方便拷贝

1. package test;
   
2. 
   
3. import java.lang.reflect.Constructor;
   
4. import java.util.Vector;
   
5. 
   
6. public class Demo {
   
7. 
   
8. /**
   
9. * @param args
   
10. */
    
11. public static void main(String[] args) {
    
12. // TODO Auto-generated method stub
    
13. //WeekDay
    
14. int [] is = new int[10];
    
15. //Vector<Integer> vs [] = new Vector<Integer>[10]; 这是什么原因？？
    
16. Class clazz = WeekDay.MON.getClass();//@0 用getClass()获得的构造函数是一个
    
17. //？1： 为何是一个？ 为何会少掉构造函数？少掉了哪些构造函数？
    
18. Constructor[] cons = clazz.getDeclaredConstructors();
    
19. System.out.println("共有 "+cons.length+" 个构造函数");
    
20. for (Constructor con : cons) {
    
21. System.out.println(con.toGenericString());
    
22. }
    
23. 
    
24. Class clazz1 = WeekDay.class;//@1 与@0 相比 用 .class 的方法却获得3个。
    
25. //？2： 为何是3个 ，多出来的那个构造函数是什么意思？ ？3： 为何与@0 不同？
    
26. Constructor[] cons1 = clazz1.getDeclaredConstructors();
    
27. System.out.println("共有 "+cons1.length+" 个构造函数");
    
28. for (Constructor con : cons1) {
    
29. System.out.println(con.toGenericString());
    
30. }
    
31. 
    
32. System.out.println();
    
33. //Weekday1
    
34. Class clazz2 = Weekday1.MON.getClass();//@2 与@0 相比 该方法enum 没有 abstract 方法， 获得的构造函数却是2个
    
35. Constructor[] cons2 = clazz2.getDeclaredConstructors();
    
36. System.out.println("共有 "+cons2.length+" 个构造函数");
    
37. for (Constructor con : cons2) {
    
38. System.out.println(con.toGenericString());
    
39. }
    
40. 
    
41. Class clazz3 = Weekday1.class;//@3 比较WeekDay 和 Weekday1,WeekDay仅多了一个abstract方法。
    
42. //说明WeekDay 之所以会多出或少掉构造函数是因为 abstract 方法
    
43. //？4：为何WeekDay 和 Weekday1 会有这样的差异？或者为何abstract方法会造成这样的差异
    
44. Constructor[] cons3 = clazz3.getDeclaredConstructors();
    
45. System.out.println("共有 "+cons3.length+" 个构造函数");
    
46. for (Constructor con : cons3) {
    
47. System.out.println(con.toGenericString());
    
48. }
    
49. 
    
50. }
    
51. }
    
52. 
    
53. 
    
54. enum WeekDay{
    
55. SUN(){
    
56. public WeekDay nextDay(){
    
57. return MON;
    
58. }
    
59. },MON(){
    
60. public WeekDay nextDay(){
    
61. return SUN;
    
62. }
    
63. };
    
64. 
    
65. WeekDay(){
    
66. System.out.println("first");
    
67. }
    
68. WeekDay(int x){
    
69. System.out.println("second");
    
70. }
    
71. 
    
72. public abstract WeekDay nextDay();
    
73. }
    
74. 
    
75. enum Weekday1{
    
76. SUN,MON;
    
77. 
    
78. Weekday1(){
    
79. System.out.println("first");
    
80. }
    
81. Weekday1(int x){
    
82. System.out.println("second");
    
83. }
    
84. 
    
85. }
    
86. 
    
87. 
    
88. /*输出结果为：
    
89. first
    
90. first
    
91. 共有 1 个构造函数
    
92. test.WeekDay$$$$2(java.lang.String,int)
    
93. 共有 3 个构造函数
    
94. private test.WeekDay(java.lang.String,int,int)
    
95. private test.WeekDay(java.lang.String,int)
    
96. test.WeekDay(java.lang.String,int,test.WeekDay)
    
97. 
    
98. first
    
99. first
    
100. 共有 2 个构造函数
     
101. private test.Weekday1(java.lang.String,int,int)
     
102. private test.Weekday1(java.lang.String,int)
     
103. 共有 2 个构造函数
     
104. private test.Weekday1(java.lang.String,int,int)
     
105. private test.Weekday1(java.lang.String,int)
     
106. 
     
107. */
     

复制代码

---

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

黑马程序员IT技术论坛 X3.2