JDK5.0新特性(静态导入、自动装箱/拆箱、增强for循环、可变参数、枚举、泛形)

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

这些新特性主要有:
1.静态导入
2.自动装箱/拆箱
3.增强for循环
4.可变参数
5.枚举
6.泛型
7.元数据

1.静态导入
静态导入用于简化程序对静态属性和方法的调用

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

2.自动装箱/拆箱
自动装箱:指开发人员可以把一个基本数据类型直接赋给对应的包装类。
自动拆箱:指开发人员可以把一个包装类对象直接赋给对应的基本数据类型。

Integer i = 1; //装箱
int j = i; //拆箱

典型应用:
List list = new ArrayList();
list.add(1);
int j=(Integer)list.get(0);//拆箱

3.增强for循环

引入增强for循环的原因:在JDK5以前的版本中,遍历数组或集合中的元素,需要先获得数组的长度或集合的迭代器,比较麻烦!

JDK5中定义了一种新的语法--增强for循环,以简化此类操作。增强for循环只能在数组或实现Iterable接口的集合类上。

语法格式:
for(变量类型 变量:需要迭代的数组或集合){
}

代码:
@Test
public void test1() {
int arr[] = { 1, 2, 3 };
for (int num : arr) {
System.out.println(num);
}
}

输出:
1
2
3

@Test
public void test2() {
List list = new ArrayList();
list.add(1);
list.add(2);
list.add(3);
for (Object obj : list) {
int i=(Integer)obj;
System.out.println(i);
}
}

输出:
1
2
3

@Test
public void test3() {
Map map=new HashMap();// HashMap按hash函数保存数据,保存的数据与存的顺序可能不一样
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=(String)it.next();
String value=(String)map.get(key);
System.out.println(key+"="+value);
}

}

输出:
3=ccc
2=bbb
1=aaa

@Test
public void test4() {
Map map=new LinkedHashMap();
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=(String)it.next();
String value=(String)map.get(key);
System.out.println(key+"="+value);
}

}

输出:
1=aaa
2=bbb
3=ccc

@Test
public void test5() {
Map map = new LinkedHashMap();
map.put("1", "aaa");
map.put("2", "bbb");
map.put("3", "ccc");

// 传统方式2
Set set = map.entrySet();
Iterator it = set.iterator();
while (it.hasNext()) {
Map.Entry entry = (Entry) it.next();
String key = (String) entry.getKey();
String value = (String) entry.getValue();
System.out.println(key + "=" + value);
}

}

输出:
1=aaa
2=bbb
3=ccc

@Test
public void test6() {
Map map = new LinkedHashMap();
map.put("1", "aaa");
map.put("2", "bbb");
map.put("3", "ccc");

// 增强for取map的第1种方式
for (Object obj : map.keySet()) {
String key = (String) obj;
String value = (String) map.get(key);
System.out.println(key + "=" + value);
}

}

输出:
1=aaa
2=bbb
3=ccc

@Test
public void test7() {
Map map = new LinkedHashMap();
map.put("1", "aaa");
map.put("2", "bbb");
map.put("3", "ccc");

// 增强for取map的第2种方式
for (Object obj : map.entrySet()) {
Map.Entry entry = (Entry) obj;
String key = (String) entry.getKey();
String value = (String) entry.getValue();
System.out.println(key + "=" + value);
}

}

输出:
1=aaa
2=bbb
3=ccc

// 使用增强for需要注意的问题:增强for只适合取数据,要修改数组或集合中的数据,要用传统方式
@Test
public void test8() {
int arr[]={1,2,3};
for(int i:arr)
{
i=10;
}
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);

List list = new ArrayList();
list.add("1");
for(Object obj:list)
{
obj=10;
}
System.out.println(list.get(0));
}

输出:
1
2
3
1

4.可变参数

测试JDK中具有可变参数的类Arrays.asList()方法。分别传多个参、传数组,传数组又传参的情况。
注意:传入基本数据类型数组的问题

从JDK5开始,Java允许为方法定义长度可变的参数。语法:
public void foo(int ...args){
}

注意事项:
调用可变参数的方法时,编译器将自动创建一个数组保存传递给方法的可变参数,因此,程序员可以在方法体中以数组的形式访问可变参数

可变参数只能处于参数列表的最后,所以一个方法最多只能有一个长度可变的参数

代码:
@Test
public void testSum() {
sum(1,2,3,4,5,6);
}

public void sum(int ...nums) {
//可变参数你把他看成数组
int sum=0;
for(int i:nums){
sum+=i;
}
System.out.println(sum);
}

输出:
21

@Test
public void testAa() {
aa(1,2,3,4,5,6);
}

//可变参数需要注意的问题:public void aa(int ...nums,int x) { 这样不行,参数会被直接看成一个数组,x没有值
public void aa(int x,int ...nums) {
//可变参数你把他看成数组
int sum=0;
for(int i:nums){
sum+=i;
}
System.out.println(sum);
}

输出:
20

@Test
public void bb(){
List list=Arrays.asList("1","2","3");
System.out.println(list);

String arr[]={"1","2","3","4"};
list = Arrays.asList(arr);
System.out.println(list);

int nums[]={1,2,3,5};//这个细节一定要小心,注意可变参数类型,int nums[]是基本类型数组,这个数组就是一个对象,Arrays.asList(nums)的参数是对象集合。
list=Arrays.asList(nums);
System.out.println(list);
}

输出:
[1, 2, 3]
[1, 2, 3, 4]
[[I@1e63e3d]

5.枚举

1).枚举的作用
一些程序在运行时,它需要的数据不能是任意的,而必须是一定范围内的值,jdk5以前采用自定义类来解决,jdk5以后可以直接采用枚举解决。

JDK5新增的enum关键字用于定义一个枚举类。网址:yii666.com

一个枚举也可以有构造函数、字段和方法。

2).枚举类具有如下特性:

枚举类也是一种特殊形式的Java类。

枚举类中声明的每一个枚举值代表枚举类的一个实例对象。

与Java中的普通类一样,在声明枚举类时,也可以声明属性、方法和构造函数,但枚举类的构造函数必须为私有的(这点不难理解)。文章地址https://www.yii666.com/article/758291.html

枚举类也是可以实现接口或继承抽象类。

JDK5中扩展了swith语句,它除了可以接收int,byte,char,short外,还可以接收一个枚举类型。

若枚举类只有一个枚举值,则可以当作单态设计模式使用。

Java中声明的枚举类,均是java.lang.Enum类的孩子,它继承了Enum类的所有方法。常用方法:
name()
ordinal()
valueof(Class enumClass,String name)
values()此方法虽然在JDK文档中查找不到,但每个枚举类都具有该方法,它用于遍历枚举的所有枚举值。

代码:
1>.
@Test
public void test() {
print(Grade.B);
}

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

// 如何定义枚举的构造函数、方法和字段,去封装更多的信息
enum Grade {
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;
}
}

输出:
89-80

2>.
@Test
public void test() {
print(Grade.B);
}

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

//带抽象方法的枚举
enum Grade {
A("100-90") {
public String localValue() {
return "优";
};
},
B("89-80") {
public String localValue() {
return "良";
};
},
C("79-70") {
public String localValue() {
return "一般";
};
},
D("69-60") {
public String localValue() {
return "差";
};
},
E("59-0") {
public String localValue() {
return "不及格";
};
};网址:yii666.com<

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

private Grade(String value) {
this.value = value;
}

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

public abstract String localValue();
}

输出:

3>.测试枚举的常用方法
@Test
public void test2(){
System.out.println(Grade.C.name());
System.out.println(Grade.C.ordinal());

String str="B";
//Grade g=Grade.valueOf(Grade.class,str);
Grade g=Grade.valueOf(str);//str给出的值若无效则会报错
System.out.println(g);

Grade gs[]=Grade.values();
for(Grade g1:gs){
System.out.println(g1);
}

}

输出:
C
2
B
A
B
C
D
E

6.泛形(Generic)

1)泛形的作用

JDK5以前,对象保存到集合中就会失去其特性,取出时通常要程序员手工进行类型的强制转换,这样不可避免就会引发程序的一些安全性问题。例如:

ArrayList list=new ArrayList();
list.add("abc");
Integer num=(Integer)list.get(0);//运行时会出错,但编码时发现不了

JDK5中的泛形允许程序员在编写集合代码时,就限制集合的处理类型,从而把原来程序运行时可能发生问题,转变为编译时的问题,以此提高程序的可读性和稳定性(尤其在大型程序中更为突出)。示例。

List<String> list1=new ArrayList<String>();
list1.add("aaaa");
String s=list1.get(0);

2)掌握泛形的基本使用

掌握泛形集合的存取

3)泛形的几个注意事项

使用泛形时几个常见问题:

使用泛形时,泛形类型须为引用类型,不能是基本数据类型
ArrayList<Object> list=new ArrayList<String>();//错
ArrayList<String> list=new ArrayList<Object>();//错
ArrayList<String> list=new ArrayList();//对
ArrayList list=new ArrayList<String>();//对
用泛形时,如果两边都使用到泛形,两边必须要一样

注意:泛形是提供给javac编译器使用的,它用于限定集合的输入类型,让编译器在源代码级别上,即挡住向集合中插入非法数据。但编译器编译带有泛形的java程序后,生成的class文件中将不再带有泛形信息,以此使程序运行效率不受到影响,这个过程称之为“擦除”。

泛形的基本术语,以ArrayList<E>为例:<>念typeof
ArrayList<E>中的E称为类型参数变量
ArrayList<Integer>中的Integer称为实际类型参数
整个称为ArrayList<E>泛形类型
整个ArrayList<Integer>称为参数化的类型ParameterizedType

4)自定义泛形---泛形方法
Java程序中的普通方法、构造方法和静态方法中都可以使用泛形。
方法使用泛形前,必须对泛形进行声明,语法:<T>,T可以是任意字母,但通常必须要大写。<T>通常需要放在方法的返回值声明之前。例如:
public static <T> void doxx(T t);

练习:

编写一个泛形方法,实现指定位置上的数组元素的交换。(代码3)

编写一个泛形方法,接收一个任意数组,并颠倒数组中所有元素。(代码3)

注意:

只有对象类型才能作为泛形方法的实际参数。
在泛形中可以同时有多个类型,例如:
public static <K,V> V getValue(K key){return map.get(key);}

5)自定义泛形---泛形类和反射泛形

如果一个类多处都要用到同一个泛形,这时可以把泛形定义在类上(即类级别的泛形),语法格式如下:
public class GenericDao<T>{
private T field1;
public void save(T obj){}
public T getId(int id){}
}

注意,静态方法不能使用类定义的泛形,而应单独定义泛形。
泛形的典型应用:BaseDao和反射泛形

public BaseDao(){
Type type=this.getClass().getGenericSuperclass();
ParameterizedType pt=(ParameterizedType)type;
class=(Class)pt.getActualTypeArguments()[0];
}

6)

代码1:

package cn.itcast.generic;

//自定义带泛形的方法
public class Demo2 {

public void testa(){
a("aaa");
}

public <T> T a(T t){
return null;
}

public <T,E,K> void b(T t,E e,K k){

}
}

代码2:

package cn.itcast.generic;

//自定义类上的泛形
//类上面声明的泛形作用于整个类,静态方法上的泛形需要单独声明
public class Demo3<T,E,K> {

public void testa(){

}

public T a(T t){
return null;
}

public void b(T t,E e,K k){文章来源地址https://www.yii666.com/article/758291.html

}

public static <T> void c(T t){

}
}

代码3:

package cn.itcast.generic;

public class Demo4 {

// 编写一个泛形方法,实现指定位置上的数组元素的交换
public <T> void swap(T arr[], int pos1, int pos2) {
T temp = arr[pos1];
arr[pos1] = arr[pos2];
arr[pos2] = temp;
}

// 编写一个泛形方法,接收一个任意数组,并颠倒数组中所有元素。
public <T> void reverse1(T arr[]) {
int start = 0;
int end = arr.length - 1;

while (true) {
if (start >= end)
break;文章来源地址:https://www.yii666.com/article/758291.html

T temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;

start++;
end--;
}
}

public <T> void reverse2(T arr[]) {
int lenth = arr.length;
for (int i = 0; i < lenth / 2; i++) {
T temp = arr[i];
arr[i] = arr[lenth - i - 1];
arr[lenth - i - 1] = temp;
}
}
}

版权声明:本文内容来源于网络,版权归原作者所有,此博客不拥有其著作权,亦不承担相应法律责任。文本页已经标记具体来源原文地址,请点击原文查看来源网址,站内文章以及资源内容站长不承诺其正确性,如侵犯了您的权益,请联系站长如有侵权请联系站长,将立刻删除

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

微信图片_20190322181744_03.jpg

微信扫一扫打赏

请作者喝杯咖啡吧~

支付宝扫一扫领取红包,优惠每天领

二维码1

zhifubaohongbao.png

二维码2

zhifubaohongbao2.png