java新特性上

jdk5.0以及5.0之后的版本:

  1. 静态导入
  2. 自动装箱和拆箱
  3. 增强for循环
  4. 可变参数
  5. 枚举类型
  6. 泛型
  7. 反射
  8. 内省
  9. 元数据
  • 静态导入

package java静态导入;
import static java.lang.System.out;		//用的不多,可阅读性下降
import org.junit.Test;

public class Demo {

		@Test
		public void test(){
			out.print("静态导入测试");
		}
}
  • 可变参数

package 可变参数;

import org.junit.Test;

public class Demo {

	@Test
	public void testSum(){
		System.out.println(sum(1,2,3,4,5,6));
		System.out.println(sum(1,2));
	}

	//可变参数,就把参数看成数组,参数也可以传送一个数组
	public int sum(int ...nums){
		int sum = 0; 

		for(int num : nums){
			sum = sum +num;
		}

		return sum;
	}

	@Test
	public void testSum2(){
		sum2(1,2,3,4);
	}

	//可变参数需要注意的问题 public void sum2(int  ...nums , int x )这样写有错,可变参数必须放在最后一个参数
	public void sum2(int x ,int  ...nums){
		System.out.println("X:"+x);
	}
}
  • 增强for循环

package 增强for循环;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import org.junit.Test;

//能否使用增强for循环的关键是:该类是否继承了util接口
public class Demo {

	@Test
	public void test() {
		int[] arr = { 1, 2, 3, 4 };

		for (int num : arr) {
			System.out.println(num);
		}
	}

	// java.util.List 使用增强for循环
	@Test
	public void test2() {
		List list = new ArrayList();
		list.add(1);
		list.add(2);
		list.add(3);

		for (Object num : list) {
			int i = (Integer) num;
			System.out.println(i);
		}
	}

	@Test
	public void test3() {
		Map map = new HashMap();

		map.put("1", "AAA");
		map.put("2", "bbb");
		map.put("3", "ccc");

		// 传统方式1
		Set set = map.keySet();
		Iterator it = set.iterator();
		while(it.hasNext()){
			String key = it.next().toString();
			String value = map.get(key).toString();
			System.out.println("key:"+key+" value:"+value);
		}
	}

	@Test
	public void test4() {
		Map map = new HashMap();

		map.put("1", "AAA");
		map.put("2", "bbb");
		map.put("3", "ccc");

		// 传统方式2
		Set set = map.entrySet();
		Iterator it = set.iterator();
		while(it.hasNext()){
			//entry 为map中的辅助类:为key-value键值对
			Map.Entry entry = (Map.Entry) it.next();
			System.out.println("key:"+entry.getKey()+" value:"+ entry.getValue());
		}
	}

	// java.util.Map使用增强for循环
		@Test
		public void test5() {
			Map map = new HashMap();

			map.put("1", "AAA");
			map.put("2", "bbb");
			map.put("3", "ccc");

			// 增强for循环
			for(Object obj : map.keySet()){
					String key = (String	) obj;
					String value = (String) map.get(key);
					System.out.println("key:"+key+" value:"+value);
			}
			}

		// java.util.Map使用增强for循环2
		@Test
		public void test6() {
			Map map = new HashMap();

			map.put("1", "AAA");
			map.put("2", "bbb");
			map.put("3", "ccc");

			//增强for循环
			for(Object obj : map.entrySet()){
				Map.Entry entry = (Entry) obj;
				String key = (String) entry.getKey();
				String value = (String) entry.getValue();
				System.out.println("key:"+key+" value:"+value);
			}
		}

		//使用增强for循环需要注意的几个问题
		@Test
		public void test7() {
				int[] arr = {1,2,3};

				for(int i : arr){
					//表示int i = arr[X] 只是把数组中的值取出来暂存在中,并不会改变arr[x]的值,改变的是i的值
					//List或者其他集合类型也是一样的,不会改变集合中的内容
					 i =10;
				}
				System.out.println(arr[0]);
				System.out.println(arr[1]);
				System.out.println(arr[2]);
		}
}
  • 自动装箱也拆箱

package 自动装箱和拆箱;

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

import org.junit.Test;

//自动装箱和拆箱:基本数据类型和对象数据类型的自动转换
public class Demo {

		@Test
		public void test(){
			Integer i = 1; //后台自动装箱,执行 -> Integer i = new Integer(1); 

			//典型应用
			List list = new ArrayList<Integer>();	//集合中只能存放对象     new ArrayList<int>()会报错
			list.add(1);	//list.add(new Integer(1));
			list.add(new Integer(2));
			list.add(3);
			list.add(4);

			Iterator<Integer> it = list.iterator();

			while(it.hasNext()){
				System.out.println(it.next());  //拆箱
			}
		}
}
  • 枚举类型

package 枚举;

import org.junit.Test;

public class Demo {

	@Test
	public void test() {
		print(Grade.A);
	}

	public void print(Grade g) {
		String value = g.getValue();
		System.out.println(value);
	}
}

/*
 * class Grade{
 *  private Grade(){}
 *   public static final Grade A = new Grade();
 *  public static final Grade B = new Grade();
 *  public static final Grade C = new Grade();
 *  public static final Grade D = new Grade();
 *   public static final Grade E = new Grade(); }
 */

//枚举类型中的元素是枚举类型的对象实例,本质上也是调用了枚举类型(特殊的类)的构造方法(不带括号则调用无参的构造方法)
enum Grade {// 此处枚举类型和以上注释代码完全等效 A:100-90 B:89-80 C:79 - 70 D: 69-60 E:59-0
	// A, B, C, D, E; 此处的5个对象是调用本类对象的默认无参的构造函数得到的
	A("100-90"), B("89-80"), C("79-70"), D("69-60"), E("59-0"); // 调用有参构造函数

	private String value; // 封装每个对象对应的分数

	private Grade(String value) { // 覆盖了无参构造函数
		this.value = value;
	}

	public String getValue() {
		return this.value;
	}

}<span style="color:#330099;">
</span>
package 枚举;

import org.junit.Test;

//带抽象方法的枚举
public class Demo带抽象方法的枚举类型 {
	@Test
	public void test() {
		print(Grade2.A);
	}

	public void print(Grade2 g) {
		System.out.println(g.getLocalValue());
	}
}

enum Grade2 {	//枚举类型其实就是特殊的类
	A("100-90") {	//每一个枚举值代表了枚举类型中的一个对象实例
		public String getLocalValue() { // 内部类实现了Grade2的getLocalValue的抽象方法
			return "优";
		}
	},						//当枚举类型中只有一个值的时候,其相当于单态设计模式
	B("89-80") {
		public String getLocalValue() {
			return "良";
		}
	},
	C("79-70") {
		public String getLocalValue() {
			return "中";
		}
	},
	D("69-60") {
		public String getLocalValue() {
			return "及格";
		}
	},
	E("59-0") {
		public String getLocalValue() {
			return "不及格";
		}
	};
	private String value;

	private Grade2(String value) {	//枚举类的构造函数必须是私有的,因为枚举类型的实例化只能出现在枚举类的内部
		this.value = value;
	}

	public abstract String getLocalValue(); // 抽象方法(枚举类也可以实现接口或继承抽象类的)
}

//单态设计模式的最简单实现
enum Grade3{	//class
	A;	//object
}
package 枚举;

import org.junit.Test;

public class Demo常用的枚举方法 {

	@Test
	public void Test(){
		String a = "A";
		System.out.println("名称"+Example.A.name());
		//存在为String类型的a时,不会报错,否则会抛出异常,常常用来判断表单提交的数据中是否为某个枚举类型中的值
		System.out.println("存在该值"+Example.valueOf(a));	//用的比较多

		System.out.println("在声明的枚举类型中的位置:"+Example.B.ordinal());//下标从0开始计算

		//遍历枚举类型
		Example[] exs = Example.values();
		for(Example value : exs)
		System.out.print(value+" ");
	}
}

enum Example{
	A,B,C,D,E;
}

----未完,待续

时间: 2024-11-07 14:50:52

java新特性上的相关文章

JAVA学习-Java新特性(泛型、枚举、Annotation)

所谓的Java新特性现在都是指从JDK 1.5之后开始的,例如,在前面已经学习过两个新特性:switch支持String判断(JDK 1.7提供的).自动装箱和拆箱.可变参数.foreach.静态导入.泛型.枚举.Annotation. 对于所有的新特性,我的个人建议:有些新特性你今天一定是不知道怎么用的,我们今天只是来看一下这些语法,至于使用方面,慢慢来观察. 1.可变参数(理解) 如果说现在有这样一个要求,要求实现整数的加法操作,并且方法可以接收任意多个整型数据一起实现加法操作. 如果按照传

JAVASE课程 第一章 第四讲方法,数组,java新特性

作用: 1.可以了解方法的申明和使用 2.可以了解数组的引用传递 3.可以了解java新特性对数组的支持 一 方法的申明和使用 1 方法的定义 方法就是一段可重复调用的代码块. 2 方法的定义格式 a public static 返回值类型 方法名称(类型参数1,类型参数2...){ 方法主体: 程序语句 [return 表达式;] } b 在本节定义的方法,因为其可以直接使用主方法调用,所以将方法声明处加上public static两个关键字 c 注意 1/ 如果返回值类型上写的是void,则

主流的单元测试工具之-JAVA新特性-Annotation 写作者:组长 梁伟龙

1:什么是Annotation?Annotation,即“@xxx”(如@Before,@After,@Test(timeout=xxx),@ignore),这个单词一般是翻译成元数据,是JAVA的一个新特性. 主流的单元测试工具之-JAVA新特性-Annotation - groupthreetogether - group博客 2:元数据的简单介绍: @Before:使用了该元数据的方法在每个测试方法执行之前都要执行一次. @After:使用了该元数据的方法在每个测试方法执行之后要执行一次.

java新特性之可变参数

public class NewDemo01 {     public static void main(String[] args) {         System.out.print("No args(fun()):");         fun();         System.out.print("\n one args(fun()):");         fun(1);         System.out.print("\n five a

Java 新特性(5) - Java EE 5 新特性

Java EE 5 由 Java Community Process 通过 Java Specification Request 244 发布,这个 “总纲” JSR 指出了详细描述 Java EE 5 中各种技术的其他规范(参见 参考资料).Sun Microsystems 的 Bill Shannon 领导一个专家组制订了这个规范,这个专家组包括从 IT 行业重量级人物到个人专家的 31 位成员.以前的 Java EE 版本有: J2EE 1.2(于 1999 年 12 月发布):这是第一个

主流的单元测试工具之-JAVA新特性-Annotation

写作者:组长 梁伟龙 1:什么是Annotation? Annotation,即“@xxx”(如@Before,@After,@Test(timeout=xxx),@ignore),这个单词一般是翻译成元数据,是JAVA的一个新特性. 2:元数据的简单介绍: @Before:使用了该元数据的方法在每个测试方法执行之前都要执行一次. @After:使用了该元数据的方法在每个测试方法执行之后要执行一次. 注意:@Before和@After标示的方法只能各有一个.这个相当于取代了JUnit以前版本中的

C# 2.0 新特性(上)

C# 2.0新特性 1. 泛型 1.1 泛型介绍 泛型类和泛型方法同时具备可重用性.类型安全和效率,这是非泛型类和非泛型方法无法具备的.泛型通常用在集合和在集合上运行的方法中..NET Framework 2.0 版类库提供一个新的命名空间 System.Collections.Generic,其中包含几个新的基于泛型的集合类.建议面向 2.0 版的所有应用程序都使用新的泛型集合类,而不要使用旧的非泛型集合类,如 ArrayList.有关更多信息,请参见 .NET Framework 类库中的泛

Java 新特性(7) - Java EE 7 新特性

http://www.ibm.com/developerworks/cn/java/j-lo-javaee7/ 新特性主要集中在: 1. 提高开发人员的生产力 2. 加强对 HTML5 动态可伸缩应用程序的支持 3. 进一步满足苛刻的企业需求这三个方面 新增组件 WebSocket 1.0.JSON Processing 1.0.JAX-RS 2.0.JSF 2.2 和 JMS 2.0.

Java新特性 5、6、7、8、9、10、11、12、13

项目地址:https://github.com/hepengju/java-new-features项目目标:1. 列举Java5-13版本的关键新特性2. 对每个新特性进行全面的阐述与代码示例 原文地址:https://www.cnblogs.com/hepengju/p/11595102.html