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高级特性-反射