jdk1.5之后的新特性

     jdk1.5之后的新特性：

     1. 泛型：

                  一般使用在集合上。可以避免类型转换异常

                   集合上如何使用泛型？

                   常用集合：List     Set     Map

                    泛型语法：集合<E>

                     遍历List：1)普通for循环   2)增强for    3)Iterator迭代器

                     遍历Set：1)增强for      2)Iterator 迭代器

                                      无序，不能有重复元素

                     遍历Map：1)keySet()    2)entrySet()

                           keySet()方式：                       

//先获取Map集合的所有键的Set集合，里面存放的是K的类型，keySet()  

        Set<String> keySet = map.keySet();  

        //有了Set集合就可以获取其迭代器  

        Iterator<String> iterator = keySet.iterator();  

        while(iterator.hasNext()){  

            //取得键  

            String key = iterator.next();  

            //有了键，就可以通过Map集合的get方法获取对应的值  

            String value = map.get(key);  

            System.out.println("key:" + key + ",value:" + value );  

        }    

    entrySet()方式：

//将Map集合中的映射关系取出，存入到Set集合  

        Set<Map.Entry<String,String>> entrySet = map.entrySet();  

        Iterator<Map.Entry<String, String>> iterator = entrySet.iterator();  

        while(iterator.hasNext()){  

            Map.Entry<String, String> entry = iterator.next();  

            //获取key  

            String key = entry.getKey();  

            //获取键  

            String value = entry.getValue();  

            //打印  

            System.out.println("key:" + key + ",value:" + value);  

        }  

     2. 枚举enum：需要在一定的范围内取值，这个值只能是这个范围中的任意一个

               enum Color{ RED , GREEN , YELLOW}

                枚举的构造方法是私有的。

                 在枚举类有构造方法，构造方法里面有参数，需要在每个实例上都写参数

                  枚举类里面有抽象方法，在枚举的每个实例都重写这个抽象方法

                 String  name():返回枚举的名称

                  int  ordinal ()返回枚举下标，下标从0开始

                  static <T extends  Enum<T>> valueOf(Class<T> enumType ,String name)返回带指定名称的指定枚举类型的枚举常量(转换枚举对象)

                   自定义的枚举类在编译阶段自动生成下面的方法：

                         valueOf(String name)：转换枚举对象

                          values()：获得所有枚举对象的数组

                   枚举对象、枚举对象下标、枚举对象名称表示之间的转换：

                        //知道枚举的对象，得到枚举名称和下标

                        @Test

                        public void  test1(){

                          Color c = Color.RED;//得到枚举对象

                          String name = c.name();//枚举名称

                          int index = c.ordinal();//枚举下标          

                     }

                  //知道枚举名称，得到枚举对象和下标

                    @Test

                     public void test2(){

                         String name = "GREEN";

                          Color c = Color.valueOf(name);//得到枚举对象

                          int index = c.ordinal();//得到枚举下标         

                   }

                  

     3. 静态导入

     4.自动拆箱装箱

     5.增强for循环

     6.可变参数

     7. 注解

     8.反射

            反射原理：



              1、首先需要把java文件保存到本地硬盘上

              2、编译java文件，成.class文件

              3、使用JVM，把java文件通过类加载器加载到内存中

              4、万事万物都是对象，java文件在内存中使用Class表示

              5、当使用反射的时候，首先需要获取到Class类，得到了这个类之后，就可以得到class文件里面的所有内容：属性，构造方法，普通方法

              6、属性通过一个类Field

              7、构造方法通过一个类Constructor

              8、普通方法通过一个类 Method

             在框架开发中，都是基于配置文件开发的，在配置文件中配置了类，可以通过反射得到类中的所有内容，可以让类中的某个方法来执行。

              类中的所有内容：属性，没有参数的构造方法，有参数的构造方法，普通方法

             使用反射操作无参构造方法：   

/**
* 操作无参构造方法
*   不实用new关键字来实例化，直接使用反射实现实例化
* @Title:test1
* @Description:
* @throws Exception
* @return void
*/
@Test
public void test1() throws Exception{
//获得Class类
Class c1 = Class.forName("com.xkf.demo.reflect.Person");
Person p = (Person)c1.newInstance();
//设置值
p.setName("张三");
System.out.println(p.getName());
}

             使用反射操作有参构造方法：         

@Test
public void test2() throws Exception{
Class c1 = Class.forName("com.xkf.demo.reflect.Person");
//使用有参数的构造方法
//		c1.getConstructors();
//传递的是有参数的构造方法里面参数类型，类型使用class类型传递
Constructor c = c1.getConstructor(String.class,String.class);
//通过有参数的构造方法设置值
//通过有参数的构造方法创建Person实例
Person p = (Person) c.newInstance("李四","001");
System.out.println("姓名：" + p.getName() + "   编号:" + p.getId() );
}

          使用反射操作属性：   

/**使用反射操作属性
*    设置可以操作私有属性:setAccessible(true)
* @Title:test3
* @Description:
* @return void
*/
@Test
public void test3() throws Exception{
//得到Class类
Class c = Class.forName("com.xkf.demo.reflect.Person");
//得到所有的属性
//		c.getDeclaredFields()
//获得Person实例
Person person = (Person)c.newInstance();
Field nameField = c.getDeclaredField("name");
Field idField = c.getDeclaredField("id");
//设置可以操作私有属性
nameField.setAccessible(true);
nameField.set(person, "xxx");//设置值：set(Object obj ,Object value)第一个参数是实例，第二个参数是设置的值
idField.setAccessible(true);
idField.set(person, "009");
System.out.println("姓名：" + nameField.get(person) + "   编号:" + idField.get(person));
}

     使用反射操作普通的方法：    

/**使用泛型操作普通方法
*   如操作Person类里面的setName(String name)方法
* @Title:test4
* @Description:
* @throws Exception
* @return void
*/
@Test
public void test4() throws Exception{
//得到Class类
Class c = Class.forName("com.xkf.demo.reflect.Person");
//得到Person 实例
Person person = (Person)c.newInstance();
//得到普通方法
//		c.getDeclaredFields();//获得所有的普通方法，用的少
Method method = c.getDeclaredMethod("setName", String.class);
//让setName()方法执行，设置值;如果操作的是私有方法，则应该通过setAccessible(true)
method.invoke(person, "王五");//invoke(Object obj ,Object value)：第一个参数Person实例，第二个参数是设置的值
System.out.println(person.getName());
}

当操作的方法是一个静态方法时，因为静态方法调用是类名.方法名，不需要类的实例

 使用反射操作静态方法的时候，也不需要实例

  在invoke()的第一个参数里面，直接写null，表示调用的是一个静态方法