------- android培訓(xùn)、java培訓(xùn)、期待與您交流！ ----------
27.01反射_類的加載概述和加載時機
類的加載:當(dāng)程序要使用某個類時，如果該類還未被加載到內(nèi)存中，則系統(tǒng)會通過加載，連接，初始化三步來實現(xiàn)對這個類進行初始化。
加載:就是指將class文件讀入內(nèi)存，并為之創(chuàng)建一個Class對象。任何類被使用時系統(tǒng)都會建立一個Class對象。
連接
驗證是否有正確的內(nèi)部結(jié)構(gòu)，并和其他類協(xié)調(diào)一致
準備負責(zé)為類的靜態(tài)成員分配內(nèi)存，并設(shè)置默認初始化值
解析將類的二進制數(shù)據(jù)中的符號引用替換為直接引用
初始化:
創(chuàng)建類的實例
訪問類的靜態(tài)變量，或者為靜態(tài)變量賦值
調(diào)用類的靜態(tài)方法
使用反射方式來強制創(chuàng)建某個類或接口對應(yīng)的java.lang.Class對象
初始化某個類的子類
直接使用java.exe命令來運行某個主類
27.02反射_類加載器的概述和分類類加載器:負責(zé)將.class文件加載到內(nèi)在中，并為之生成對應(yīng)的Class對象。
類加載器的組成:
BootstrapClassLoader根類加載器
也被稱為引導(dǎo)類加載器，負責(zé)Java核心類的加載
比如System,String等。在JDK中JRE的lib目錄下rt.jar文件中
ExtensionClassLoader擴展類加載器
負責(zé)JRE的擴展目錄中jar包的加載。
在JDK中JRE的lib目錄下ext目錄
SysetmClassLoader系統(tǒng)類加載器
負責(zé)在JVM啟動時加載來自java命令的class文件，以及classpath環(huán)境變量所指定的jar包和類路徑
27.03反射_反射概述JAVA反射機制是在運行狀態(tài)中，對于任意一個類，都能夠知道這個類的所有屬性和方法；對于任意一個對象，都能夠調(diào)用它的任意一個方法和屬性；這種動態(tài)獲取的信息以及動態(tài)調(diào)用對象的方法的功能稱為java語言的反射機制。
要想解剖一個類，必須先要獲取到該類的字節(jié)碼文件對象。而解剖使用的就是Class類中的方法.所以先要獲取到每一個字節(jié)碼文件對應(yīng)的Class類型的對象。
27.04反射_獲取class文件對象的三種方式1:Object類的getClass()方法
2:數(shù)據(jù)類型的靜態(tài)屬性class
3:Class類中的靜態(tài)方法:publicstaticClassforName(StringclassName)
開發(fā)中使用第三種方式
例:
1 public class PRactice 2 { 3 public static void main(String[] args) throws ClassNotFoundException 4 { 5 // 方式1 6 Student p = new Student(); 7 Class c1 = p.getClass(); 8 9 Student p2 = new Student();10 Class c2 = p2.getClass();11 12 System.out.println(p == p2);// false13 System.out.println(c1 == c2);// true14 15 // 方式216 Class c3 = Student.class;17 System.out.println(c1 == c3);// true18 19 // 方式320 //public static Class<?> forName(String className) throws ClassNotFoundException21 //返回與帶有給定字符串名的類或接口相關(guān)聯(lián)的 Class 對象22 Class c4 = Class.forName("com.test.Student");//類的全路徑23 System.out.println(c1 == c4);// true24 }25 }
27.05反射_通過反射獲取無參構(gòu)造方法并使用
獲取無參構(gòu)造方法
publicConstructor<?>[]getConstructors()throwsSecurityException
返回一個包含某些Constructor對象的數(shù)組，這些對象反映此Class對象所表示的類的所有公共構(gòu)造方法。
publicConstructor<?>[]getDeclaredConstructors()throwsSecurityException
返回Constructor對象的一個數(shù)組，這些對象反映此Class對象表示的類聲明的所有構(gòu)造方法。
例1:
1 Class c = Class.forName("com.test.Student"); 2 //獲取所有公共構(gòu)造方法 3 Constructor[] cons = c.getConstructors(); 4 for(Constructor con : cons) 5 { 6 System.out.println(con); 7 } 8 System.out.println("--------------"); 9 //獲取所有構(gòu)造方法10 Constructor[] conss = c.getDeclaredConstructors();11 for(Constructor con : conss)12 {13 System.out.println(con);14 }例2:
1 public class Practice 2 { 3 public static void main(String[] args) throws Exception 4 { 5 Class c = Class.forName("com.test.Student"); 6 // 獲取單個構(gòu)造方法 7 // public Constructor<T> getConstructor(Class<?>... parameterTypes) 8 // 參數(shù)表示的是:要獲取的構(gòu)造方法的構(gòu)造參數(shù)個數(shù)及數(shù)據(jù)類型的class字節(jié)碼文件對象 9 Constructor con = c.getConstructor();// 返回的是構(gòu)造方法對象10 11 // Person p = new Person();12 // System.out.println(p);13 // public T newInstance(Object... initargs)14 // 使用此 Constructor 對象表示的構(gòu)造方法來創(chuàng)建該構(gòu)造方法的聲明類的新實例，并用指定的初始化參數(shù)初始化該實例。15 Object obj = con.newInstance();16 System.out.println(obj);17 18 //Student p = (Student)obj;19 //p.show();20 }21 }27.06反射_通過反射獲取帶參構(gòu)造方法并使用
獲取帶參構(gòu)造方法
例:
1 public class Practice 2 { 3 public static void main(String[] args) throws Exception 4 { 5 // 獲取字節(jié)碼文件對象 6 Class c = Class.forName("com.test.Student"); 7 8 // 獲取帶參構(gòu)造方法對象 9 // public Constructor<T> getConstructor(Class<?>... parameterTypes)10 Constructor con = c.getConstructor(String.class, int.class,String.class);11 12 // 通過帶參構(gòu)造方法對象創(chuàng)建對象13 // public T newInstance(Object... initargs)14 Object obj = con.newInstance("小明", 27, "上海");15 16 System.out.println(obj);17 }18 }27.07反射_通過反射獲取私有構(gòu)造方法并使用
獲取私有構(gòu)造方法
1 public class Practice 2 { 3 public static void main(String[] args) throws Exception 4 { 5 // 獲取字節(jié)碼文件對象 6 Class c = Class.forName("com.test.Student"); 7 8 // 獲取私有構(gòu)造方法對象 9 Constructor con = c.getDeclaredConstructor(String.class);10 11 // 用該私有構(gòu)造方法創(chuàng)建對象12 // IllegalaccessException:非法的訪問異常。13 // 暴力訪問14 con.setAccessible(true);// 值為true則指示反射的對象在使用時應(yīng)該取消Java語言訪問檢查15 Object obj = con.newInstance("旺財");16 17 System.out.println(obj);18 }19 }27.08反射_通過反射獲取成員變量并使用
獲取成員變量
publicFieldgetField(Stringname)throwsNoSuchFieldException,SecurityException
返回一個Field對象，它反映此Class對象所表示的類或接口的指定公共成員字段。
publicField[]getDeclaredFields()throwsSecurityException
返回Field對象的一個數(shù)組，這些對象反映此Class對象所表示的類或接口所聲明的所有字段。
例:
1 public class Practice 2 { 3 public static void main(String[] args) throws Exception 4 { 5 // 獲取字節(jié)碼文件對象 6 Class c = Class.forName("com.test.Student"); 7 8 // 通過無參構(gòu)造方法創(chuàng)建對象 9 Constructor con = c.getConstructor();10 Object obj = con.newInstance();11 System.out.println(obj);12 13 // 獲取單個的成員變量14 // 獲取address并對其賦值(公共的)15 Field addressField = c.getField("address");16 // public void set(Object obj,Object value)17 // 將指定對象變量上此 Field 對象表示的字段設(shè)置為指定的新值。18 addressField.set(obj, "上海"); // 給obj對象的addressField字段設(shè)置值為"上海"19 System.out.println(obj);20 21 // 獲取name并對其賦值(私有的)22 // NoSuchFieldException23 Field nameField = c.getDeclaredField("name");24 // IllegalAccessException25 nameField.setAccessible(true);26 nameField.set(obj, "小強");27 System.out.println(obj);28 29 // 獲取age并對其賦值(默認的)30 Field ageField = c.getDeclaredField("age");31 ageField.setAccessible(true);32 ageField.set(obj, 27);33 System.out.println(obj);34 }35 }27.09反射_通過反射獲取無參無返回值成員方法并使用
獲取無參無返回值成員方法
publicMethod[]getMethods()throwsSecurityException
返回本類的所有公共方法同時返回從Object類繼承的所有公共方法。
publicMethod[]getDeclaredMethods()throwsSecurityException
返回自己的所有方法
例:
1 public class Practice 2 { 3 public static void main(String[] args) throws Exception 4 { 5 // 獲取字節(jié)碼文件對象 6 Class c = Class.forName("com.test.Student"); 7 8 Constructor con = c.getConstructor(); 9 Object obj = con.newInstance();10 11 // 獲取單個方法并使用12 // public void show()13 // public Method getMethod(String name,Class<?>... parameterTypes)14 // 第一個參數(shù)表示的方法名，第二個參數(shù)表示的是方法的參數(shù)的class類型15 Method m1 = c.getMethod("show");16 // obj.m1(); // 錯誤17 // public Object invoke(Object obj,Object... args)18 // 返回值是Object接收,第一個參數(shù)表示對象是誰，第二參數(shù)表示調(diào)用該方法的實際參數(shù)19 m1.invoke(obj); // 調(diào)用obj對象的m1方法20 }21 }27.10反射_通過反射獲取帶參帶返回值成員方法并使用
獲取帶參帶返回值成員方法
例:
1 public class Practice 2 { 3 public static void main(String[] args) throws Exception 4 { 5 // 獲取字節(jié)碼文件對象 6 Class c = Class.forName("com.test.Student"); 7 8 Constructor con = c.getConstructor(); 9 Object obj = con.newInstance();10 11 // 獲取單個方法并使用12 // public void show()13 // public Method getMethod(String name,Class<?>... parameterTypes)14 // 第一個參數(shù)表示的方法名，第二個參數(shù)表示的是方法的參數(shù)的class類型15 Method m1 = c.getMethod("show");16 // obj.m1(); // 錯誤17 // public Object invoke(Object obj,Object... args)18 // 返回值是Object接收,第一個參數(shù)表示對象是誰，第二參數(shù)表示調(diào)用該方法的實際參數(shù)19 m1.invoke(obj); // 調(diào)用obj對象的m1方法20 21 System.out.println("----------");22 // public void method(String s)23 Method m2 = c.getMethod("method", String.class);24 m2.invoke(obj, "hello");25 System.out.println("----------");26 27 // public String getString(String s, int i)28 Method m3 = c.getMethod("getString", String.class, int.class);29 Object objString = m3.invoke(obj, "hello", 100);30 System.out.println(objString);31 // String s = (String)m3.invoke(obj, "hello",100);32 // System.out.println(s);33 System.out.println("----------");34 35 // private void function()36 Method m4 = c.getDeclaredMethod("function");37 m4.setAccessible(true);38 m4.invoke(obj);39 }40 }27.11反射_通過反射運行配置文件內(nèi)容
通過配置文件運行類中的方法
反射:需要有配置文件配合使用。用class.txt代替。并且知道有兩個鍵。className、methodName
例:
1 public class Test 2 { 3 public static void main(String[] args) throws Exception 4 { 5 // 反射前的做法 6 // Student s = new Student(); 7 // s.love(); 8 // Teacher t = new Teacher(); 9 // t.love();10 // Worker w = new Worker();11 // w.love();12 13 // 反射后的做法14 // 加載鍵值對數(shù)據(jù)15 Properties prop = new Properties();16 FileReader fr = new FileReader("class.txt");17 prop.load(fr);18 fr.close();19 20 // 獲取數(shù)據(jù)21 String className = prop.getProperty("className");22 String methodName = prop.getProperty("methodName");23 24 // 反射25 Class c = Class.forName(className);26 27 Constructor con = c.getConstructor();28 Object obj = con.newInstance();29 30 // 調(diào)用方法31 Method m = c.getMethod(methodName);32 m.invoke(obj);33 }34 }上例中，如果需要運行其他的類只需要修改class.txt文件中的內(nèi)容即可
27.12反射_通過反射越過泛型檢查實現(xiàn)向ArrayList<Integer>中添加一個字符串?dāng)?shù)據(jù)
1 public class ArrayListDemo 2 { 3 public static void main(String[] args) throws Exception 4 { 5 // 創(chuàng)建集合對象 6 ArrayList<Integer> array = new ArrayList<Integer>(); 7 8 // array.add("hello"); 9 // array.add(10);10 11 Class c = array.getClass(); // 集合ArrayList的class文件對象12 Method m = c.getMethod("add", Object.class);13 14 m.invoke(array, "hello"); // 調(diào)用array的add方法，傳入的值是hello15 m.invoke(array, "world");16 m.invoke(array, "java");17 18 System.out.println(array);19 }20 }27.13反射_通過反射寫一個通用的設(shè)置某個對象的某個屬性為指定的值
1 public class Tool 2 { 3 public void setProperty(Object obj, String propertyName, Object value)throws Exception 4 { 5 // 根據(jù)對象獲取字節(jié)碼文件對象 6 Class c = obj.getClass(); 7 // 獲取該對象的propertyName成員變量 8 Field field = c.getDeclaredField(propertyName); 9 // 取消訪問檢查10 field.setAccessible(true);11 // 給對象的成員變量賦值為指定的值12 field.set(obj, value);13 }14 }15 16 //測試類17 public class ToolDemo 18 {19 public static void main(String[] args) throws Exception 20 {21 Person p = new Person();22 Tool t = new Tool();23 t.setProperty(p, "name", "小明");24 t.setProperty(p, "age", 27);25 System.out.println(p);26 System.out.println("-----------");27 28 Dog d = new Dog();29 30 t.setProperty(d, "sex", '男');31 t.setProperty(d, "price", 12.34f);32 33 System.out.println(d);34 }35 }36 37 class Dog38 {39 char sex;40 float price;41 42 @Override43 public String toString() 44 {45 return sex + "---" + price;46 }47 }48 49 class Person 50 {51 private String name;52 public int age;53 54 @Override55 public String toString()56 {57 return name + "---" + age;58 }59 }27.14反射_動態(tài)代理的概述和實現(xiàn)
動態(tài)代理:在程序運行過程中產(chǎn)生的這個對象，而程序運行過程中產(chǎn)生對象其實就是我們剛才反射講解的內(nèi)容，所以，動態(tài)代理其實就是通過反射來生成一個代理
在Java中java.lang.reflect包下提供了一個Proxy類和一個InvocationHandler接口，通過使用這個類和接口就可以生成動態(tài)代理對象。JDK提供的代理只能針對接口做代理。我們有更強大的代理cglib
Proxy類中的方法創(chuàng)建動態(tài)代理類對象
publicstaticObjectnewProxyInstance(ClassLoaderloader,Class<?>[]interfaces,
InvocationHandlerh)throwsIllegalArgumentException
返回一個指定接口的代理類實例，該接口可以將方法調(diào)用指派到指定的調(diào)用處理程序。最終會調(diào)用InvocationHandler的方法
接口InvocationHandler中的方法
Objectinvoke(Objectproxy,Methodmethod,Object[]args)throwsThrowable
在代理實例上處理方法調(diào)用并返回結(jié)果。
Proxy.newProxyInstance
創(chuàng)建的代理對象是在jvm運行時動態(tài)生成的一個對象，它并不是我們的InvocationHandler類型，
也不是我們定義的那組接口的類型，而是在運行是動態(tài)生成的一個對象，并且命名方式都是這樣的形式，
以$開頭，proxy為中，最后一個數(shù)字表示對象的標號。
System.out.println(u.getClass().getName());
每一個動態(tài)代理類都必須要實現(xiàn)InvocationHandler這個接口，并且每個代理類的實例都關(guān)聯(lián)到了一個handler，當(dāng)我們通過代理對象調(diào)用一個方法的時候，這個方法的調(diào)用就會被轉(zhuǎn)發(fā)為由InvocationHandler這個接口的invoke方法來進行調(diào)用。
Proxy類中創(chuàng)建動態(tài)代理對象的方法的三個參數(shù):
ClassLoader對象，定義了由哪個ClassLoader對象來對生成的代理對象進行加載
Interface對象的數(shù)組，表示的是我將要給我需要代理的對象提供一組什么接口，如果我提供了一組接口給它，那么這個代理對象就宣稱實現(xiàn)了該接口(多態(tài))，這樣我就能調(diào)用這組接口中的方法了
InvocationHandler對象，表示的是當(dāng)我這個動態(tài)代理對象在調(diào)用方法的時候，會關(guān)聯(lián)到哪一個InvocationHandler對象上
InvocationHandler接口中invoke方法的三個參數(shù):
proxy:代表動態(tài)代理對象
method:代表正在執(zhí)行的方法
args:代表調(diào)用目標方法時傳入的實參
27.15設(shè)計模式_模版設(shè)計模式概述和使用模版設(shè)計模式概述:模版方法模式就是定義一個算法的骨架，而將具體的算法延遲到子類中來實現(xiàn)
優(yōu)點:使用模版方法模式，在定義算法骨架的同時，可以很靈活的實現(xiàn)具體的算法，滿足用戶靈活多變的需求
缺點:如果算法骨架有修改的話，則需要修改抽象類
例:
1 //模板 2 public abstract class GetTime 3 { 4 // 計算出一段代碼的運行時間 5 public long getTime() 6 { 7 long start = System.currentTimeMillis(); 8 code(); 9 10 long end = System.currentTimeMillis();11 12 return end - start;13 }14 public abstract void code();15 }16 17 //實現(xiàn)類18 public class ForDemo extends GetTime19 {20 @Override21 public void code() 22 {23 for (int x = 0; x < 100000; x++) 24 {25 System.out.println(x);26 }27 }28 }29 //測試類30 public class Practice 31 {32 public static void main(String[] args)33 {34 GetTime gt = new ForDemo();35 System.out.println(gt.getTime() + "毫秒");36 }37 }
27.16設(shè)計模式_裝飾模式概述和使用
裝飾設(shè)計模式概述:裝飾模式就是使用被裝飾類的一個子類的實例，在客戶端將這個子類的實例交給裝飾類。是繼承的替代方案
優(yōu)點:使用裝飾模式，可以提供比繼承更靈活的擴展對象的功能，它可以動態(tài)的添加對象的功能，并且可以隨意的組合這些功能
缺點:正因為可以隨意組合，所以就可能出現(xiàn)一些不合理的邏輯
例:
1 public class Practice 2 { 3 public static void main(String[] args) 4 { 5 Person p = new Person(); 6 // p.chifan(); 7 8 NewPerson p1 = new NewPerson(p); 9 p1.chifan();10 11 NewPerson2 p2 = new NewPerson2();12 p2.chifan();13 }14 }15 16 class Person17 {18 void chifan()19 {20 System.out.println("吃飯");21 }22 }23 24 //這個類的出現(xiàn)是為了增強Person而出現(xiàn)的。25 class NewPerson//裝飾設(shè)計模式26 {27 private Person p ;28 NewPerson(Person p)29 {30 this.p = p;31 }32 33 public void chifan()34 {35 System.out.println("開胃酒");36 p.chifan();37 System.out.println("甜點");38 }39 40 }41 42 43 class NewPerson2 extends Person//繼承44 {45 public void chifan()46 {47 System.out.println("開胃酒");48 super.chifan();49 System.out.println("甜點");50 }51 }27.17JDK5新特性_JDK5新特性回顧
自動裝箱和拆箱、泛型、增強for循環(huán)、靜態(tài)導(dǎo)入、可變參數(shù)
27.18JDK5新特性_自己實現(xiàn)枚舉類枚舉概述:是指將變量的值一一列出來,變量的值只限于列舉出來的值的范圍內(nèi)。
舉例:一周只有7天，一年只有12個月等。
單例設(shè)計模式:單例類是一個類只有一個實例
那么多例類就是一個類有多個實例，但不是無限個數(shù)的實例，而是有限個數(shù)的實例。這才能是枚舉類。
例:
1 //版本1 2 public class Direction 3 { 4 // 創(chuàng)建幾個實例 5 public static final Direction FRONT = new Direction(); 6 public static final Direction BEHIND = new Direction(); 7 public static final Direction LEFT = new Direction(); 8 public static final Direction RIGHT = new Direction(); 9 10 // 構(gòu)造私有，不能無限的創(chuàng)建 11 private Direction() 12 {} 13 } 14 ---------------------------------------------------------------------- 15 //版本2 16 public class Direction2 17 { 18 // 創(chuàng)建幾個實例 19 public static final Direction2 FRONT = new Direction2("前"); 20 public static final Direction2 BEHIND = new Direction2("后"); 21 public static final Direction2 LEFT = new Direction2("左"); 22 public static final Direction2 RIGHT = new Direction2("右"); 23 24 // 構(gòu)造私有，別人就不能無限的創(chuàng)建了 25 // private Direction2() { 26 // } 27 28 // 加入成員變量,并去掉無參構(gòu)造 29 private String name; 30 31 private Direction2(String name) 32 { 33 this.name = name; 34 } 35 36 public String getName() 37 { 38 return name; 39 } 40 } 41 ---------------------------------------------------------------------- 42 //版本3 43 public abstract class Direction3 44 { 45 // 創(chuàng)建幾個實例 46 public static final Direction3 FRONT = new Direction3("前") 47 { 48 @Override 49 public void show() 50 { 51 System.out.println("前"); 52 } 53 54 }; 55 public static final Direction3 BEHIND = new Direction3("后") 56 { 57 @Override 58 public void show() 59 { 60 System.out.println("后"); 61 } 62 63 }; 64 public static final Direction3 LEFT = new Direction3("左") 65 { 66 @Override 67 public void show() 68 { 69 System.out.println("左"); 70 } 71 72 }; 73 public static final Direction3 RIGHT = new Direction3("右") 74 { 75 @Override 76 public void show() 77 { 78 System.out.println("右"); 79 } 80 81 }; 82 83 // 構(gòu)造私有，別人就不能無限的創(chuàng)建了 84 // private Direction2() { 85 // } 86 87 // 加入成員變量,并去掉無參構(gòu)造 88 private String name; 89 90 private Direction3(String name) 91 { 92 this.name = name; 93 } 94 95 public String getName() 96 { 97 return name; 98 } 99 100 // 加入抽象方法101 public abstract void show();102 }103 ----------------------------------------------------------------------104 //測試105 public class DirectionDemo 106 {107 public static void main(String[] args) 108 {109 Direction d = Direction.FRONT;110 System.out.println(d); // cn.itcast_01.Direction@175078b111 System.out.println("------------------------------------");112 Direction2 d2 = Direction2.FRONT;113 System.out.println(d2);// cn.itcast_01.Direction2@11563ff114 System.out.println(d2.getName());115 d2 = Direction2.RIGHT;116 System.out.println(d2);117 System.out.println(d2.getName());118 System.out.println("------------------------------------");119 Direction3 d3 = Direction3.FRONT;120 System.out.println(d3);121 System.out.println(d3.getName());122 d3.show();123 124 d3 = Direction3.LEFT;125 System.out.println(d3);126 System.out.println(d3.getName());127 d3.show();128 }129 }27.19JDK5新特性_通過enum實現(xiàn)枚舉類
格式:
只有枚舉項的枚舉類
publicenum枚舉類名
{
枚舉項1，枚舉項2，枚舉項3…;
}
例:
1 //版本1 2 public enum Direction 3 { 4 FRONT, BEHIND, LEFT, RIGHT; 5 } 6 ---------------------------------------------------------------------- 7 //版本2 8 public enum Direction2 9 { 10 FRONT("前"), BEHIND("后"), LEFT("左"), RIGHT("右"); 11 12 private String name; 13 14 private Direction2(String name) 15 { 16 this.name = name; 17 } 18 19 public String getName() 20 { 21 return name; 22 } 23 } 24 25 ---------------------------------------------------------------------- 26 //版本3 27 public enum Direction3 28 { 29 FRONT("前") 30 { 31 @Override 32 public void show() 33 { 34 System.out.println("前"); 35 } 36 }, 37 BEHIND("后") 38 { 39 @Override 40 public void show() 41 { 42 System.out.println("后"); 43 } 44 }, 45 LEFT("左") 46 { 47 @Override 48 public void show() 49 { 50 System.out.println("左"); 51 } 52 }, 53 RIGHT("右") 54 { 55 @Override 56 public void show() 57 { 58 System.out.println("右"); 59 } 60 }; 61 62 private String name; 63 64 private Direction3(String name) 65 { 66 this.name = name; 67 } 68 69 public String getName() 70 { 71 return name; 72 } 73 74 public abstract void show(); 75 } 76 77 ---------------------------------------------------------------------- 78 //測試 79 public class DirectionDemo 80 { 81 public static void main(String[] args) 82 { 83 Direction d = Direction.FRONT; 84 System.out.println(d); // FRONT 85 // public String toString()返回枚舉常量的名稱，它包含在聲明中。 86 System.out.println("-------------"); 87 Direction2 d2 = Direction2.FRONT; 88 System.out.println(d2); 89 System.out.println(d2.getName()); 90 System.out.println("-------------"); 91 Direction3 d3 = Direction3.FRONT; 92 System.out.println(d3); 93 System.out.println(d3.getName()); 94 d3.show(); 95 System.out.println("--------------"); 96 97 Direction3 dd = Direction3.FRONT; 98 dd = Direction3.LEFT; 99 100 switch (dd) 101 {102 case FRONT:103 System.out.println("你選擇了前");104 break;105 case BEHIND:106 System.out.println("你選擇了后");107 break;108 case LEFT:109 System.out.println("你選擇了左");110 break;111 case RIGHT:112 System.out.println("你選擇了右");113 break;114 }115 }116 }運行結(jié)果:
FRONT-------------FRONT前-------------FRONT前前--------------你選擇了左27.20JDK5新特性_枚舉的注意事項
注意事項:
1.定義枚舉類要用關(guān)鍵字enum
2.所有枚舉類都是Enum的子類
3.枚舉類的第一行上必須是枚舉項，最后一個枚舉項后的分號是可以省略的，但是如果枚舉類有其他的東西，這個分號就不能省 略。建議不要省略
4.枚舉類可以有構(gòu)造器，但必須是private的，它默認的也是private的。枚舉項的用法比較特殊:枚舉(“”);
5.枚舉類也可以有抽象方法，但是枚舉項必須重寫該方法
6.枚舉在switch語句中的使用
27.21JDK5新特性_枚舉類的常見方法1.publicfinalintcompareTo(Eo)比較此枚舉與指定對象的順序。
2.publicfinalStringname()返回此枚舉常量的名稱，在其枚舉聲明中對其進行聲明。
3.publicfinalintordinal()返回枚舉常量的序數(shù)（它在枚舉聲明中的位置，其中初始常量序數(shù)為零）。
4.publicStringtoString()返回枚舉常量的名稱，它包含在聲明中。
5.publicstatic<TextendsEnum<T>>TvalueOf(Class<T>enumType,Stringname)
返回帶指定名稱的指定枚舉類型的枚舉常量。
例:
1 public class Practice 2 { 3 public static void main(String[] args) 4 { 5 // int compareTo(E o) 6 Direction2 d21 = Direction2.FRONT;//0 7 Direction2 d22 = Direction2.BEHIND;//1 8 Direction2 d23 = Direction2.LEFT;//2 9 Direction2 d24 = Direction2.RIGHT;//310 System.out.println(d21.compareTo(d21));//011 System.out.println(d21.compareTo(d24));//-312 System.out.println(d24.compareTo(d21));//313 System.out.println("---------------");14 // String name()15 System.out.println(d21.name());//FRONT16 System.out.println("--------------");17 // int ordinal()18 System.out.println(d21.ordinal());//019 System.out.println(d22.ordinal());//120 System.out.println("--------------");21 // String toString()22 System.out.println(d21.toString());//FRONT23 System.out.println(d22.toString());//BEHIND24 System.out.println("--------------");25 // <T> T valueOf(Class<T> type,String name)26 Direction2 d = Enum.valueOf(Direction2.class, "FRONT");27 System.out.println(d.getName());//前28 System.out.println("----------------");29 // values()30 // 此方法雖然在JDK文檔中查找不到，但每個枚舉類都具有該方法，它遍歷枚舉類的所有枚舉值非常方便31 Direction2[] dirs = Direction2.values();32 for (Direction2 d2 : dirs) 33 {34 System.out.println(d2);35 System.out.println(d2.getName());36 }37 }38 }27.22JDK7新特性_JDK7的六個新特性回顧和講解
二進制字面量
JDK7開始，可以用二進制來表示整數(shù)（byte,short,int和long）。
使用二進制字面量的好處是，可以使代碼更容易被理解。語法非常簡單，只要在二進制數(shù)值前面加0b或者0B
例:intx=0b110110
數(shù)字字面量可以出現(xiàn)下劃線
為了增強對數(shù)值的閱讀性，如我們經(jīng)常把數(shù)據(jù)用逗號分隔一樣。JDK7提供了_對數(shù)據(jù)分隔。
例:intx=100_1000;
注意事項:
不能出現(xiàn)在進制標識和數(shù)值之間
不能出現(xiàn)在數(shù)值開頭和結(jié)尾
不能出現(xiàn)在小數(shù)點旁邊
switch語句可以用字符串
泛型簡化
異常的多個catch合并
try-with-resources語句
try(必須是java.lang.AutoCloseable的子類對象){…}
好處:
資源自動釋放，不需要close()了
把需要關(guān)閉資源的部分都定義在這里就行了
主要是流體系的對象是這個接口的子類(JDK7的API)
27.23JDK8新特性_接口中也可以有方法例:
1 interface Inter 2 { 3 //抽象方法 4 public abstract void show(); 5 6 //default方法 7 public default void defaultPrint() 8 { 9 System.out.println("defaultPrint run");10 }11 12 //static方法13 public static void staticPrint()14 {15 System.out.println("staticPrint run");16 }17 }18 19 //實現(xiàn)類20 class InterImpl implements Inter21 {22 public void show()23 {24 System.out.println("重寫接口中的方法");25 }26 }27 28 //測試類29 public class Demo30 {31 public static void main(String[] args) 32 {33 //Inter.defaultPrint(); //非靜態(tài)方法不能直接使用 34 Inter.staticPrint();35 36 Inter i = new InterImpl();37 i.defaultPrint();38 i.show();39 }40 }新聞熱點
疑難解答
