JDK15的新特性Word格式文档下载.docx
《JDK15的新特性Word格式文档下载.docx》由会员分享，可在线阅读，更多相关《JDK15的新特性Word格式文档下载.docx（17页珍藏版）》请在冰豆网上搜索。
Integer>
foo2=newGenericFoo<
foo.setFoo（newBoolean（true））;
foo2.setFoo（newInteger（74））;
Booleanb=foo.getFoo（）;
Integeri=foo2.getFoo（）;
System.out.println（b）;
System.out.println（i）;
}运行结果：
//传入两个泛型T1,T2，且T2为数组类型
T1,T2>
privateT1Foo;
privateT2[]FooArray;
publicT1getFoo（）
publicvoidsetFoo（T1foo）
this.Foo=foo;
publicT2[]getFooArray（）
returnFooArray;
publicvoidsetFooArray（T2[]fooArray）
this.FooArray=fooArray;
GenericFoo<
Integer,String>
g=newGenericFoo<
g.setFoo（newInteger（74））;
String[]str1={"
c"
"
w"
j"
};
String[]str2=null;
g.setFooArray（str1）;
str2=g.getFooArray（）;
System.out.println（g.getFoo（））;
for（inti=0;
i<
str2.length;
i++）
{
System.out.println（str2[i]）;
}
//自己定义一个集合：
privateT[]objArr;
privateintindex;
publicGenericFoo（）
objArr=（T[]）newObject[10];
publicvoidadd（Tt）
objArr[index++]=t;
publicTget（inti）
returnobjArr[i];
5;
g.add（newInteger（i））;
Integerin=g.get（i）;
System.out.println（in）;
//应用在HashSet
importjava.util.HashSet;
importjava.util.Iterator;
importjava.util.Set;
Set<
String>
set=newHashSet<
set.add（"
cwj"
）;
bb"
for（Iterator<
iter=set.iterator（）;
iter.hasNext（）;
）
Stringvalue=iter.next（）;
System.out.println（value）;
System.out.println（"
------------------"
Person>
set1=newHashSet<
set1.add（newPerson（"
zhangsan"
20,"
tianjing"
））;
lisi"
30,"
beijing"
iter=set1.iterator（）;
Personperson=iter.next（）;
Stringname=person.getName（）;
intage=person.getAge（）;
Stringadress=person.getAdress（）;
System.out.println（name+"
-"
+age+"
+adress）;
}
classPerson
privateStringname;
privateintage;
privateStringadress;
publicStringgetAdress（）
returnadress;
publicvoidsetAdress（Stringadress）
this.adress=adress;
publicintgetAge（）
returnage;
publicvoidsetAge（intage）
this.age=age;
publicStringgetName（）
returnname;
publicvoidsetName（Stringname）
this.name=name;
publicPerson（Stringname,intage,Stringadress）
{
this.name=name;
this.age=age;
this.adress=adress;
publicinthashCode（）
finalintPRIME=31;
intresult=1;
result=PRIME*result+（（adress==null）?
0:
adress.hashCode（））;
result=PRIME*result+age;
result=PRIME*result+（（name==null）?
name.hashCode（））;
returnresult;
publicbooleanequals（Objectobj）
if（this==obj）
returntrue;
if（obj==null）
returnfalse;
if（getClass（）!
=obj.getClass（））
finalPersonother=（Person）obj;
if（adress==null）
if（other.adress!
=null）
returnfalse;
elseif（!
adress.equals（other.adress））
if（age!
=other.age）
if（name==null）
if（other.name!
name.equals（other.name））
returntrue;
importjava.util.HashMap;
importjava.util.Map;
publicclassTest
Map<
String,String>
map=newHashMap<
map.put（"
cc"
ww"
jj"
set=map.keySet（）;
Stringkey=iter.next（）;
Stringvalue=map.get（key）;
System.out.println（key+"
:
"
+value）;
-----------------"
Map.Entry<
>
set1=map.entrySet（）;
Map.Entry<
entry=iter.next（）;
Stringkey=entry.getKey（）;
Stringvalue=entry.getValue（）;
限制泛型可用类型：
在定义泛型类别时，预设可以使用任何的类型来实例化泛型类型中的类型，但是如果想要限制使用泛型类别时，只能用某个特定类型或是其子类型才能实例化该类型时，可以在定义类型时，使用extends关键字指定这个类型必须是继承某个类，或实现某个接口。
当没有指定泛型继承的类型或接口时，默认使用TextendsObject，所以默认情况下任何类型都可以作为参数传入。
importjava.util.ArrayList;
importjava.util.LinkedList;
importjava.util.List;
publicclassListGenericFoo<
TextendsList>
privateT[]FooArray;
publicT[]getFooArray（）
publicvoidsetFooArray（T[]fooArray）
FooArray=fooArray;
//ListGenericFoo<
HashMap>
list=newListGenericFoo<
这句就是错误的
ListGenericFoo<
ArrayList>
LinkedList>
list1=newListGenericFoo<
ArrayList[]array=newArrayList[10];
list.setFooArray（array）;
LinkedList[]linked=newLinkedList[10];
list1.setFooArray（linked）;
类型通配声明：
现在有这么一个要求，希望有一个参考名称foo可以接受所以下面的实例：
list=newListGenericFoo<
list=newListGenericFoo<
简单的说，实例化类型持有者时，它必须是实现List的类别或其子类别，要定义这样一个名称，可以使用'
?
'
通配字元，并使用"
extends"
关键字限定类型持有者的形态。
<
extendsSomeClass>
eg：
ListGenericFoo<
extendsList>
list=null;
通常当<
extendsObject>
时写作<
For-Each循环：
主要用于简化集合、数组的遍历。
语法：
for（typeelement:
array）
System.out.println（element）....
element是变量，array代表数组或集合引用的名字
int[]amount={1,2,};
//旧式的for遍历
amount.length;
System.out.println（amount[i]）;
----"
//新式的for遍历，增强的for循环
for（intelement:
amount）
System.out.println（element）;
-------"
String[]words={"
hello"
world"
for（Stringenglish:
words）
System.out.println（english）;
//对二维数组的遍历
int[][]array={{1,2},{3,4}};
for（int[]row:
array）//此处里面的是int[],数组的方括号别忘了，先遍历行
for（intline:
row）
{
System.out.println（line）;
}
----下列是集合的3种遍历"
List<
list=newArrayList<
list.add（"
a"
b"
//下列3种遍历方式
list.size（）;
System.out.println（list.get（i））;
for（Iteratoriter=list.iterator（）;
System.out.println（iter.next（））;
for（Stringelement:
list）
当遍历集合或数组时，如果需要访问集合或数组的下标，那么最好使用旧式的方式来实现循环或遍历，而不要使用增强的for循环，因为它丢失了下标信息。
自动装箱/拆箱（Autoboxing/unboxing）：
大大方便了基本类型数据和它们包装类的使用
自动装箱：
基本类型自动转为包装类.（int>
Integer）
自动拆箱：
包装类自动转为基本类型.（Integer>
int）
importjava.util.Collection;
inta=4;
Collection<
cwj=newArrayList<
cwj.add（newInteger（74））;
//原本的方法
cwj.add（74）;
//JDK1.5的新特性，自动装箱，将int类型的3转换为Integer
cwj.add（a+70）;
//将a+70的值int类型的74转换为Integer类型
for（Integeri:
cwj）
System.out.println（i）;
可变参数（Varargs）：
可变参数使程序员可以声明一个接受可变数目参数的方法。
注意：
可变参数必须是方法声明中的最后一个参数，即一个方法不可能具有两个或两个以上的可变参数。
可变参数本质上就是一个数组，对于某个声明了可变参数的方法来说，我们既可以传递离散的值，也可以传递数组对象。
但如果将方法中的参数定义为数组，那么只能传递数组对象而不能传递离散的值。
privatestaticintsum（int...nums）
intsum=0;
for（intnumbers:
nums）
sum+=numbers;
returnsum;
intresult=sum（newint[]{1,2}）;
System.out.println（result）;
result=sum（3,4）;
枚举（Enums-enumeration的缩写）：
JDK1.5引入枚举类型，使用关键字enum，我们可以这样定义一个枚举类型：
publicenumColor
Red,White,Blue//Color枚举类型有此3个实例，对象。
然后可以这样来使用ColormyColor=Color.red
枚举类型还提供了2个有用的静态方法values（）和valueOf（）。
ColormyColor=Color.Gree;
System.out.println（myColor）;
------"
for（Colorcolor:
Color.values（））
System.out.println（color）;
enumColor
Gree,Blue,Red//枚举成员，也代表3个实例，对象
运行结果：
定义枚举类型本质上就是在定义一个类别，只不过很多细节由编译器帮你完成了，所以某些程度上，enum关键字的作用就像是class或interface，我们所定义的每个枚举类型都继承自java.lang.Enum类，枚举中的每个成员默认都是publicfinal，且是static的，所以你可以通过类名.枚举成员名直接使用它们。
而每个枚举的成员其实就是你定义的枚举类型的一个实例（Instance），换句话说，当定义了一个枚举类型后，在编译时刻就能确定该枚举类型有几个实例，分别是什么。
在运行期间我们无法再使用该枚举类型创建新的实例了，这些实例在编译期间就已经完全确定下来了。
publicenumCoin
/*
*Coin枚举的3个对象，下面有Coin的有字符串参数的构造方法，所以这3个实例都传进了字符串值，要用括号括起来
*3个对象，每个对象都维护着一个value值，Coin构造方法就是给value赋值
hs（"
haha"
）,cwj（"
menghuan"
）,abc（"
xiyou"
publicStringvalue;
publicStrin
升级会员 