java基礎增強
阿新 • • 發佈：2017-11-05
構造 single span abs move rri star msi pan
1. 靜態導入和自動裝箱拆箱
(1).靜態導入： 導入java裏面類的靜態成員 import static 包名 類名 靜態屬性/靜態方法/*
(2).自動裝箱拆箱：
自動裝箱：把基本數據類型賦值給對應的包裝類（對象）
自動拆箱：把包裝類的對象賦值給對應的基本數據類型
1 package com.study.lgs; 2 import static java.lang.System.out; 3 4 import java.util.ArrayList; 5 import java.util.Iterator; 6 import java.util.List; 7 public classZhuangXiangChaiXiang { 8 9 public static void main(String[] args) { 10 // TODO Auto-generated method stub 11 //1、靜態導入 12 //out.println("aaa"); 13 14 //2.自動裝箱拆箱： 15 Integer i=1;//自動裝箱 jdk1.5+才能這樣寫 否則這樣寫：Integer i=new Integer(1) 16 int j=i;//自動拆箱 1718 //3.自動裝箱拆箱的典型應用 19 List l=new ArrayList(); 20 l.add(1);//裝箱 把對象1裝到list對象l裏面去 21 l.add(2); 22 l.add(3); 23 24 //叠代器遍歷輸出 25 Iterator k=l.iterator(); 26 while(k.hasNext()){ 27 int j1=(Integer)k.next(); 28 out.println(j1);29 30 31 } 32 /*ArrayList<Integer> al=new ArrayList<Integer>(); 33 al.add(1); 34 al.add(2); 35 al.add(3); 36 for(Integer k:al){ 37 out.println(k); 38 }*/ 39 } 40 41 }
2. 增強for循環
用途：遍歷數組或者遍歷實現Iterable泛型接口的集合
1 package cn.study.lgs; 2 import static java.lang.System.out; 3 4 import java.util.ArrayList; 5 import java.util.HashMap; 6 import java.util.Iterator; 7 import java.util.List; 8 import java.util.Map; 9 import java.util.Map.Entry; 10 import java.util.Set; 11 12 import org.junit.Test; 13 14 public class StrongFor { 15 16 @Test 17 public void test1(){ 18 //1、遍歷數組 19 int i[]={1,2,3}; 20 for(int k:i){ 21 out.println(k); 22 } 23 } 24 @Test 25 public void test2(){ 26 //2、遍歷集合 27 List l=new ArrayList(); 28 l.add(1); 29 l.add(2); 30 l.add(3); 31 // l.add("aaa"); 32 33 for(Object o:l){ 34 // out.println(o); //不用包裝直接以對象的形式輸出 也可以 35 int i=(Integer) o; 36 out.println(i); 37 } 38 } 39 @Test 40 public void testMap(){ 41 Map m=new HashMap(); 42 m.put("1", "aaa"); 43 m.put("2", "bbb"); 44 m.put("3", "ccc"); 45 //1、傳統方案取出Map裏面的值 1 46 Set s=m.keySet();//通過keyset方法把map裏面的每個key存到s裏面去 47 Iterator i=s.iterator();//叠代遍歷s裏面的key值 48 while(i.hasNext()){ 49 // String key=(String) i.next(); 50 // String value=(String) m.get(key); 51 // out.println(key+"對應的值為："+value); 52 String st=(String) i.next(); 53 System.out.println(st+ "對應的值為"+m.get(st)); 54 55 // System.out.println(i.next()); //有錯 兩次的i.next()不一樣 56 // System.out.println(m.get(i.next())); 57 58 59 } 60 61 62 } 63 @Test 64 public void testMap2(){ 65 Map m=new HashMap(); 66 m.put("1", "aaa"); 67 m.put("2", "bbb"); 68 m.put("3", "ccc"); 69 //1、傳統方案取出Map裏面的值 2 70 Set s=m.entrySet();//通過entrySet方法把每組鍵值存到s中 71 Iterator i=s.iterator();//叠代遍歷輸出s中的值 72 while(i.hasNext()){ 73 Map.Entry me=(Entry) i.next(); 74 System.out.println(me.getKey()+"對應的值為"+me.getValue()); 75 } 76 77 78 79 } 80 81 @Test 82 public void testMap3(){ 83 Map m=new HashMap(); 84 m.put("1", "aaa"); 85 m.put("2", "bbb"); 86 m.put("3", "ccc"); 87 //1、增強for循環 1 (keySet實現Iterable泛型接口) 88 for(Object o:m.keySet()){ 89 // String s=(String) o; 90 // String value=(String) m.get(o); 91 // System.out.println(o+" "+value); 92 out.println(o+" "+m.get(o)); 93 } 94 95 96 } 97 @Test 98 public void testMap4(){ 99 Map m=new HashMap(); 100 m.put("1", "aaa"); 101 m.put("2", "bbb"); 102 m.put("3", "ccc"); 103 //1、增強for循環 2 (entrySet實現Iterable泛型接口) 104 for(Object o:m.entrySet()){ 105 Map.Entry me=(Entry) o; 106 System.out.println(me.getKey()+" "+me.getValue()); 107 } 108 109 110 } 111 112 @Test //增強for循環應該註意的問題 增強for循環只能取數組或者集合裏面的數據 不能更改數據；要改數據的話只能用傳統方法 113 public void test3(){ 114 // int []i=new int[]{1,2,3}; 115 // for(int j:i){ 116 // j=10;//j僅僅是指向取出來的值而已 並不能改變數組裏面的值 117 // 118 // } 119 // //傳統方法改變數組的值 120 // for(int j=0;j<i.length;j++){ 121 // i[j]=10; 122 // } 123 // out.println(i[0]); 124 // out.println(i[1]); 125 // out.println(i[2]); 126 // 127 128 List l=new ArrayList(); 129 l.add("a"); 130 l.add("b"); 131 l.add("c"); 132 for(Object k:l){ 133 k="d";//k僅僅是指向取出來的值而已 並不能改變集合裏面的值 134 135 } 136 //傳統方案刪除集合裏面的元素 137 for(int i=0;i<l.size();i++){ 138 139 l.removeAll(l); 140 141 142 143 } 144 l.add("e"); 145 l.add("e"); 146 l.add("e"); 147 System.out.println(l.get(0)); 148 System.out.println(l.get(1)); 149 System.out.println(l.get(2)); 150 151 152 } 153 }
3. 可變參數
使用可變參數的精髓：就是看需要什麽類型的數據，需要對象就傳入對象/對象數組，需要基本數據類型就傳基本數據類型/基本數組
1 package com.study.lgs; 2 import java.util.Arrays; 3 import java.util.List; 4 5 import org.junit.Test; 6 7 public class KeBianCanShu { 8 9 @Test 10 public void testSum(){ 11 int []i={1,2,3}; 12 sum(i);//可變參數裏面可以看成一個數組，所以可以向裏面傳入數組i 13 sum(1,2,3); 14 } 15 //可變參數按數組方式進行處理，只能放在參數列表的最後，一個參數列表中只能有一個可變參數 16 17 public void sum(int...nums){ 18 int sum=0; 19 for(int k:nums){ 20 sum+=k; 21 } 22 System.out.println(sum); 23 } 24 @Test 25 public void testArrays(){ 26 List l=Arrays.asList("1","2","3");//傳入普通字符串對象 27 System.out.println(l); 28 29 String [] s={"1","2","3","4"};//傳入字符數組對象 30 l=Arrays.asList(s); 31 System.out.println(l); 32 33 //int []i={1,2,3,4,5}; 34 Integer []i={1,2,3,4,5}; 35 l=Arrays.asList(i);//傳入基本數據類型整型數組對象 List的l會吧i數組看作一個對象，所以輸出的l為一個地址，必須使用包裝類的對象以對象方式傳入才可輸出實際的值 36 System.out.println(l); 37 } 38 39 }
4. 枚舉
4.1 枚舉的作用和特性
作用：限定某些程序運行時所需要數據的取值範圍
特性：
(1) 枚舉類也是一種特殊形式的java類
(2) 枚舉類中聲明的每一個枚舉值代表枚舉類的一個實例對象
(3) 與java中的普通類一樣，在聲明枚舉類時，也可以聲明屬性、方法和構造函數，但枚舉類的構造函數必須是私有的(因為枚舉類的作用就是限定某些程序運行時所需要數據的取值範圍，如果構造函數公有，別人就可以隨便更改)
(4) 枚舉類也可以實現接口、繼承抽象類
(5) jdk5擴展了switch語句，它除了可以接收int,byte,char,short外，還可以接收一個枚舉類型
(6) 若枚舉類只有一個枚舉值，則可以單作單態設計模式使用
1 package enumeration; 2 3 import org.junit.Test; 4 5 //枚舉的作用：限定某些程序運行時所需要數據的取值範圍 6 enum Grade{ 7 A,B,C,D 8 } 9 public class DefineEnum { 10 @Test 11 public void test(){ 12 DefineEnum.printGrade(Grade.A); 13 } 14 public static void printGrade(Grade a){ 15 switch(a){ 16 case A: 17 System.out.println("90"); 18 break; 19 case B: 20 System.out.println("80"); 21 break; 22 case C: 23 System.out.println("70"); 24 break; 25 case D: 26 System.out.println("60"); 27 break; 28 default: 29 System.out.println("傳入參數有錯"); 30 31 } 32 } 33 }
4.2 定義枚舉的字段、構造函數、方法去封裝更多的信息
1 package enumeration; 2 3 import org.junit.Test; 4 5 //枚舉的作用：限定某些程序運行時所需要數據的取值範圍 6 //怎樣定義枚舉的字段、構造函數、方法去封裝更多的信息 7 enum Grade{ 8 A("100-90"),B("89-80"),C("79-70"),D("69-60");//對枚舉進行實例化 9 private String value;//定義每個枚舉類型裏面存的值 10 private Grade(String value){ 11 this.value=value; 12 } 13 public String getValue(){ //外部對象獲取每個枚舉類型裏面存的值 14 return this.value; 15 } 16 } 17 public class DefineEnum { 18 @Test 19 public void test(){ 20 printGrade(Grade.B); 21 } 22 public void printGrade(Grade a){ 23 System.out.println(a.getValue()); 24 } 25 }
4.3 帶抽象方法的枚舉 實例化時必須實現抽象方法
1 package enumeration; 2 3 import org.junit.Test; 4 5 //枚舉的作用：限定某些程序運行時所需要數據的取值範圍 6 //帶抽象方法的枚舉 實例化時必須實現抽象方法 7 enum Grade{ 8 A("100-90") { 9 @Override 10 public String getLocalValue() { 11 // TODO Auto-generated method stub 12 return "優"; 13 } 14 }, 15 B("89-80") { 16 @Override 17 public String getLocalValue() { 18 // TODO Auto-generated method stub 19 return "良"; 20 } 21 }, 22 C("79-70") { 23 @Override 24 public String getLocalValue() { 25 // TODO Auto-generated method stub 26 return "中"; 27 } 28 }, 29 D("69-60") { 30 @Override 31 public String getLocalValue() { 32 // TODO Auto-generated method stub 33 return "差"; 34 } 35 };//對枚舉進行實例化 必須實現抽象方法 36 37 private String value;//定義每個枚舉類型裏面存的值 38 private Grade(String value){ 39 this.value=value; 40 } 41 public String getValue(){ //外部對象獲取每個枚舉類型裏面存的值 42 return this.value; 43 } 44 //帶抽象方法的枚舉 45 public abstract String getLocalValue(); 46 } 47 public class DefineEnum { 48 @Test 49 public void test(){ 50 printGrade(Grade.B); 51 } 52 public void printGrade(Grade a){ 53 System.out.println(a.getValue()); 54 System.out.println(a.getLocalValue()); 55 56 } 57 }
4.4 普通單例設計模式與枚舉單例設計模式
1 package enumeration; 2 3 //定義普通單態設計模式 4 class Single{ 5 private static Single sin=null; 6 private Single(){} 7 private Single(Single sin){ 8 this.sin=sin; 9 } 10 public static Single createShiLi(){ 11 if(sin==null){ 12 sin=new Single(); 13 } 14 return sin; 15 16 } 17 } 18 //定義枚舉類型單態設計模式 當枚舉裏面只有一個對象時也屬於單態設計模式 19 enum EnumSingle{ 20 A;//枚舉中聲明的每一個枚舉值表示枚舉類的一個實例化對象 21 //m枚舉類的構造函數必須是私有的，因為枚舉就是用來限制實例化的對象的，如果構造函數為公有的就可以實例化新的對象，不符合枚舉規範 22 } 23 public class DefineSingle { 24 25 public static void main(String[] args) { 26 // TODO Auto-generated method stub 27 //普通設計模式的實例化 28 Single s1=Single.createShiLi(); 29 Single s2=Single.createShiLi(); 30 Single s3=Single.createShiLi(); 31 System.out.println(s1); 32 System.out.println(s2); 33 System.out.println(s3); 34 35 36 37 } 38 39 }
java基礎增強