javaweb-day03-1&2(基础加强 - 静态导入、自动装箱/拆箱、增强for循环、可变参数、枚举)

JDK 5.0 新特性

JDK5中新增了很多新的java特性,利用这些新语法可以帮助开发人员编写出更加高效、清晰,安全的代码。

  • 静态导入
  • 自动装箱/拆箱
  • 增强for循环
  • 可变参数
  • 枚举
  • 反射
  • 内省
  • 泛型
  • 元数据

 

静态导入

普通导入是导入某个类,静态导入是导入某个类的 静态方法 静态属性

为了简化书写,但不常用。

  • 语法:
    • import static 包名.类名.静态属性|静态方法|*
  • 例如:
    • import static java.lang.System.out
    • import static java.lang.Math.*

package cn.mengmei.import_static;

import static java.lang.System.out;
import static java.util.Arrays.*;

public class Demo1 {

	public static void main(String[] args) {
		
		out.println("hello world");
		
		System.out.println( asList(new Integer[] { 1, 2, 3, 4 }) );
	}

}
运行结果:

hello world
[1, 2, 3, 4]



自动装箱/拆箱

  •   JDK5.0的语法允许把一个基本数据类型直接赋给对应的包装类变量, 或者赋给Object 类型的变量,这个过程称之为自动装箱。
  •   自动拆箱与自动装箱正好相反,即把包装类对象直接赋给一个对应的基本类型变量。
  •   典型应用:
    • List  list = new ArrayList();
    • list.add(1);
    • int  j = (Integer)list.get(0);

package cn.mengmei.demo;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Demo2 {

	public static void main(String[] args) {
		
		//5.0  jvm
		Integer i = 1;  //自动装箱
		int j = i;    //自动拆箱
		
		//典型应用
		List list = new ArrayList();
		list.add(1);  //自动装箱
		list.add(2);
		list.add(3);
		
		Iterator it = list.iterator();
		while(it.hasNext()){
			int k = (Integer)it.next();  //自动拆箱
		}
	}

}


增强for循环

  •   引入增强for循环的原因:在JDK5以前的版本中,遍历数组或集合中的元素,需先获得数组的长度或集合的迭代器,比较麻烦!
  •   因此JDK5中定义了一种新的语法——增强for循环,以简化此类操作。增强for循环只能用在数组、或实现Iterable接口的集合类上
  •   语法格式:                                             
    • for(变量类型 变量 :需迭代的数组或集合){
    •  
    • }
  •   使用增强for循环的几个注意事项 (以下程序的输出结果?)
    • int arr[] = new int[5];
    • for(int num : arr){
    •     num = 1;
    • }
    • System.out.println(arr[0]);  //0
    •  

    • List<String> list = new ArrayList<String>();
    • list.add("xxx");
    • for(String str : list){
    •        str = "yyy";
    • }
    • System.out.println(list.get(0));  //xxx

package cn.mengmei.demo;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.junit.Test;

public class Demo3 {
	
	//注意:增强for循环只适合取数据,不要想着用它给数组赋值。
	
	@Test
	public void test1() {
		int[] arr = new int[5]; 
		for(int a : arr){
			a = 1; //只是把变量a的值改了,并没有改数组里面的值。
		}
		System.out.println(arr[0]);
	}
	
	@Test
	public void test2() {
		List<String> list = new ArrayList<String>();
		list.add("xxx");
		for(String a : list){  //定义了个变量去指向迭代出来的东西。
			a = "yyy"; //只是将这个变量的指向改变了,原来指向"xxx",现在指向"yyy",并没有改变集合中的东西。
		}
		System.out.println(list.get(0));
	}
	
	@Test
	public void test3() {
		int[] arr = new int[]{1,2,3};
		for(int a : arr){
			System.out.println(a);
		}
	}
	
	@Test
	public void test4() {
		List<Integer> list = new ArrayList<Integer>();
		list.add(1);
		list.add(2);
		list.add(3);
		for(int a : list){
			System.out.println(a);
		}
	}
	
	@Test
	public void test5() {
		Map<Integer,String> map = new LinkedHashMap<Integer,String>();
		map.put(1, "aa");
		map.put(2, "bb");
		map.put(3, "cc");
		
		//传统方式一:
		Set<Integer> keySet = map.keySet();
		Iterator<Integer> it = keySet.iterator();
		while(it.hasNext()){
			int key = it.next();
			String value = map.get(key);
			System.out.println(key+":"+value);
		}
		
		//高级for循环一:
		for(int key : map.keySet()){
			String value = map.get(key);
			System.out.println(key+"::"+value);
		}
		
		
		//传统方式二:
		Set<Map.Entry<Integer, String>> entrySet = map.entrySet();
		Iterator<Map.Entry<Integer, String>> it2 = entrySet.iterator();
		while(it2.hasNext()){
			Map.Entry<Integer, String> me = it2.next();
			int key = me.getKey();
			String value = me.getValue();
			System.out.println(key+":::"+value);
		}
		
		//高级for循环二:
		for(Map.Entry<Integer, String> me : map.entrySet()){
			int key = me.getKey();
			String value = me.getValue();
			System.out.println(key+"::::"+value);
		}
	}

}


可变参数

  • 测试JDK中具有可变参数的类Arrays.asList()方法。分别传多个参、传数组,传数组又传参的情况。
    • 注意:传入基本数据类型数组的问题。
  • 从JDK 5开始, Java 允许为方法定义长度可变的参数。语法:
    • public void foo(int … args){
    • }
  • 注意事项:
    • 调用可变参数的方法时, 编译器将自动创建一个数组保存传递给方法的可变参数,因此,程序员可以在方法体中以数组的形式访问可变参数
    • 可变参数只能处于参数列表的最后, 所以一个方法最多只能有一个长度可变的参数

 

package cn.mengmei;

import java.util.Arrays;
import java.util.List;

public class Demo1 {

	public static void main(String[] args) {

		sum(1,2,3,4,5);
		
		Integer[] arr = {1,2,3,4,5};
		sum(arr); //如果一个函数接受可变参数,那么往里面传数组也是可以的。
		
		List list = Arrays.asList(1,2,3);
		System.out.println(list);
		
		Integer[] arr1 = {1,2,3,4,5};
		list = Arrays.asList(arr1);   //5
		System.out.println(list);
		
		//注意
		int[] arr2 = {1,2,3,4,5};
		list = Arrays.asList(arr2);  //1
		System.out.println(list);
		
		//总结:以后能用对象类型,就不用基本数据类型。
		
		sum2(1,2,3,4,5);
	}
	
	public static void sum(Integer...args){
		int sum = 0;
		for(int arg : args){
			sum += arg;
		}
		
		System.out.println(sum);
	}
	
	//注意:可变参数必须处于参数列表的最后,且一个方法只能拥有一个可变参数。
	public static void sum2(Integer num, Integer...args){
		int sum = 0;
		for(int arg : args){
			sum += arg;
		}
		sum += num;
		
		System.out.println(sum);
	}

}

枚举类

  • 为什么需要枚举?
    • 一些方法在运行时,它需要的数据不能是任意的,而必须是一定范围内的值,此类问题在JDK5以前采用自定义带有枚举功能的类解决,Java5以后可以直接使用枚举予以解决。
  • JDK 5新增的 enum 关键字用于定义一个枚举类。
  • 枚举类具有如下特性:
    • 枚举类也是一种特殊形式的Java类。
    • 枚举类中声明的每一个枚举值代表枚举类的一个实例对象。
    • 与java中的普通类一样,在声明枚举类时,也可以声明属性、方法和构造函数,但枚举类的构造函数必须为私有的(这点不难理解)。
    • 枚举类也可以实现接口、或继承抽象类。
    • JDK5中扩展了swith语句,它除了可以接收int, byte, char, short外,还可以接收一个枚举类型。
    • 若枚举类只有一个枚举值,则可以当作单态设计模式使用。
  • 练习:请编写一个关于星期几的枚举WeekDay,要求:
    • 枚举值:Mon,Tue,Wed,Thu,Fri,Sat,Sun
    • 该枚举要有一个方法,调用该方法返回中文格式的星期。
  • Java中声明的枚举类,均是java.lang.Enum类的孩子,它继承了Enum类的所有方法。常用方法:
    • name()         //枚举对象的名称
    • ordinal()       //枚举对象在声明中的位置序数。
    • valueof(Class enumClass, String name)        //将字符串转化成枚举对象。
    • values()      //此方法虽然在JDK文档中查找不到,但每个枚举类都具有该方法,它遍历枚举类的所有枚举值非常方便。

package cn.mengmei;

public class Demo2 {

	public static void main(String[] args) {

		WeekDay.Mon.printName();       //星期一
		WeekDay.Mon.toLocalString();   //Monday
	
		String name = "Wed";
		WeekDay w = WeekDay.valueOf(WeekDay.class, name); //将一个字符串转化成一个枚举对象
		System.out.println(w.ordinal());  //2,初始常量序数为0
		
		//遍历枚举类中的对象
		WeekDay[] days = WeekDay.values();
		for(WeekDay day : days){
			System.out.println(day);
		}
	}

}

//一个拥有属性和抽象方法的的枚举类:
enum WeekDay {
	Mon("星期一"){
		@Override
		public void toLocalString() {
			// TODO Auto-generated method stub
			System.out.println("Monday");
		}
	},Tue("星期二"){
		@Override
		public void toLocalString() {
			// TODO Auto-generated method stub
			System.out.println("Tuesday");
		}
	},Wed("星期三"){
		@Override
		public void toLocalString() {
			// TODO Auto-generated method stub
			System.out.println("Wednesday");
		}
	},Thu("星期四"){
		@Override
		public void toLocalString() {
			// TODO Auto-generated method stub
			System.out.println("Thursday");
		}
	},
	Fri("星期五"){
		@Override
		public void toLocalString() {
			// TODO Auto-generated method stub
			System.out.println("Friday");
		}
	},Sat("星期六"){
		@Override
		public void toLocalString() {
			// TODO Auto-generated method stub
			System.out.println("Saturday");
		}
	},Sun("星期日"){
		@Override
		public void toLocalString() {
			// TODO Auto-generated method stub
			System.out.println("Sunday");
		}
	};
	
	private WeekDay(String name){
		this.cname = name;
	}
	
	private String cname;
	
	public void printName(){
		System.out.println(this.cname);
	}
	
	//抽象类:每个对象都必须单独实现
	public abstract void toLocalString();

}

枚举不能继承类,因为它本身就继承了一个Enum类。

但是枚举可以实现接口。







  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值