Num27反射，jdk新特性（傳智視頻）
獲取class文件對象的三種方式java
package cn.itcast_01;
/*
* 反射：就是經過class文件對象，去使用該文件中的成員變量，構造方法，成員方法。
*
* Person p = new Person();
* p.使用
*
* 要想這樣使用，首先你必須獲得class文件對象，其實也就是獲得Class類的對象。
* Class類：
* 成員變量 Field
* 構造方法 Constructor
* 成員方法 Method
*
* 獲取class文件對象的方式：
* A:Object類的getClass()方法
* B:數據類型的靜態屬性class
* C:Class類中的靜態方法
* public static Class forName(String className)
*
* 通常咱們到底使用誰呢?
* A:本身玩 任選一種，第二種比較方便
* B:開發 第三種
* 爲何呢?由於第三種是一個字符串，而不是一個具體的類名。這樣咱們就能夠把這樣的字符串配置到配置文件中。
*/
public class ReflectDemo {
public static void main(String[] args) throws ClassNotFoundException {
// 方式1
Person p = new Person();
Class c = p.getClass();
Person p2 = new Person();
Class c2 = p2.getClass();
System.out.println(p == p2);// false
System.out.println(c == c2);// true
// 方式2
Class c3 = Person.class;
// int.class;
// String.class;
System.out.println(c == c3);
// 方式3
// ClassNotFoundException
Class c4 = Class.forName("cn.itcast_01.Person");
System.out.println(c == c4);
}
}
經過反射獲取無參構造方法並使用
ide
package cn.itcast_02;
import java.lang.reflect.Constructor;
import cn.itcast_01.Person;
/*
* 經過反射獲取構造方法並使用。
*/
public class ReflectDemo {
public static void main(String[] args) throws Exception {
// 獲取字節碼文件對象
Class c = Class.forName("cn.itcast_01.Person");
// 獲取構造方法
// public Constructor[] getConstructors():全部公共構造方法
// public Constructor[] getDeclaredConstructors():全部構造方法
// Constructor[] cons = c.getDeclaredConstructors();
// for (Constructor con : cons) {
// System.out.println(con);
// }
// 獲取單個構造方法
// public Constructor<T> getConstructor(Class<?>... parameterTypes)
// 參數表示的是：你要獲取的構造方法的構造參數個數及數據類型的class字節碼文件對象
Constructor con = c.getConstructor();// 返回的是構造方法對象
// Person p = new Person();
// System.out.println(p);
// public T newInstance(Object... initargs)
// 使用此 Constructor 對象表示的構造方法來建立該構造方法的聲明類的新實例，並用指定的初始化參數初始化該實例。
Object obj = con.newInstance();
System.out.println(obj);
// Person p = (Person)obj;
// p.show();
}
}
經過反射獲取私有構造方法並使用
測試
package cn.itcast_02;
import java.lang.reflect.Constructor;
/*
* 需求：經過反射去獲取該構造方法並使用：
* public Person(String name, int age, String address)
*
* Person p = new Person("林青霞",27,"北京");
* System.out.println(p);
*/
public class ReflectDemo2 {
public static void main(String[] args) throws Exception {
// 獲取字節碼文件對象
Class c = Class.forName("cn.itcast_01.Person");
// 獲取帶參構造方法對象
// public Constructor<T> getConstructor(Class<?>... parameterTypes)
Constructor con = c.getConstructor(String.class, int.class,
String.class);
// 經過帶參構造方法對象建立對象
// public T newInstance(Object... initargs)
Object obj = con.newInstance("林青霞", 27, "北京");
System.out.println(obj);
}
}
經過反射獲取私有構造方法並使用
this
package cn.itcast_02;
import java.lang.reflect.Constructor;
/*
* 需求：經過反射獲取私有構造方法並使用
* private Person(String name){}
*
* Person p = new Person("風清揚");
* System.out.println(p);
*/
public class ReflectDemo3 {
public static void main(String[] args) throws Exception {
// 獲取字節碼文件對象
Class c = Class.forName("cn.itcast_01.Person");
// 獲取私有構造方法對象
// NoSuchMethodException：每一個這個方法異常
// 緣由是一開始咱們使用的方法只能獲取公共的，下面這種方式就能夠了。
Constructor con = c.getDeclaredConstructor(String.class);
// 用該私有構造方法建立對象
// IllegalAccessException:非法的訪問異常。
// 暴力訪問
con.setAccessible(true);// 值爲true則指示反射的對象在使用時應該取消Java語言訪問檢查。
Object obj = con.newInstance("風清揚");
System.out.println(obj);
}
}
經過反射獲取成員變量並使用
代理
package cn.itcast_03;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
/*
* 經過發生獲取成員變量並使用
*/
public class ReflectDemo {
public static void main(String[] args) throws Exception {
// 獲取字節碼文件對象
Class c = Class.forName("cn.itcast_01.Person");
// 獲取全部的成員變量
// Field[] fields = c.getFields();
// Field[] fields = c.getDeclaredFields();
// for (Field field : fields) {
// System.out.println(field);
// }
/*
* Person p = new Person(); p.address = "北京"; System.out.println(p);
*/
// 經過無參構造方法建立對象
Constructor con = c.getConstructor();
Object obj = con.newInstance();
System.out.println(obj);
// 獲取單個的成員變量
// 獲取address並對其賦值
Field addressField = c.getField("address");
// public void set(Object obj,Object value)
// 將指定對象變量上此 Field 對象表示的字段設置爲指定的新值。
addressField.set(obj, "北京"); // 給obj對象的addressField字段設置值爲"北京"
System.out.println(obj);
// 獲取name並對其賦值
// NoSuchFieldException
Field nameField = c.getDeclaredField("name");
// IllegalAccessException
nameField.setAccessible(true);
nameField.set(obj, "林青霞");
System.out.println(obj);
// 獲取age並對其賦值
Field ageField = c.getDeclaredField("age");
ageField.setAccessible(true);
ageField.set(obj, 27);
System.out.println(obj);
}
}
經過反射獲取無參無返回值成員方法並使用
日誌
package cn.itcast_04;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
public class ReflectDemo {
public static void main(String[] args) throws Exception {
// 獲取字節碼文件對象
Class c = Class.forName("cn.itcast_01.Person");
// 獲取全部的方法
// Method[] methods = c.getMethods(); // 獲取本身的包括父親的公共方法
// Method[] methods = c.getDeclaredMethods(); // 獲取本身的全部的方法
// for (Method method : methods) {
// System.out.println(method);
// }
Constructor con = c.getConstructor();
Object obj = con.newInstance();
/*
* Person p = new Person(); p.show();
*/
// 獲取單個方法並使用
// public void show()
// public Method getMethod(String name,Class<?>... parameterTypes)
// 第一個參數表示的方法名，第二個參數表示的是方法的參數的class類型
Method m1 = c.getMethod("show");
// obj.m1(); // 錯誤
// public Object invoke(Object obj,Object... args)
// 返回值是Object接收,第一個參數表示對象是誰，第二參數表示調用該方法的實際參數
m1.invoke(obj); // 調用obj對象的m1方法
System.out.println("----------");
// public void method(String s)
Method m2 = c.getMethod("method", String.class);
m2.invoke(obj, "hello");
System.out.println("----------");
// public String getString(String s, int i)
Method m3 = c.getMethod("getString", String.class, int.class);
Object objString = m3.invoke(obj, "hello", 100);
System.out.println(objString);
// String s = (String)m3.invoke(obj, "hello",100);
// System.out.println(s);
System.out.println("----------");
// private void function()
Method m4 = c.getDeclaredMethod("function");
m4.setAccessible(true);
m4.invoke(obj);
}
}
經過反射運行配置文件內容
code
package cn.itcast.test;
public class Student {
public void love() {
System.out.println("愛生活,愛Java");
}
}
package cn.itcast.test;
public class Teacher {
public void love() {
System.out.println("愛生活,愛青霞");
}
}
package cn.itcast.test;
public class Worker {
public void love() {
System.out.println("愛生活,愛老婆");
}
}
package cn.itcast.test;
import java.io.FileReader;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.Properties;
/*
* 經過配置文件運行類中的方法
*
* 反射：
* 須要有配置文件配合使用。
* 用class.txt代替。
* 而且你知道有兩個鍵。
* className
* methodName
*/
public class Test {
public static void main(String[] args) throws Exception {
// 反射前的作法
// Student s = new Student();
// s.love();
// Teacher t = new Teacher();
// t.love();
// Worker w = new Worker();
// w.love();
// 反射後的作法
// 加載鍵值對數據
Properties prop = new Properties();
FileReader fr = new FileReader("class.txt");
prop.load(fr);
fr.close();
// 獲取數據
String className = prop.getProperty("className");
String methodName = prop.getProperty("methodName");
// 反射
Class c = Class.forName(className);
Constructor con = c.getConstructor();
Object obj = con.newInstance();
// 調用方法
Method m = c.getMethod(methodName);
m.invoke(obj);
}
}
className = shezhi.Teacher methodName = love
經過反射越過泛型檢查
對象
package cn.itcast.test;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
/*
* 我給你ArrayList<Integer>的一個對象，我想在這個集合中添加一個字符串數據，如何實現呢？
*/
public class ArrayListDemo {
public static void main(String[] args) throws NoSuchMethodException,
SecurityException, IllegalAccessException,
IllegalArgumentException, InvocationTargetException {
// 建立集合對象
ArrayList<Integer> array = new ArrayList<Integer>();
// array.add("hello");
// array.add(10);
Class c = array.getClass(); // 集合ArrayList的class文件對象
Method m = c.getMethod("add", Object.class);
m.invoke(array, "hello"); // 調用array的add方法，傳入的值是hello
m.invoke(array, "world");
m.invoke(array, "java");
System.out.println(array);
}
}
經過反射寫一個通用的設置某個對象的某個屬性爲指定的值
接口
package cn.itcast.test;
import java.lang.reflect.Field;
public class Tool {
public void setProperty(Object obj, String propertyName, Object value)
throws NoSuchFieldException, SecurityException,
IllegalArgumentException, IllegalAccessException {
// 根據對象獲取字節碼文件對象
Class c = obj.getClass();
// 獲取該對象的propertyName成員變量
Field field = c.getDeclaredField(propertyName);
// 取消訪問檢查
field.setAccessible(true);
// 給對象的成員變量賦值爲指定的值
field.set(obj, value);
}
}
package cn.itcast.test;
public class ToolDemo {
public static void main(String[] args) throws NoSuchFieldException,
SecurityException, IllegalArgumentException, IllegalAccessException {
Person p = new Person();
Tool t = new Tool();
t.setProperty(p, "name", "林青霞");
t.setProperty(p, "age", 27);
System.out.println(p);
System.out.println("-----------");
Dog d = new Dog();
t.setProperty(d, "sex", '男');
t.setProperty(d, "price", 12.34f);
System.out.println(d);
}
}
class Dog {
char sex;
float price;
@Override
public String toString() {
return sex + "---" + price;
}
}
class Person {
private String name;
public int age;
@Override
public String toString() {
return name + "---" + age;
}
}
動態代理的概述和實現
開發
package cn.itcast_06;
public interface StudentDao {
public abstract void login();
public abstract void regist();
}
package cn.itcast_06;
public class StudentDaoImpl implements StudentDao {
@Override
public void login() {
System.out.println("登陸功能");
}
@Override
public void regist() {
System.out.println("註冊功能");
}
}
package cn.itcast_06;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class MyInvocationHandler implements InvocationHandler {
private Object target; // 目標對象
public MyInvocationHandler(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.out.println("權限校驗");
Object result = method.invoke(target, args);
System.out.println("日誌記錄");
return result; // 返回的是代理對象
}
}
package cn.itcast_06;
import java.lang.reflect.Proxy;
public class Test {
public static void main(String[] args) {
UserDao ud = new UserDaoImpl();
ud.add();
ud.delete();
ud.update();
ud.find();
System.out.println("-----------");
// 咱們要建立一個動態代理對象
// Proxy類中有一個方法能夠建立動態代理對象
// public static Object newProxyInstance(ClassLoader loader,Class<?>[]
// interfaces,InvocationHandler h)
// 我準備對ud對象作一個代理對象
MyInvocationHandler handler = new MyInvocationHandler(ud);
UserDao proxy = (UserDao) Proxy.newProxyInstance(ud.getClass()
.getClassLoader(), ud.getClass().getInterfaces(), handler);
proxy.add();
proxy.delete();
proxy.update();
proxy.find();
System.out.println("-----------");
StudentDao sd = new StudentDaoImpl();
MyInvocationHandler handler2 = new MyInvocationHandler(sd);
StudentDao proxy2 = (StudentDao) Proxy.newProxyInstance(sd.getClass()
.getClassLoader(), sd.getClass().getInterfaces(), handler2);
proxy2.login();
proxy2.regist();
}
}
jdk5新特性 經過enum實現枚舉類
package cn.itcast_02;
/*
* 經過JDK5提供的枚舉來作枚舉類
*/
public enum Direction {
FRONT, BEHIND, LEFT, RIGHT;
}
package cn.itcast_02;
/*
* 經過JDK5提供的枚舉來作枚舉類
*/
public enum Direction2 {
FRONT("前"), BEHIND("後"), LEFT("左"), RIGHT("右");
private String name;
private Direction2(String name) {
this.name = name;
}
public String getName() {
return name;
}
// @Override
// public String toString() {
// return "我愛林青霞";
// }
}
package cn.itcast_02;
/*
* 經過JDK5提供的枚舉來作枚舉類
*/
public enum Direction3 {
FRONT("前") {
@Override
public void show() {
System.out.println("前");
}
},
BEHIND("後") {
@Override
public void show() {
System.out.println("後");
}
},
LEFT("左") {
@Override
public void show() {
System.out.println("左");
}
},
RIGHT("右") {
@Override
public void show() {
System.out.println("右");
}
};
private String name;
private Direction3(String name) {
this.name = name;
}
public String getName() {
return name;
}
public abstract void show();
}
package cn.itcast_02;
public class DirectionDemo {
public static void main(String[] args) {
Direction d = Direction.FRONT;
System.out.println(d); // FRONT
// public String toString()返回枚舉常量的名稱，它包含在聲明中。
System.out.println("-------------");
Direction2 d2 = Direction2.FRONT;
System.out.println(d2);
System.out.println(d2.getName());
System.out.println("-------------");
Direction3 d3 = Direction3.FRONT;
System.out.println(d3);
System.out.println(d3.getName());
d3.show();
System.out.println("--------------");
Direction3 dd = Direction3.FRONT;
dd = Direction3.LEFT;
switch (dd) {
case FRONT:
System.out.println("你選擇了前");
break;
case BEHIND:
System.out.println("你選擇了後");
break;
case LEFT:
System.out.println("你選擇了左");
break;
case RIGHT:
System.out.println("你選擇了右");
break;
}
}
}
枚舉類的常見方法
package cn.itcast_02;
public class EnumMethodDemo {
public static void main(String[] args) {
// int compareTo(E o)
Direction2 d21 = Direction2.FRONT;
Direction2 d22 = Direction2.BEHIND;
Direction2 d23 = Direction2.LEFT;
Direction2 d24 = Direction2.RIGHT;
System.out.println(d21.compareTo(d21));
System.out.println(d21.compareTo(d24));
System.out.println(d24.compareTo(d21));
System.out.println("---------------");
// String name()
System.out.println(d21.name());
System.out.println(d22.name());
System.out.println(d23.name());
System.out.println(d24.name());
System.out.println("--------------");
// int ordinal()
System.out.println(d21.ordinal());
System.out.println(d22.ordinal());
System.out.println(d23.ordinal());
System.out.println(d24.ordinal());
System.out.println("--------------");
// String toString()
System.out.println(d21.toString());
System.out.println(d22.toString());
System.out.println(d23.toString());
System.out.println(d24.toString());
System.out.println("--------------");
// <T> T valueOf(Class<T> type,String name)
Direction2 d = Enum.valueOf(Direction2.class, "FRONT");
System.out.println(d.getName());
System.out.println("----------------");
// values()
// 此方法雖然在JDK文檔中查找不到，但每一個枚舉類都具備該方法，它遍歷枚舉類的全部枚舉值很是方便
Direction2[] dirs = Direction2.values();
for (Direction2 d2 : dirs) {
System.out.println(d2);
System.out.println(d2.getName());
}
}
}
jdk7 的六個新特性
package cn.itcast_03;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
public class Demo {
public static void main(String[] args) {
// 二進制字面量
int x = 0b100101;
System.out.println(x);
// 數字字面量能夠出現下劃線
int y = 1_1123_1000;
// 不能出如今進制標識和數值之間
int z = 0x111_222;
// 不能出如今數值開頭和結尾
int a = 0x11_22;
// 不能出如今小數點旁邊
double d = 12.3_4;
// switch 語句能夠用字符串?本身回顧
// 泛型簡化
ArrayList<String> array = new ArrayList<>();
// 異常的多個catch合併
method();
}
private static void method() {
// try-with-resources 語句
// try(必須是java.lang.AutoCloseable的子類對象){…}
try {
FileReader fr = new FileReader("a.txt");
FileWriter fw = new FileWriter("b.txt");
int ch = 0;
while ((ch = fr.read()) != -1) {
fw.write(ch);
}
fw.close();
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
// 改進版的代碼
try (FileReader fr = new FileReader("a.txt");
FileWriter fw = new FileWriter("b.txt");) {
int ch = 0;
while ((ch = fr.read()) != -1) {
fw.write(ch);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
jdk8 新特性 接口也能夠有方法
interface Inter
{
//抽象方法
public abstract void show();
//default方法
public default void defaultPrint()
{
System.out.println("defaultPrint 我愛林青霞");
}
//static方法
public static void staticPrint()
{
System.out.println("staticPrint 我愛林青霞");
}
}
//實現類
class InterImpl implements Inter
{
public void show()
{
System.out.println("重寫接口中的方法");
}
}
//測試類
public class Demo01
{
public static void main(String[] args)
{
//Inter.defaultPrint(); //非靜態方法不能直接使用
Inter.staticPrint();
Inter i = new InterImpl();
i.defaultPrint();
i.show();
}
}
相關文章
- 1. JDK5.0新特性 （二）反射
- 2. jdk5.0新特性—— 反射
- 3. JAVASE-註解+反射+內部類+socket+JDK新特性
- 4. Java編程基礎28——反射&JDK新特性
- 5. HTML5新特性——視頻
- 6. JDK新特性
- 7. 趙雅智_Java JDK 5.0 新特性
- 8. H5新特性（視頻和音頻）
- 9. 反射和特性學習
- 10. php高級特性-反射
- 更多相關文章...
- • C# 反射（Reflection） - C#教程
- • PHP 7 新特性 - PHP教程
- • Flink 數據傳輸及反壓詳解
- • JDK13 GA發佈：5大特性解讀
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. JDK5.0新特性 （二）反射
- 2. jdk5.0新特性—— 反射
- 3. JAVASE-註解+反射+內部類+socket+JDK新特性
- 4. Java編程基礎28——反射&JDK新特性
- 5. HTML5新特性——視頻
- 6. JDK新特性
- 7. 趙雅智_Java JDK 5.0 新特性
- 8. H5新特性（視頻和音頻）
- 9. 反射和特性學習
- 10. php高級特性-反射