jdk1.5之后的新特性

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/u010918487/article/details/48587513

     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()方式:                       

  1. //先获取Map集合的所有键的Set集合,里面存放的是K的类型,keySet()  
  2.         Set<String> keySet = map.keySet();  
  3.         //有了Set集合就可以获取其迭代器  
  4.         Iterator<String> iterator = keySet.iterator();  
  5.         while(iterator.hasNext()){  
  6.             //取得键  
  7.             String key = iterator.next();  
  8.             //有了键,就可以通过Map集合的get方法获取对应的值  
  9.             String value = map.get(key);  
  10.             System.out.println("key:" + key + ",value:" + value );  
  11.         }    

    entrySet()方式:

  1. //将Map集合中的映射关系取出,存入到Set集合  
  2.         Set<Map.Entry<String,String>> entrySet = map.entrySet();  
  3.         Iterator<Map.Entry<String, String>> iterator = entrySet.iterator();  
  4.         while(iterator.hasNext()){  
  5.             Map.Entry<String, String> entry = iterator.next();  
  6.             //获取key  
  7.             String key = entry.getKey();  
  8.             //获取键  
  9.             String value = entry.getValue();  
  10.             //打印  
  11.             System.out.println("key:" + key + ",value:" + value);  
  12.         }  

     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,表示调用的是一个静态方法

                    

            

阅读更多
想对作者说点什么?

博主推荐

换一批

没有更多推荐了,返回首页