現在首先摘錄一部分網上的總結，自己會在下面加上自己寫的例子。
1.泛型(Generic)
C++通過模板技術可以指定集合的元素類型，而Java在1.5之前一直沒有相對應的功能。一個集合可以放任何類型的對象，相應地從集合裏面拿對象的時候我們也不得不對他們進行強制得類型轉換。猛虎引入了泛型，它允許指定集合裏元素的類型，這樣你可以得到強類型在編譯時刻進行類型檢查的好處。
2.For-Each循環
For-Each循環得加入簡化了集合的遍歷。
3.自動裝包/拆包(Autoboxing/unboxing)
自動裝包/拆包大大方便了基本類型數據和它們包裝類地使用。
自動裝包：基本類型自動轉爲包裝類.(int >> Integer)
自動拆包：包裝類自動轉爲基本類型.(Integer >> int)
4.枚舉(Enums)
JDK1.5加入了一個全新類型的“類”－枚舉類型。爲此JDK1.5引入了一個新關鍵字enmu. 我們可以這樣來定義一個枚舉類型。
public enum Color
{
Red,
White,
Blue
}
然後可以這樣來使用Color myColor = Color.Red.
枚舉類型還提供了兩個有用的靜態方法values()和valueOf(). 我們可以很方便地使用它們，例如
for (Color c : Color.values())
System.out.println©;
5.可變參數(Varargs)
可變參數使程序員可以聲明一個接受可變數目參數的方法。注意，可變參數必須是函數聲明中的最後一個參數。假設我們要寫一個簡單的方法打印一些對象，
util.write(obj1);
util.write(obj1,obj2);
util.write(obj1,obj2,obj3);
…
在JDK1.5之前，我們可以用重載來實現，但是這樣就需要寫很多的重載函數，顯得不是很有效。如果使用可變參數的話我們只需要一個函數就行了
public void write(Object... objs) {
for (Object obj: objs)
System.out.println(obj);
}
在引入可變參數以後，Java的反射包也更加方便使用了。對於c.getMethod("test", new Object[0]).invoke(c.newInstance(), new Object[0]))，現在我們可以這樣寫了c.getMethod("test").invoke(c.newInstance())，這樣的代碼比原來清楚了很多。
6.靜態導入(Static Imports)
要使用用靜態成員（方法和變量）我們必須給出提供這個方法的類。使用靜態導入可以使被導入類的所有靜態變量和靜態方法在當前類直接可見，使用這些靜態成員無需再給出他們的類名。
import static java.lang.Math.*;
…….
r = sin(PI * 2); //無需再寫r = Math.sin(Math.PI);
不過，過度使用這個特性也會一定程度上降低代碼地可讀性。
7.註解
非常重要
Annotation 註解
@SuppressWarnings
指示應該在註釋元素(以及包含在該註釋元素中的所有程序元素)中取消顯示指定的編譯警告
@Deprecated
在使用不被贊成的程序元素或在不被贊成的代碼中執行重寫時，編譯器會發出警告
@Override
表示一個方法聲明打算重寫超類中的另一個方法聲明。如果方法利用此註釋類型進行註釋但沒有重寫超類方法，則編譯器會生成一條錯誤信息。
註解相當於一種標記，在程序中加了註解就等於爲程序打上了某種標記。沒加，則等於沒有某種標記，以後，javac編譯器，開發工具和其他程序可以用反射來了解你的類及各種元素上有無何種標記，看你有什麼標記，就去幹相應的事。標記可以加在包，類，字段，方法，方法的參數以及局部變量上
看java.lang包，可以看到JDK中提供的最基本的annotiation
註解的應用結構圖
註解類---->應用了“註解類”的類----->對“應用了註解類的類”進行反射操作的類
註解類就相當於一個你的源程序中要調用的一個類，要在源程序中應用某個註解，得先準備好了這個註解類。就想你要調用某個類，得先有開發好這個類。
@Retention元註解 標註註解的生命週期
RetetionPolicy.SOURCE,RetetionPolicy.CLASS,RetetionPolicy.RUNTIME分別對應源文件，class文件，內存中的字節碼
@Target 表示註解的作用域
Interface Type 1.5 新東西
註解的屬性
數組類型的屬性
int[] arrayAttr() default{1,2,3};
@MyAnnotation(arrayAttr={2,3,4});
如果數組屬性中只有一個元素，這時屬性值部分可以聲落大括號
枚舉類型的屬性
EnumTest.TrafficLamp lamp();
@MyAnnotation(lamp=EnumTest.TrafficLamp.GREEN);
註解類型的屬性
MetaAnnotation annotationAttr() default @MetaAnnotation("xxxx");
@MyAnnotation(annotationAttr=@MetaAbbotation("yyy"));
可以認爲上面這個@MyAnnotation是MyAnnotation類的一個實例對象，同樣的道理，可以認爲上面這個@MetaAnnotation是MetaAnnotation類的一個實例對象。
8.
java.lang.reflect
接口 Type
public interface Type
Type 是 Java 編程語言中所有類型的公共高級接口。它們包括原始類型、參數化類型、數組類型、類型變量和基本類型。
//靜態導入，導入某個類中的所有靜態方法。
//JDK1.5新特性，注意語法
import static java.lang.Math.*;
public class StaticDemo {
public static void main(String[] args) {
System.out.println("hello world!");
for(int i=0;i<3;i++){
i = i+1;
System.out.println(i);
}
System.out.println(round(10.5));
System.out.println(max(3, 6));
System.out.println(min(9, 8));
System.out.println(abs(3 - 7));
}
}
package cn.heima;
//可變參數
//高級for循環
public class VariableParameter {
public static void main(String[] args) {
// System.out.println("hello java");
System.out.println(add(1,2,3));
System.out.println(add(1,2,3,4,5));
}
//調用可變參數的方法時，編譯器爲該可變參數隱含創建一個數組，在
//方法體內以數組的形式訪問可變參數。
public static int add(int x,int... args){
int sum = x;
//既然是數組，直接用高級for，測試果然有效，一個例子包含兩個新特性講解O(∩_∩)O~
for(int arg:args){
sum+=arg;
}
return sum;
/*for(int i=0;i<args.length;i++){
sum+=args[i];
}
return sum;
*/
}
}
package cn.heima;
//自動拆箱裝箱的原理，享元模式，flyweight
public class AutoBox {
public static void main(String[] args) {
String s1 = new String("abc");
String s2 = new String("abc");
//false 兩個對象
System.out.println(s1==s2);
Integer i1 = 12;
Integer i2 = 12;
//自動裝箱true
System.out.println(i1==i2);
//自動拆箱，Integer本身沒有加法，不能相加
System.out.println(i1+15);
Integer i3 = new Integer(13);
Integer i4 = new Integer(13);
//堆內存新建兩個對象false
System.out.println(i3==i4);
Integer i5 = Integer.valueOf(20);
Integer i6 = Integer.valueOf(20);
//true
System.out.println(i5==i6);
Integer i7 = Integer.valueOf(200);
Integer i8 = Integer.valueOf(200);
//false
System.out.println(i7==i8);
}
}
package cn.heima;
abstract class WeekDay {
private WeekDay(){}
//在本類內部定義好對象，匿名內部類
public final static WeekDay SUN = new WeekDay(){
@Override
public WeekDay nextDay() {
return MON;
}
};
public final static WeekDay MON = new WeekDay(){
@Override
public WeekDay nextDay() {
return TUE;
}
};
public final static WeekDay TUE = new WeekDay(){
@Override
public WeekDay nextDay() {
return WED;
}
};
public final static WeekDay WED = new WeekDay(){
@Override
public WeekDay nextDay() {
return THU;
}
};
public final static WeekDay THU = new WeekDay(){
@Override
public WeekDay nextDay() {
return FRI;
}
};
public final static WeekDay FRI = new WeekDay(){
@Override
public WeekDay nextDay() {
return SAT;
}
};
public final static WeekDay SAT = new WeekDay(){
@Override
public WeekDay nextDay() {
return SUN;
}
};
//採用抽象方法定義nextDay，就將大量的if...else語句轉移成了一個獨立的類
public abstract WeekDay nextDay();
//方法極其囉嗦，代碼冗餘。
/* public WeekDay nextDay(){
if(this==SUN){
return MON;
}
else if(this == MON){
return TUE;
}
else if(this==TUE){
return WED;
}
else if(this==WED){
return THU;
}
else if(this==THU){
return FRI;
}
else if(this==FRI){
return SAT;
}
else{
return SUN;
}
}*/
public String toString(){
if(this==SUN)
return "星期日";
if(this==MON)
return "星期一";
if(this==TUE)
return "星期二";
if(this==WED)
return "星期三";
if(this==THU)
return "星期四";
if(this==FRI)
return "星期五";
if(this==SAT)
return "星期六";
return null;
}
}
package cn.heima;
public class Enum {
public static void main(String[] args) {
WeekDay1 wd = WeekDay1.SUN;
System.out.println(wd.nextDay());
WeekDay1 wd1 = WeekDay1.MON;
System.out.println(wd1.nextDay());
WeekDay wd3 = WeekDay.MON;
System.out.println(wd3);
//傳遞一個字符串返回一個枚舉對象。
System.out.println(WeekDay.valueOf("SAT"));
System.out.println(WeekDay.valueOf("SUN"));
//返回數組
WeekDay[] wds = WeekDay.values();
//ordinal(),排名
for(WeekDay wday:wds){
System.out.println(wday.name()+"---"+wday.ordinal());
}
}
public enum WeekDay{
SUN,MON,TUE,WED,THU,FRI,SAT;
}
}
public enum TrafficLamp{ //{}用於實現抽象方法，()表示是用的帶參數的構造函數創建的
GREEN(50){
public TrafficLamp nextLamp(){
return YELLOW;
}
},
RED(30){
public TrafficLamp nextLamp(){
return GREEN;
}
},
YELLOW(5){
public TrafficLamp nextLamp(){
return RED;
}
};
private int time; //定義帶參數的構造函數
private TrafficLamp(int time){
this.time = time;
} //定義抽象方法
public abstract TrafficLamp nextLamp();
}
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
//註解保留到運行時期
@Retention(RetentionPolicy.RUNTIME)
//可以放在哪裏
@Target({ElementType.METHOD,ElementType.TYPE})
public @interface HeiMaAnnotation {
String color() default "yellow";
String value() ;
int[] arr() default {1,2,3};
String[] arrs() default{"haha"};
Enum.TrafficLamp lamp() default Enum.TrafficLamp.RED;
MyAnnotation annotatioArr() default @MyAnnotation("bxd");
Class claz() default int.class;
}import java.lang.annotation.Annotation;
import java.util.Arrays;
@HeiMaAnnotation(color="red",value="testing" ,arr={1},arrs={"annotation","struts2"},
annotatioArr=@MyAnnotation("laobi"),lamp=Enum.TrafficLamp.YELLOW,claz=String.class)
public class AnnotationTest {
@HeiMaAnnotation("haha")
public static void main(String[] args) {
//isAnnotationPresent()Annotation是否在現場，形象化字面化翻譯
if(AnnotationTest.class.isAnnotationPresent(HeiMaAnnotation.class)){
//getAnnotation得到Annotation
HeiMaAnnotation ann = (HeiMaAnnotation)AnnotationTest.class.getAnnotation(HeiMaAnnotation.class);
System.out.println(ann);
System.out.println(ann.color());//red
System.out.println(ann.value());//testing
System.out.println(ann.arr().length);//1
System.out.println(Arrays.asList(ann.arrs()));
System.out.println(ann.annotatioArr().value());//laobi
System.out.println(ann.lamp().nextLamp());//RED
System.out.println(ann.claz().getName());//java.lang.String
}
}
}public @interface MyAnnotation {
String value() ;
}