A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© First 中级黑马   /  2013-6-17 09:22  /  1406 人查看  /  0 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

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. import java.lang.reflect.Constructor;
  3. import java.util.Vector;

  4. public class Demo {

  5. /**
  6. * @param args
  7. */
  8. public static void main(String[] args) {
  9. // TODO Auto-generated method stub
  10. //WeekDay
  11. int [] is = new int[10];
  12. //Vector<Integer> vs [] = new Vector<Integer>[10]; 这是什么原因??
  13. Class clazz = WeekDay.MON.getClass();//@0 用getClass()获得的构造函数是一个
  14. //?1: 为何是一个? 为何会少掉构造函数?少掉了哪些构造函数?
  15. Constructor[] cons = clazz.getDeclaredConstructors();
  16. System.out.println("共有 "+cons.length+" 个构造函数");
  17. for (Constructor con : cons) {
  18. System.out.println(con.toGenericString());
  19. }

  20. Class clazz1 = WeekDay.class;//@1 与@0 相比 用 .class 的方法却获得3个。
  21. //?2: 为何是3个 ,多出来的那个构造函数是什么意思? ?3: 为何与@0 不同?
  22. Constructor[] cons1 = clazz1.getDeclaredConstructors();
  23. System.out.println("共有 "+cons1.length+" 个构造函数");
  24. for (Constructor con : cons1) {
  25. System.out.println(con.toGenericString());
  26. }

  27. System.out.println();
  28. //Weekday1
  29. Class clazz2 = Weekday1.MON.getClass();//@2 与@0 相比 该方法enum 没有 abstract 方法, 获得的构造函数却是2个
  30. Constructor[] cons2 = clazz2.getDeclaredConstructors();
  31. System.out.println("共有 "+cons2.length+" 个构造函数");
  32. for (Constructor con : cons2) {
  33. System.out.println(con.toGenericString());
  34. }

  35. Class clazz3 = Weekday1.class;//@3 比较WeekDay 和 Weekday1,WeekDay仅多了一个abstract方法。
  36. //说明WeekDay 之所以会多出或少掉构造函数是因为 abstract 方法
  37. //?4:为何WeekDay 和 Weekday1 会有这样的差异?或者为何abstract方法会造成这样的差异
  38. Constructor[] cons3 = clazz3.getDeclaredConstructors();
  39. System.out.println("共有 "+cons3.length+" 个构造函数");
  40. for (Constructor con : cons3) {
  41. System.out.println(con.toGenericString());
  42. }

  43. }
  44. }


  45. enum WeekDay{
  46. SUN(){
  47. public WeekDay nextDay(){
  48. return MON;
  49. }
  50. },MON(){
  51. public WeekDay nextDay(){
  52. return SUN;
  53. }
  54. };

  55. WeekDay(){
  56. System.out.println("first");
  57. }
  58. WeekDay(int x){
  59. System.out.println("second");
  60. }

  61. public abstract WeekDay nextDay();
  62. }

  63. enum Weekday1{
  64. SUN,MON;

  65. Weekday1(){
  66. System.out.println("first");
  67. }
  68. Weekday1(int x){
  69. System.out.println("second");
  70. }

  71. }


  72. /*输出结果为:
  73. first
  74. first
  75. 共有 1 个构造函数
  76. test.WeekDay$$$$2(java.lang.String,int)
  77. 共有 3 个构造函数
  78. private test.WeekDay(java.lang.String,int,int)
  79. private test.WeekDay(java.lang.String,int)
  80. test.WeekDay(java.lang.String,int,test.WeekDay)

  81. first
  82. first
  83. 共有 2 个构造函数
  84. private test.Weekday1(java.lang.String,int,int)
  85. private test.Weekday1(java.lang.String,int)
  86. 共有 2 个构造函数
  87. private test.Weekday1(java.lang.String,int,int)
  88. private test.Weekday1(java.lang.String,int)

  89. */
复制代码

0 个回复

您需要登录后才可以回帖 登录 | 加入黑马