关于枚举、反射、泛型的简单例子

  

 

一、枚举
  
 枚举就是要让某个类型的取值只能为若干个固定值中的一个，否则，编译器就会报错。枚举是一种特殊的类，其中的每个元素都是该类的一个实例对象。定义枚举使     用的关键字是enum。
   
    1、定义的方法必须放到元素列表之后。
              public enum EnumDay{
                     SUM,MON,TUE,WED,THI,FRI,SAT;

                     public EnumDay(){       
                           System.out.println("枚举构造函数");
                     }              
              }
 
    2、定义一个枚举类：RED、GREEN、YELLOW 相当于NnumTraffic的一个子类，所以子类就要重写父类的nextLamp()方法。
             public enum NnumTraffic {
                    RED {
                         @Override
                         public NnumTraffic nextLamp() {
                                   return GREEN;
                         }
                    },
                    GREEN {
                       @Override
                        public NnumTraffic nextLamp() {
                                   return YELLOW;
                      }
                  },
                  YELLOW {
                       @Override
                       public NnumTraffic nextLamp() {

                                   return RED;
                       }
                  };
               public abstract NnumTraffic nextLamp();
           }

二、反射
      1、反射的基石是Class类。Java程序中的各个Java类属于同一类事物，描述这类事物的Java类名就是Class。
    
          （1）如何得到各个字节码对应的实例对象。
 
                         类名.class,例如：Date.class；
                         对象.getClass(),例如：new Date().getClass()；
                         Class.forName("类名")，例如：Class.forName("java.util.Date");
                         public static void main(String[] args){
                                String str ="strings"; 
                                Class class1=str.getClass();
                                Class class2=String.class();
                                Class class3=：Class.forName("java.lang.String");
                                System.out.println(class1==class2);
                                System.out.println(class1==class3);
                          }
     2、反射就是把Java类中的各种成分映射成相应的Java类。一个类中每个成员都可以用相 应的反射API类的一个实例对象来表示。
 
         （1）得到某个类的构造方法。
                       //得到一个带参数的构造方法
                      Constructor con = String.class.getConstructor(StringBuffer.class);
                      String str = (String)con.newInstance(new StringBuffer("fanshe"));
                      System.out.println(str.charAt(3));
         （2）用反射改变类的成员变量的值。但是要注意类里面成员变量的权限（修饰符）
                      public class SetProperty {
                            private int x;
                            public int y;
                            public String str ="ssksshopsszxss";
                            public String str1 ="ssdvbwswssyy";
                            public SetProperty(int x, int y) {
                                    super();
                                    this.x = x;
                                    this.y = y;
                            }
                            @Override
                            public String toString() {
                                   return str+" : "+str1;
                            } 
                    }
                   public class Test {// 测试
  
                           public static void main(String[] args) throws Exception {
                                    SetProperty s = new SetProperty(2, 5);
                                    Field fs = s.getClass().getField("y");//只可以访问公有的成员
                                    System.out.println(fs.get(s));
                                    Field f = s.getClass().getDeclaredField("x");//访问私有的成员
                                    f.setAccessible(true);//允许可以访问私有的成员
                                   System.out.println(f.get(s));
                                   chang(s);
                                   System.out.println(s);
                           }

                         private static void chang(Object obj) throws Exception {
                                   Field[] f = obj.getClass().getFields();
                                   for (Field fi : f) {
                                        // 字节码比较用等号，不是字节码才用equals(）
                                         if (fi.getType() == String.class) {
                                                 String value1 = (String) fi.get(obj);
                                                 String newvalue = value1.replace('s', 'a');
                                                 System.out.println("---" + newvalue);
                                                 fi.set(obj, newvalue);
                                          }
                                   }
                          }
                 }

三、泛型
         泛型是提供javac编译器使用的，可以将一个集合中的元素限定为一个特定类型，集合中只能存储同一个类型的对象，并且当从集合获取一对象时，编译器也可以知道这 个对象的类型，不需要对对象进行强制类型转换。这样方便又安全。
 
        （1）定义一个简单的泛型。
  
                  ArrayList<String> arry = new ArrayList<String>();
                  arry.add("简单的泛型");
                  arry.add("字符串");
                  String elem = arry.get(1);
                  System.out.println("结果是： "+elem);

        （2）泛型中的？通配符的使用。定义一个方法，该方法用于打印出任意参数化类型的集合的所有参数。
  
                   public static void main(String[] args){
                           ArrayList<String> arry = new ArrayList<String>();
                           arry.add("简单的泛型");
                           arry.add("字符串");
                           printCollection(arry);
                    }

                    public static void printCollection(Collection<?> con){
   
                            for(Object obj:con){
    
                                   System.out.println(obj);
                            }   

                    }
   （3）泛型集合类的使用。
 
  
                   public static void main(String[] args){
       
                             HashMap<String,Integer> hashmap= new HashMap<String,Integer>();
                             hashmap.put("Hash",23);
                             hashmap.put("李四",43);
                             hashmap.put("朱雀",24);
                             Set<Map.Entry<String,Integer>> entrySet = hashmap.entrySet();
                             for(Map.Entry<String,Integer> en:entrySet ){

                                        System.out.println("键是："+en.getKey()+"  值是："+en.getValue());
                            } 

                    }