Java反射课堂笔记

JavaSE基础_类加载器和反射
|---类加载器
|---反射
|---动态代理

1.类的加载
当程序要使用某个类时,如果该类还未被加载到内存中,则系统会通过加载,连接,初始化三步来实现对这个类进行初始化.
加载
>就是指将class文件读入内存,并为之创建一个Class对象.
>任何类被使用时系统都会创建一个Class对象.
连接
>验证 是否有正确的内部结构,并和其他类协调一致.
>准备 负责味蕾的静态成员分配内存,并设置默认初始化值.
>解析 将类的二进制数据中的符号引用替换为直接引用
初始化 就是我们将过的初始化步骤


1.1 类的初始化时机
>创建类的实例
>访问类的静态变量,或者额为静态变量赋值
>调用类的静态方法
>使用反射方式来强制创建某个类或接口对应的java.lang.Class对象.
>初始化某个类的子类
>直接使用java.exe命令来运行某个主类
1.2 类加载器
负责将class文件加载到内存中,并为之生成对应的Classs对象.
虽然我们不需要关心类加载器机制,但是了解这个机制我们就能更好的理解程序的运行.
类加载器的组成:
>Bootstrap ClassLoader 根类加载器
>Extension ClassLoader 扩展类加载器
>System ClassLoader 系统类加载器
1.3 类加载器的作用
>Bootstrap ClassLoader 根类加载器
>>也被称为引导类加载器,负责java核心类的加载,比如System.String等,在JDK中JRE的lib目录下tr.jar文件中
>Extension ClassLoader 扩展类加载器
>>负责JRE的扩展目录中Jar包的加载.在JDK中JRE的lib目录下ext目录.
>System ClassLoader 系统类加载器
>>负责在JVM启动时加载来自java命令的class文件,以及classpath环境变量所指定的jar包和类路径.

2.反射
Java反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意一个方法和属性;这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制.
要想解剖一个类,而解剖使用的就是Class类中的方法,所以先要获取到每一个字节码文件对应的Class类型的对象.


反射就是通过使用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)


一般我们到底使用哪种方法获取class文件呢?
A:自己玩   任选一种, 第二种比较方便
B:开发     第三种
为什么呢?因为第三种是一个字符串,而不是一个具体的类名,这样我们就可以把这样的字符串配置到配置文件中.
=====================================================================================
//需求: 获取class文件对象的方式:
public class ReflectDemo{
public static void main(String[] args){
//方式1
Person p = new Person();
class c =P.getClass();

Person p2 = new Person();
Class c2 = p2.getClass();

System.out.println( p == p2);//flase
System.out.println( c == c2);//true


//方式2
Class　c3 = Person.class;
/*任意类型对象都可以调用class方法
int.class;
String.class;*/
System.out.println( c == c3);



//方式3(开发中使用)
Class c4 = Class.forName("cn.itcast_01.Person");
System.out.println(c == c4);
}
}
==================================================================================


public class Person{
//成员变量
private String name;
int age;
public String address;
//构造方法
public Person(){
}

Person(String name,int age){
this.name=name;
this.age =age;
}

private Person(String name){
this.name = name;
}

public Person(String name,int age,String address){
this.name = name;
this.age = age;
this.address = address;
}
//成员方法
public void show(){
System.out.println("show");
}

public void method(String s){
System.out.println("method"+s);
}

public String getString(String s ,int i){
return s+"---"+i;
}

private void function(){
System.out.println("function");
}

public String toString(){
return "Person [name="+name+",age="+age+",address="+address+"]";
}
}
===============================================================================
//通过反射获取成员变量并使用
package cn.itcast_03;
import java.lang.reflect.File;
public class ReflectDemo{
public static void main(String[] args){
//获取字节码文件对象
Class c = Class.forName("cn.itcast_01.Person");

//获取所有成员变量
Fields[] fields = c.getFields();//获取公共的成员变量
Fields[] fields = c.getDdeclaredFields();//获取含私有成员变量的所有成员变量;
for(Field filed : fields){
Syrtem.out.println(field);
/*
Person p = new Person();P.address = "北京";System.out.println(P);
*/

//通过无参构造方法创建对象
Constructor con = c.getConstructor();
Object obj = con.newInstance();

//获取单个的成员变量
//获取address并对其赋值
Fields addressField = c.getField("address");
addressField.set(Object obj, Object value)
//将指定对象变量上此Field 对象表示的字段设置为指定的新值.
addressField.set(obj,"北京"); //给obj的对象addressField字段设置值为"北京".
}

//获取name并对其赋值
//NoSuchFieldExcreption
Field nameField = c.getDeclaredField("name");
//IllegalAccessibleException
nameField.setAccessible(true);
name.Field.set(obj,"林青霞");
System.out.println(obj);

//获取age并对其赋值
Field ageField =c.getDeclaredField("age");
//public void set(Object obj,Object value);
//将指定对象变量上此Field对象表示的字段设置为指定的新值.
ageField.setAccessible(true);
addressField.set(obj,27);
System.out.println(obj);
}
}

====================================================================================
//通过反射获取构造方法并使用
pack cn.itcast_02;
import java.lang.reflect.Contstructor;

public class ReflectDemo{
public Static void main(String[] args){
//获取字节码文件对象 (字符串配置到配置文件)
Class c  = Class.forName("cn.itcast.01_Person");
/*
//获取构造方法
//public Constructor[] getConstructor():所有公共构造方法
//public Constructor[] getDeclaredConstructors():所有构造方法
//Constructor[] cons = c.getConstruction();
Constructor[] cons = c.getDeclaredConstructors();
//增强For遍历对象
for(Constructor c : cons){
System.out.println(con);
}
*/
   //获取单个构造方法.
//public Constructor getConstructor(class...parameteTypse)
//参数表示的是:你要获取的构造方法的构造参数个数及数据类型的class字节码文件对象.
Constructor con = c.getConstructor(); //返回的是构造方法对象

//效果相当于 Person P = new Person();
//public T newInstance (Object...initarges)
//使用此Constructor 对象表示的构造方法来创建该构造方法的声明类的新实例,并用指定的初始化参数初始化实例.
Object obj = con.newInstance();
System.out.println(obj);

//效果相当于 Person p = (Person)obj; 在反射是不允许出现任何类的信息.
//p.show();
}
//需求:通过反射获取构造方法并使用
/*public Person(String name,int age,String address)
Preson p = new Person("林青霞",27,"北京");
System.out.println(p);*/
package cn.itcast_02;
public class ReflectDemo2{
public static void main(String[] args){
//获取字节码文件对象
Class c = Class.forName("cn.itcast_01.Person");

//获取带参构造方法对象
//public Constructor getConstrctor (Class...parameterTypes)
Constructor con = c.getConstructor(String.class,int.class,String.class);

//通过带构造方法对象创建对象
public T newInstace(Object...initarge)
Object obj = con.newInstance(林青霞",27,"北京市朝阳区CBD");
System.out.println(obj);
}
}
//需求:通过反射获取私有构造方法并使用
/*
private Person(String name){
this.name = name;
}
public void setName(String s){
this.name = name;
}
public String getName(){
return name;
}

person p = new Person("风清扬");
System.out.println(P);
*/
package cn.itcast_02;
import java.lang.reflect.Constructor;
public class ReflectDemo3{
public static void main(String[] args){
//获取字节码文件对象
Class c = Class.forName("cn.itcast_01.Person");

//获取私有构造方法对象 Constructor (构造器:获取构造方法)
/*constrcutor con = c.getConstructor(String.class);
在获取私有构造方法的时候会报错:NoSuchMethodException(没有这个对象异常)
原因是:getConstructor只能获取公共的构造方法,不能获取私有构造方法,所有会报错.
方法:getDeclaredConstructor()就可以获取私有构造方法.
*/
Constructor con = c.getDeclaredConstructor(String.class); 

//用该私有构造方法创建对象
//IllegalAccessException:非法的访问异常. 
/*
  解决SetGet访问替代方法:con.setAccessible()
con.setAccessible(ture);//值为ture,则表示反射的对象在使用时应取消java语言访问检查. flase则是设定java语言访问权限.
*/
Object obj = con.newInstance("风清扬");
System.out.println(obj);
}
}
加密方法: 1.异或同一个变量两次.  2.Constructor.setAccessible(flase or ture);
====================================================================================
//通过反射获取无参无返回值成员方法并使用
package cn.intcast_04
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);

//模拟: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方法

Syetem.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.getMthod("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() 调用私有成员方法
Metheod m4 = c.getDeclaredMethod("function");
m4.setAccessible(true);
m4.invoke(obj);
}
}
}
=====================================================================================

反射应用举例
//反射前的做法
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;
public class Test{
public static void main(String[] args){

//Student s = new Student();
//s.love();

//Teacher t = new Teacher();
//t.love();

//Worker w = new Worker();
//w.love();

}
}
================================================================================
应用案例:
//通过配置文件运行类中的方法
反射:
需要有配置文件配合使用.在执行过程中动态的加载配置文件名称就可以直接操作类的所有操作.
用class.txt代替 
并且你知道有两个键
className    className = ??? (cn.itcast.)   
methodName   methodName = ???(方法)
//反射后的做法
public class Test{
public static void main(String[] args)throws Exception{
//加载键值对数据
propertirse prop = new Properties();
FileReadeer fr = new FileReadrer("class.txt");
prop.load(fr);
fr.colse();
//获取数据  //根据键获取值
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);
}
}
--------------------------------------------------------------------------
//通过反射越过泛型检查
package cn.itcast.test
import java.util.ArrayList;
// 我给你的ArrayList的一个对象,在这个集合中添加一个字符串数据,如何实现?
pubic class ArrayListDemo{
public static void main(String[] args)throws Exception{
//创建集合对象
ArrayList array = new ArrayList();

//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);
}

}
==================================================================
测试题:
写一个方法public void setProperty(Object obj,String PropertyName,Object value){},
此方法可将obj对象中的名为propertyName的属性的值设置为value.

package cn.itcast.test;
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){
Person p = new Person();

Tool t = new Tool();
t.setProperty(p,"name","林青霞");
t.setProprtty(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 Person{
private String name;
public int age;

public String toString(){
return name+"----"+age;
}
}

class Dog{
char sex;
float price;

public String toString(){
return sex+"----"+price;
}
}


==================================================================
/*用户操作接口案例*/

//用户接口类(含增删改查四个抽象方法)
package cn.itcast_05;
public class UserDao{
public abstract void add();
public abstract void delete();
public abstract void update();
public abstract void find();
}
--------------------------------------
package cn.itcast_05;
public class UserDaoImpl implements UserDao{
public void add(){
System.out.println("添加功能");
}
public void delete(){
System.out.println("删除功能");
}
public void update(){
System.out.println("修改功能");
}
public void find(){
System.out.println("查找功能");
}
}
=====================================================
//测试类
package cn.itcast_05
public class UserDaoDemo{
public static void main(String[] args){
//基本的用户操作
UserDao ud = new UserDaoImpl();
ud.add();
ud.delete();
ud.update();
ud.find();
System.out.println("--------------");
//在真实的用户需求:
1.在每个操作执行前:应该看看操作者是否有权限进行这个操作.
2.谁操作的这个东西,你得给我留下记录.
//代码的开闭原则:对修改关闭,对扩展开放;
UserDao ud2 = new UserDaoImpl2();
ud2.add();
ud2.delete();
ud2.update();
ud2.find();
//假如我还有一个学生类,也具备这样的操作;
//假如我还有一个老师类,也具备这样的操作;
system.out.println("--------------------");
Studentdao sd = new StudentDaoImpl();
sd.login();
sd.regist(); 
system.out.println("--------------------");
//在真实的用户需求:
1.在每个操作执行前:应该看看操作者是否有权限进行这个操作.
2.谁操作的这个东西,你得给我留下记录.
Studentdao sd2 = new StudentDaoImpl();
sd2.login();
sd2.regist(); 
}
}
--------------------------------------------------
//扩展类 UserDao
package cn.itcast_05;
public class UserDao12 implements UserDao{
public void add(){
//权限校验代码部分省略,模拟操作
System.out.println("权限校验");
System.out.println("添加功能");
//日志记录代码部分省略.模拟操作
System.out.println("日志记录");
}

public void delete(){
//权限校验代码部分省略
System.out.println("权限校验");
System.out.println("删除功能");
//日志记录代码部分省略
System.out.println("日志记录");
}

public void update(){
//权限校验代码部分省略
System.out.println("权限校验");
System.out.println("修改功能");
//日志记录代码部分省略
System.out.println("日志记录");
}

public void find(){
//权限校验代码部分省略
System.out.println("权限校验");
System.out.println("查找功能");
//日志记录代码部分省略
System.out.println("日志记录");
}
}
-----------------------------------
实际操作:
//学生接口
package cn.itcast_05;
public interface StudentDao{
public abstract void login();
public abstract void regist();
}
//学生实现类
package cn.itcast_05;
public class StudentDaoImpl implements StudentDao{
public void login(){
System.out.println("登陆功能");
}
public void regist(){
System.out.println("注册功能");
}
}
//加入校验和记录
package cn.itcast_05;
public class StudentDaoImpl2 implements StudentDao{
public void login(){
System.out.println("权限校验");
System.out.println("登陆功能");
System.out.println("日志记录");
}
public void regist(){
System.out.println("权限校验");
System.out.println("注册功能");
System.out.println("日志记录");
}
}
=====================================================
3.动态代理
在java中java.lang.reflect包下提供了一个Proxy类和一个InvocationHandler接口,通过使用这个类和接口就可以生成动态代理对象.JDK提供的代理只能针对接口做代理.我们有更强大的代理cglibPrixy类中的方法创建动态代理类对象
public static Object newProxyInstance(ClassLoader loader,Class[] interfaces,invocationHandler h)最终会调用InvocationHandler的方法
InvocationHandler
  Object invoke(Object proxy,Method method.Object[] args)
Proxy类表示代理设置
中创建动态代理对象的方法的三个参数:
ClassLoader对象,定义了由哪个ClassLoader对象来对生成的代理对象进行加载;
Interface对象的数组,表示的是我将要给我需要代理的对象提供一组什么接口,如果我提供了一组接口给它,那么这个代理对象就宣称实现了该接口(多态),这样我就能调用这组接口的方法了.
package cn.itcast_06
public calss Test{
public static void main(String[] args){
UserDao ud = new UserDaoImpl();
ud.add();
ud.delete();
ud.update();
ud.find();
System.out.println("----------------");
//创建一个动态代理对象
MyInvocationHadler handler = new MyInvocationHadler(ud);
UserDao proxy = Proxy.newProxyInstance(ud.getClass().getClassLoader(),ud.getClass().getInstance(),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().getInterface(),handler2);
proxy2.login();
proxy2.regist();
}
}

package cn.itcast_06;
import java.lang.reflect.InvocationHandler;
import java.lang.,reflect.Method;
public clas MyInvocationHandler implements InvocationHandler{
private Object target;//目标对象

public MyInvocationHandler(Object target){
this.target = target;
}

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;//返回的是代理对象.
}
}

面向对象思想设计原则及常见设计模式
>面向对象思想设计原则
>设计模式
java中有23种设计模式,全部基于面向对象思想.设计模式就是一种解决问题的思想,用编程的手法,解决实际中的问题.
>设计模式的分类及常见的设计模式
创建型模式:
 (工厂模式)简单工厂模式和工厂方法模式(接口)
  建造模式
  原始模型模式
  单例设计模式(多线程)
结构性模式
  适配器(变压器)模式(GUI)
  桥梁模式
  合成模式
  装饰设计模式(IO流)
>装饰模式就是使用被装饰类的一个子类的实例,在客户端将这个子类的实例交给装饰类,是继承的替代方案.
>优点:使用装饰模式,可以提高比继承更灵活的扩展对象的功能,它可以动态的添加对象的功能,并且可以随意的组合这些功能.
>缺点:正因为可以随意组合,所有就可能出现一些不合理的逻辑.
手机案例:
定义手机设计规则(interface)---具体手机iphone(calss) 
 装饰(抽象类)实现手机规则(interfacw)
 >彩铃(给手机进行装饰)
 >听音乐(给手机进行装饰)
  门面模式
  亨元模式
  代理模式
行为模式
责任链模式
命令模式
解释器模式
迭代子模式
调停者模式
备忘录模式
观察者模式
状态模式
策略模式
模板方法设计模式(抽象类)==模式框架板块模式,然后在用内容填充.
>模板方法模式就是定义一个算法的骨架,而将具体的算法延迟到子类中来实现.
优点:使用模板方法模式,在定义算法骨架的同时,可以很灵活的实现具体的算法,满足用户灵活多变的需求
缺点:如果算法骨架有修该的话,则需要修改抽象类
访问者模式


===========================================
模板设计模式(抽象类)演示:
//需求:请给我计算出一段代码的运行时间
package cn.itcast_01
public class GetTimeDemo{
public Static void main(String[] args){
//GetTime gt = new GetTime();
//System.out.println(gt.getTime()+"毫秒");

//For循环操作时间 =For循环重写code()方法;
GetTime gt = new ForDemo();
System.out.println(ge);

//IO流操作的时间
gt = new IODemo();
System.out,println(gt.getTime()+"毫秒");
}
}



public calss GetTime{
public long gettime(){
long strat = System.currentTimeMillis();
/*计算for循环时间毫秒值
for(int x = 0 ;x < 10000;x++){
System.out.println(x);
}
long end = System.currentTimeMillis();
*/

//计算复制视频时间毫秒值
try{
BufferInputStream bis = new BufferedInputStream(new FileInputStream("a.avi"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStrea("b.avi"));
byte[] bytes = new byte[1024];
int len = 0;
while((len = bis.read(bys))!=-1){
bos.write(byte,0 ,len);
}
bos.close();
bis.close();
}catch(IOException e){
e.PrintStackTrace();
}
//再给我测试一个代码:集合操作的,多线程操作的,常用API操作的等等...
code();

long end = System.currentTimeMillis();
return end - strat;
}
public abstract void code();
}

//For循环继承GetTime 重写code()方法;
public class ForDemo extends GetTime{
public void code(){
for(int x = 0;x <10000;x++){
System.out.println(x);
}
}
}

//IO流复制继承GetTime.重写code()方法;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class IODemo extends GetTime{
public void code(){
try{
BufferInputStream bis = new BufferedInputStream(new FileInputStream("a.avi"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStrea("b.avi"));
byte[] bytes = new byte[1024];
int len = 0;
while((len = bis.read(bys))!=-1){
bos.write(byte,0 ,len);
}
bos.close();
bis.close();
}catch(IOException e){
e.PrintStackTrace();
}
}
}
===================================================================
装饰模式案例:
package cn.itcast_02
public interface　phone{
public abstract void call();
}

public calss IPhone implements Phone{
public void call(){
System.out.println("手机可以打电话了");
}
}

public class PhoneDemo{
public static void main(String[] args){
Phone p =new Iphone();
p.call();
System.out.println("-------------------------");
//需求:我想在接电话之前,听彩铃
PhoneDecorate pd = new RingPhoneDecorate(p);
pd.call();

//需求:我想要手机在接前听彩铃,接后听音乐.
//自己提供装饰类,在打电话前听彩铃,打电话后听音乐.
pd = new RingPhoneDecorate(new MusicPhoneDecorate(P));
pd.call();
system.out.println("--------------------");
//IO流中的使用
InputStream is = System.in;
InputStreamReader isr = new InputStreamReader(is);
BufferedReader br = new BufferedReader(isr);

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bw = new BufferedWriter(new InputStreamWriter(System.in));

//Scanner sc = new Scanner(System.in);


//需求:我想在接电话后,听音乐
pd = new MusicPhoneDecorate(p);
pd.call();
}
}

     ------------------------------------------------------

public class RingPhoneDecorate extends PhoneDecorat{
public RingPhoneDecorate(Phone p){
super(p);
}
public void call(){
System.out.println("手机可以听彩铃");
super.call();
}
}

public abstract calss PhoneDecorate implements Phone{
private Phone p;

public  PhoneDecorate(Phone p){
this.p = p;
}
public void call(){
this.p.call();
}
}
----------------------------
public calss MusicPhoneDecorate extends PhoneDecorate{
public MusicPhoneDecorate(Phone p){
super(p);
}
public void call(){
super.call();
System.out.println("手机可以听音乐");
}
}
==========================================================================