jdk 1.5新特性

jdk1.5的新特性之-------->靜態(tài)導(dǎo)入

靜態(tài)導(dǎo)入的作用：簡化書寫。
靜態(tài)導(dǎo)入僅對于一個類的靜態(tài)成員起作用、

靜態(tài)導(dǎo)入的格式：

import static 包名.類名.靜態(tài)成員;

靜態(tài)導(dǎo)入要注意的實現(xiàn)：

  1. 如果靜態(tài)導(dǎo)入的成員與本類的靜態(tài)成員同名了，那么在本類中優(yōu)先使用本類的靜態(tài)成員， 如果要使用靜態(tài)導(dǎo)入的方法，那么需要指定類名進(jìn)行調(diào)用。
package cn.itcast.jdk15;
import java.util.ArrayList;
import java.util.Collections;
/*
import  static java.util.Collections.sort;
import static java.util.Collections.max;
import static java.util.Collections.min;
 */
import static java.util.Collections.*;
import static java.lang.System.out;

public class Demo1 {    
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        list.add(19);
        list.add(3);
        list.add(23);
        list.add(4);
        //排序:(有本地同名的靜態(tài)函數(shù)時,只有寫全)
        Collections.sort(list);
        
        out.println("集合的元素："+ list);
        out.println("集合 的最大值："+ max(list));
        out.println("集合 的最小值："+ min(list)); 
        out.println();  
    }
    
    public static void sort(ArrayList<Integer> list){
        System.out.println("哈哈，排序了...");
    }
}

jdk1.5新特性之----- 增強for循環(huán)

增強for循環(huán)的主要作用是： 簡化迭代器的書寫格式。
增強for循環(huán)的格式：

 for(元素的數(shù)據(jù)類型     變量名   : 遍歷的目標(biāo)){
    
 }

使用增強for循環(huán)的前提： 只有實現(xiàn)了Iterable接口的對象或者是數(shù)組對象才能使用。

增強for循環(huán)要注意的細(xì)節(jié)：

  1. 增強for循環(huán) 的底層還是通過獲取迭代器的方式進(jìn)行遍歷的，只不過不需要我們手動獲取迭代器而已，所以在使用增強for循環(huán)的遍歷元素 的過程中不準(zhǔn)使用集合對象改變集合對象中的元素個數(shù)。
  2. 增強for循環(huán)與迭代器遍歷的區(qū)別： 增強for循環(huán)只能用于遍歷集合的元素，不能增刪元素 。 而迭代器的遍歷方式可以使用迭代器的方法增刪元素。
  3. 增強for循環(huán)使用的時候必須要存在一個遍歷的目標(biāo)對象， 而普通的for循環(huán)可以不存在遍歷的目標(biāo)對象。
public class Demo2 {
    
    public static void main(String[] args) {
        HashSet<String>  set = new HashSet<String>();
        set.add("張三");
        set.add("李四");
        set.add("王五");
        
    /*  System.out.println("===========迭代器的遍歷方式===========");
        Iterator<String> it = set.iterator(); //使用迭代器
        while(it.hasNext()){
            String item = it.next();
            System.out.print(item +",");
            it.remove();
        }
        
        
        for(String item : set){  //遍歷出來的每個元素都會交給item變量。
            System.out.print(item+",");
        
        }
        int[] arr = {19,17,18,30};
        
        //普通的for循環(huán)遍歷
        for(int i = 0 ; i<arr.length ; i++){
            System.out.print(arr[i]+",");
        }
        
        
        //增強for循環(huán)
        for(int item :arr){
            System.out.print(item+",");
        }
        
        int[] arr2 = new int[5];
        //在控制臺打印5句hello world
        for(int i = 0 ; i<5; i++){
            System.out.println("hello world");
        }
        */
        
        TreeMap<Integer, String>  tree = new TreeMap<Integer, String>();
        tree.put(110, "張三");
        tree.put(109, "李四");
        tree.put(120, "王五");
        tree.put(115, "趙六");
        
        //使用增強for循環(huán)遍歷map集合、。
        Set<Entry<Integer, String>> entryes = tree.entrySet();
        for(Entry<Integer, String> entry :  entryes){
            System.out.println("鍵："+entry.getKey()+" 值："+ entry.getValue());
        }
    }
}

jdk1.5新特性之----- 自定義類實現(xiàn)Iterable接口

實現(xiàn)了Iterable接口后就可以使用迭代功能啦!!!

//自定義一個集合類
class MyList implements Iterable<String>{
    
    Object[] arr ;
    
    int index = 0;//當(dāng)前的索引值
    
    public MyList(){
        arr = new Object[10];
    }
    
    public void add(Object o){
        int minLength = index+1;
        ensureCapcity(minLength); //檢查長度
        arr[index++]= o;
    }

    //檢查當(dāng)前的長度是否夠用，如果不夠用自動拓展0.5倍。
    public void ensureCapcity(int minLength){
        if(minLength==arr.length){
            int newLength = (int) (arr.length*1.5);
            arr = Arrays.copyOf(arr, newLength);
        }
    }

    @Override
    public Iterator<String> iterator() {
    
        return new Iterator<String>() {
            
            int cursor;  //游標(biāo)
            
            @Override
            public boolean hasNext() {

                return cursor!=index;
            }

            @Override
            public String next() {
                
                return (String) arr[cursor++];
            }

            @Override
            public void remove() {
                
            }
            
            
        };
    }
}

public class Demo3 {
    
    public static void main(String[] args) {
        MyList list = new MyList();
        list.add("張三");
        list.add("李四");
        list.add("王五");
        list.add("趙六");
        for(String item :list){
            System.out.println(item+",");
        }
    }
}

jdk1.5新特性之----- 自定義類實現(xiàn)Iterable接口

可變參數(shù)的格式：

數(shù)據(jù)類型...  變量名 //幾個點必須要寫的

可變參數(shù)要 注意的事項：

  1. 如果一個函數(shù)的形參使用了可變參數(shù)，那么調(diào)用該函數(shù)的時候可以傳遞參數(shù)也可以不傳遞參數(shù)。
  2. 可變參數(shù)實際上就是一個數(shù)組.
  3. 可變參數(shù)必須要位于形參列表中的最后一個位置。
  4. 一個方法中最多只能使用一個可變參數(shù)。

需求:定義函數(shù)計算總和

public class Demo4 {
    
    public static void main(String[] args) {
        sum(1,2);         //當(dāng)一個函數(shù)使用了可變參數(shù)的時候，傳遞的數(shù)據(jù)的時候，jvm會自動把實參數(shù)據(jù)保存到一個數(shù)組中，然后再傳遞給可變參數(shù)。
    }
    
    public static void sum(int... arr){
        int sum = 0;
        for(int i : arr){
            sum+=i;
        }
        System.out.println("總和："+ sum);
    }

}

jdk1.5新特性之---自動裝箱與自動拆箱

java是面向?qū)ο蟮恼Z言， 任何的事物都使用了一個類進(jìn)行了描述。 基本類型數(shù)據(jù)也是一類事物，所以
java對于基本類型的數(shù)據(jù)也使用了對應(yīng)的類進(jìn)行了描述，我們把描述基本類型變量的類稱作為----- 包裝類。

基本數(shù)據(jù)類型 包裝類型
byte Byte
short Short
int Integer
long Long
float Float
double Double
boolean Boolean
char Character

***基本數(shù)據(jù)類型設(shè)計出對應(yīng)的包裝類型的好處： *** 可以讓基本數(shù)據(jù)類型也使用上方法，讓功能變得更加強大。

public class Demo5 {
    
    public static void main(String[] args) {
        /*String str = "12";
        
        //功能一：可以把字符串轉(zhuǎn)成數(shù)字
        int num = Integer.parseInt(str); 
        System.out.println(num+1);
        
        //功能2： 可以把數(shù)字轉(zhuǎn)成指定進(jìn)制格式的字符串。
        int num2 = 10; 
        System.out.println("二進(jìn)制："+ Integer.toBinaryString(num2));
        System.out.println("八進(jìn)制："+ Integer.toOctalString(num2));
        System.out.println("十六進(jìn)制："+ Integer.toHexString(num2));*/
        
        
        //自動裝箱 --     自動把基本數(shù)據(jù)類型轉(zhuǎn)成引用數(shù)據(jù)類型數(shù)據(jù)，
        /*ArrayList<Integer> list = new ArrayList<Integer>();
        list.add(1); // new Integer(數(shù)據(jù))
        list.add(2);
        */
        
        //自動拆箱：   自動把引用數(shù)據(jù)類型數(shù)據(jù)轉(zhuǎn)成  基本數(shù)據(jù)類型.
        Integer i = new Integer(10);  //引用數(shù)據(jù)類型數(shù)據(jù)
        System.out.println(2+i); // intValue() 獲取基本類型的數(shù)據(jù)
        
        /*
         Integer類內(nèi)部維護(hù)了一個靜態(tài)的數(shù)組，該數(shù)組內(nèi)部存儲了-128~127這些數(shù)據(jù)，當(dāng)我們創(chuàng)建
         一個Integer對象的時候，如果數(shù)據(jù)是落入到了-128~127這個范圍之內(nèi)，那么會直接從數(shù)組中
         獲取，而不會創(chuàng)建新的Integer對象。    ----------> 把一些常用的數(shù)據(jù)事先創(chuàng)建好，
         然后貢獻(xiàn)給大家一起使用 ： 享元模式。
         
         */
        Integer i1 = 127;
        Integer i2 = 127;
        System.out.println(i1==i2);//true;在int表示范圍內(nèi),所以比較的其實是兩個int數(shù)據(jù)而已
        
        Integer ii1 = 128;
        Integer ii2 = 128;
        System.out.println(ii1==ii2)//false;因為超出了int表示的范圍,所以這里是創(chuàng)建了兩個不同對象
    }
}

jdk1.5的新特性之-------->枚舉類

枚舉類的應(yīng)用場景：一些方法在運行時，它需要的數(shù)據(jù)不能是任意的，而必須是一定范圍內(nèi)的值 , 這時候我們就可以使用枚舉類進(jìn)行限制。

比如： 一年四季、 方向、 性別...

定義枚舉類的格式：

enum  類名{
    
}

枚舉類要注意的事項：

  1. 枚舉類是一個特殊的類。
  2. 枚舉值默認(rèn)的修飾符是： public static final 。
  3. 枚舉值其實就是一個當(dāng)前枚舉類的對象。
  4. 枚舉值必須是枚舉類中的第一個語句。
  5. 枚舉類的構(gòu)造方法默認(rèn)的修飾符是private，修飾符也必須是private.
  6. 枚舉類允許出現(xiàn)抽象的方法，但是一旦出現(xiàn)了抽象的方法，那么枚舉值就必須要實現(xiàn)抽象方法。(幾乎不用)
enum Direction{
    
    /*UP("上"){

        @Override
        public void test() {
            System.out.println("哈哈，爽嗎?");
        }
        
    },DOWN("下"){

        @Override
        public void test() {
            System.out.println("呵呵，是向下！！");
        }
        
    }; */  //枚舉值
    
    UP("上"),DOWN("下");
    
    String value;  //成員變量
    
    private Direction(String value){
        this.value = value;
    }
    
    //成員函數(shù)
    public void print(){
        System.out.println("value:"+value);
    }
    
    //public abstract void test();
}


public class Demo7 {

    public static void main(String[] args) {
        //Direction.UP.test();使用抽象方法 
        Direciton.DOWN.print();

        //使用values方法可以使用該枚舉類的所有枚舉值
        Direction []d = Direction.values();
        for(Direction value :d){
            System.out.println(value);
        }
    }
}

switch語句的使用
switch語句適用的數(shù)據(jù)類型： byte\ short \ int \char \ String \枚舉類型。

注意的事項：

  1. 在switch語句中使用枚舉類的時候，case語句后面的枚舉值不能帶有枚舉類，直接寫枚舉值即可。
//季節(jié)
enum Season{
    SPRING,SUMMER,AUTUMN,WINTER;
}

public class Demo8 {
    
    public static void main(String[] args) {
        Season currentSeason =  Season.SUMMER;
    
        switch (currentSeason) {
            case SPRING:
                System.out.println("春天來了..");
                break;
            case SUMMER:
                System.out.println("夏天到了..");
                break;
            case AUTUMN:
                System.out.println("秋天不遠(yuǎn)了..");
                break;
            case WINTER:
                System.out.println("冬天不見了..");
                break;
        }

    }
}
最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務(wù)。

推薦閱讀更多精彩內(nèi)容