黑马程序员_java高薪部分(2)

最新推荐文章于 2014-06-28 13:26:36 发布

探哥

最新推荐文章于 2014-06-28 13:26:36 发布

阅读量345

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/dingtan1990/article/details/35559441

版权

java 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------

java 高薪部分

反射：

反射是在运行状态中，对于任意一个类（class文件），都能够知道这个类的所有属性和方法；对于任意一个对象，都只能都调用它的任意一个
方法和属性，这种动态获取的信息一级动态调用对象的方法的功能呢个称为java 的反射机制。

反射其实就是动态加载一个指定的类，并获取该类中的所有的内容。而且将字节码文件封装成对象，
并将字节码文件中的内容都封装成对象，这样便于操作这些成员。就是把JAVA类中的各种成分反射成为相应的JAVA类
简单说：反射技术可以对一个类进行解剖。

如果想要对指定名称的字节码文件进行加载

反射的好处：大大的增强了程序的扩展性。 
反射的基本步骤： 
1、获得Class对象，就是获取到指定的名称的字节码文件对象。 
2、实例化对象，获得类的属性、方法或构造函数。 
3、访问属性、调用方法、调用构造函数创建对象。

得到类的字节码文件相同，这三种方式。
1.Class cls1=类名.class 相对简单，还是需要明确类名
2.cls1.getclass();必须要明确具体的类，并创建对象
3.class.forName("完整的类名（带包名）");

9个预定义的Class实例对象。

Integer.class包装类的字节码
Integer.TYPE Integer中基本类型的字节码
int.class==Integer.TYPE

数组 
class.isPrimitive();
class.isArray();

只要在源程序中出现的类型，都有各自的Class实例对象，例如 int[] void 等等

创建类的对象
     String  name="com.dsa.类名";
     寻找该名称类文件，并加载进内存，并非产生class对象
     Class clazz=Class.forName(name);
     产生该类的对象
     Object obj=clazz.newInstance();
      得到某一个指定构造方法
     Constructor  constructor= Class.forName("").getConstructor(String.class);
     创建实例对象
          Object obj=constructor.newInstance("abc");

Constructor 构造方法：代表某个类中的一个构造方法。

     得到某个类中所有的构造方法
     Constructor  constructors[]= Class.forName("").getConstructors();; 

     得到某一个构造方法
     Constructor  constructor= Class.forName("").getConstructor(StringBuffer.class);


          Constructor  constructor= Class.getConstructor(StringBuffer.class);
     创建实例对象
          String str=(String) constructor.newInstance(new StringBUffer("abc"));
          调用获得的方法时要用到上面相同类型的实例对象

      Class.newInstance()方法：
           String obj=（String）Class.forName("java.lang.String").newInstance();
            先得到默认的构造方法，然后用该构造方法创建实例对象。

成员变量 Filed类 代表某个类中的一个成员变量

  对一个类进行反射。
  ReflectPoint  pt1=new ReflectPoint(3,5);
   Filed filedy=pt1.getclsss().getFiled("Y");//只代表哪个对象
   Filed filedy=pt1.getclsss().getDeclaredField("x")//获取对象不管是私有还是被保护的
    filedy.setAccessible(true);//设置可以访问，暴力反射
   filedy.get(pt1)//取出Y的值


 将字段中的b全变成a
  Field[] fields=obj.getClass().getFields();//获取全部对象 
   for(Field field :fields){
      if(field.getType()==String.class){//如果是字符串
          String oldValue = (String)field.get(obj);//获取字符串内容
          String newValue = oldValue.replace('b','a');将字符串内容替换
          field.set(obj,newValue);将新值赋给对象           

Method类 成员方法的反射。
   
    获取成员方法
   
    反射形式：
    Method  methodCharAt = String.class.getMethod("charAt"--方法名,int.class--这是参数类型，如果是空参函数则是 null);
     Object obj=clazz.newInstance();

          methodCharAt.invoke(str1,1);
  

数组的反射
    Class clazz=obj.getClass();
     if(clazz.isArray()){
     int len=array.getLength(obj);
     for(int i=0;i<len;I==){
             sopArray.get(obj,i))
      }   


  }
    

反射来获取泛型信息

通过指定对应的Class对象，程序可以获得该类里面所有的Field，不管该Field使用private 方法public。获得Field对象后都可以使用getType()来获取其类型。
Class<?> type = f.getType();//获得字段的类型
但此方法只对普通Field有效,若该Field有泛型修饰,则不能准确得到该Field的泛型参数,如Map<String,Integer>;
为了获得指定Field的泛型类型，我们采用：
Type gType = f.getGenericType();得到泛型类型
然后将Type对象强转为ParameterizedType,其表示增加泛型后的类型
Type getRawType()//返回被泛型限制的类型;
Type[]  getActualTypeArguments()//返回泛型参数类型;

利用反射来获取泛型的类型（泛型信息）
步骤：
获取当前类
获取目标字段
获取包含泛型类型的类型 getGenericType()
强转至子类ParameterizedType 	因为Type没有任何对应的方法
获得泛型真正的类型 getActualTypeArguments()

例子
package junereflect624;

import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.HashMap;
import java.util.Map;

public class GetGenericTypeDemo14 {
	Map<String,Integer> map = new HashMap<String,Integer>();
	
	public static void main(String[] args) throws Exception {
		Class c = GetGenericTypeDemo14.class;
		Field f = c.getDeclaredField("map");
		System.out.println(f);
		System.out.println(f.getName());//map
		
		// Class<?> getType()  返回一个 Class 对象，它标识了此 Field 对象所表示字段的声明类型。 
		Class cl = f.getType();
		System.out.println("获得其类型："+cl);
//获得其类型：interface java.util.Map
		
		/**
		 *  Type getGenericType() 返回一个 Type 对象，它表示此 Field 对象所表示字段的声明类型。 
		 *  Type是Class的接口;
		 */
		Type t = f.getGenericType();//包含泛型的类型
		System.out.println(t);
//java.util.Map<java.lang.String, java.lang.Integer>
		

		/**
		 * Type这个类里面没有任何的方法，所以需要调用子类的方法，那么大的类型转到小的类型，需要强转！
		 */
		ParameterizedType pt = (ParameterizedType)t;//强转到其子类
		/**
		 *  Type[] getActualTypeArguments() 
			          返回表示此类型实际类型参数的 Type对象的数组。 
			 Type getOwnerType() 
			          返回 Type 对象，表示此类型是其成员之一的类型。 
			 Type getRawType() 
			          返回 Type 对象，表示声明此类型的类或接口。 
		 */
		
		t = pt.getRawType();//类型的类或接口
		System.out.println(t);
		
		Type[] ts = pt.getActualTypeArguments();
		for (Type type : ts) {
			System.out.println(type);
			/**
			 *  class java.lang.String
			    class java.lang.Integer
			 */
		}
	}
}

打印：
java.util.Map junereflect624.GetGenericTypeDemo14.map
map
获得其类型：interface java.util.Map
java.util.Map<java.lang.String, java.lang.Integer>
interface java.util.Map
class java.lang.String
class java.lang.Integer

我的总结：多查找api，参考api中方法使用的限制，比如是否静态、返回值类型等。


JavaBean与内省
内省：IntroSpector
·JavaBean是一种特殊的Java类，主要用于传递数据信息，这种java类中的方法主要用于访问私有的字段，且方法名符合某种命名规则。


·如果要在两个模块之间传递多个信息，可以将这些信息封装到一个JavaBean中，这种JavaBean的实例对象通常称之为值对象（Value Object，简称VO）。这些信息在类中用私有字段来存储，如果读取或设置这些字段的值，则需要通过一些相应的方法来访问。


·JavaBean的属性是根据其中的setter和getter方法来确定的，而不是根据其中的成员变量。如果方法名为setId，中文意思即为设置id，至于你把它存到哪个变量上，则不用管。如果方法名为getId，中文意思即为获取id，至于你从哪个变量上取，也不用管。去掉set前缀，剩余部分就是属性名，如果剩余部分的第二个字母是小写的，则把剩余部分的首字母改成小的。
例如：
setId()的属性名：id
isLast()的属性名：last
setCPU的属性名：CPU
getUPS的属性名：UPS
总之，一个类被当作javaBean使用时，JavaBean的属性是根据方法名推断出来的，它根本看不到java类内部的成员变量。

·一个符合JavaBean特点的类可以当作普通类一样进行使用，但把它当JavaBean用肯定需要带来一些额外的好处，我们才会去了解和应用JavaBean！
好处如下：
1-在Java EE开发中，经常要使用到JavaBean。很多环境就要求按JavaBean方式进行操作。
2-JDK中提供了对JavaBean进行操作的一些API，这套API就称为内省。如果要你自己去通过getX方法来访问私有的x，怎么做，有一定难度吧？用内省这套api操作JavaBean比用普通类的方式更方便。


2. 对JavaBean的简单内省操作
通过内省的方式对ReflectPoint对象中的成员变量进行读写操作。
示例：
ReflectTest.java
package com.itheima.day1;


public class ReflectPoint {
       private int x ;
       private int y ;
      
       public ReflectPoint(int x, int y) {
             super();
             this.x = x;
             this.y = y;
      }


      public int getX() {
             return x ;
      }


       public void setX(int x) {
             this.x = x;
      }


       public int getY() {
             return y ;
      }


       public void setY(int y) {
             this.y = y;
      }
}

ReflectTest.javapackage com.itheima.day1;


import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;


public class ReflectTest {


       public static void main(String[] args) throws Exception {
         ReflectPoint pt1 = new ReflectPoint(3, 5);
        
         String propertyName = "x";
         PropertyDescriptor pd1 = new PropertyDescriptor(propertyName, pt1.getClass());
         Method readMethod = pd1.getReadMethod();
         Object retVal = readMethod.invoke(pt1);
         System. out.println(retVal);
         //结果：3
        
         PropertyDescriptor pd2 = new PropertyDescriptor(propertyName, pt1.getClass());
         Method writeMethod = pd2.getWriteMethod();
         Object value = 7;
         writeMethod.invoke(pt1,value);
         System. out.println(pt1.getX());
         //结果：7
       }
}

类加载器
类加载器：就是加载类的工具。

JAVA虚拟机中可以安装多个类加载器，系统默认三个主要的类加载器，每个类负责加载特定位置的类。
 BootStrap-------ExtClassLoader------AppClassLoader classpath指定的类加载器
    父级              子集               子子集
类加载器也是JAVA类，因为其他是JAVA类的类加载器背身也要被类加载其加载。显然必须有第一个类加载器不是jAVA类，这正是BootStrap；所以类加载器
是用BootStrap加载的。
Java虚拟机中的所有类装载器采用具有父子关系的树形结构进行组织，在实例化每个类装载器对象时，需要为其指定一个父级类装载器对象或者默认采用系统类装载器为其父级类加载。 


类名.class.getClassLoader().getClass().getname();获取类加载器名称。

类加载器的委托机制：
当Java虚拟机要加载一个类时，到底派出哪个类加载器去加载呢？
首先当前线程的类加载器去加载线程中的第一个类。
如果类A中引用了类B，Java虚拟机将使用加载类A的类装载器来加载类B。 
还可以直接调用ClassLoader.loadClass()方法来指定某个类加载器去加载某个类。
每个类加载器加载类时，又先委托给其上级类加载器。

类加载器是类的加载工具，主要有三种类加载器 一种是BootStrap  一种是ExtClassLoader  一种是 AppClassLoader 
自定义类加载器：
   首先，类加载器必须要继承ClassLoader。 覆盖findClss



代理类
程序中的代理：要为已存在的多个具有相同接口的目标类的各个方法增加一些系统功能，例如:异常处理、日志、计算方法的运行时间、事务管理、等等。

代理类要调用目标类的功能。
目标类  doSomeThing(){
        业务功能代码
            }
代理类  doSomeThing(){
          //前置系统功能代码
           目标对象.doSomeThing()
          //后置系统功能代码   
         }




动态代理的工作原理：

1）Client(客户端)调用代理，代理的构造方法接受一个InvocationHandler，client调用代理的各个方法，代理的各个方法请求转发给刚才通过构造方法传入的handler对象，又把各请求分发给目标的相应的方法。就是将handler封装起来，其中this引用了当前的放(发来什么请求就接受哪个方法)。
猜想分析动态生成的类的内部代码：
1、动态生成的类实现了Collection接口（可以实现若干接口），生成的类有Collection接口中的所有方法和一个如下接受InvocationHandler参数的构造方法。
2、构造方法接受一个InvocationHandler对象，接受对象了要干什么用呢？该方法内部的代码会是怎样的呢？
实现Collection接口的动态类中的各个方法的代码又是怎样的呢？InvocationHandler接口中定义的invoke方法接受的三个参数又是什么意思？图解说明如下：

分析为什么动态类的实例对象的getClass()方法返回了正确结果呢？
为何动态类的实例对象的getClass()方法返回了正确结果，而没调用invoke方法：
因为代理类从Object上继承了许多方法，其中只对三个方法（hashCode、equals和toString）进行开发，委托给handler去自行处理，对于它身上其他方法不会交给代理类去实现，所以对于getClass()方法，还是由Object本身实现的。即proxy3.getClass()，该是什么结果还是什么结果，并不会交给invoke方法处理。


自定义代理类的步骤：
方式1：
             获得动态代理类的字节码文件
		Class claz=Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);
		//通过反射获得该动态代理类的构造方法
		Constructor c=claz.getConstructor(InvocationHandler.class);
	     //编写一个InvocationHandler类
		class myInvocationHandler implements InvocationHandler{

			@Override
			public Object invoke(Object proxy, Method method, Object[] args)
					throws Throwable {
				// TODO Auto-generated method stub
				return null;
			}
			
		}
		//创建实例，接受一个invocationhandler对象
		c.newInstance(new myInvocationHandler());

方式2，newProxyInstance这个方法需要三个参数，可以直接创建target的代理对象          Object proxy3 = Proxy.newProxyInstance(  
                target.getClass().getClassLoader(),  
                /*new Class[]{Collection.class},*/  
                  
                //获取target上的接口  
                target.getClass().getInterfaces(),  
                new InvocationHandler(){  
                  
                    public Object invoke(Object proxy, Method method, Object[] args)  
                            throws Throwable {  
  
                        /*long beginTime = System.currentTimeMillis();  
                        Object retVal = method.invoke(target, args);  
                        long endTime = System.currentTimeMillis();  
                        System.out.println(method.getName() + " running time of " + (endTime - beginTime));  
                        return retVal;*/  
                          
                        //把上边的代码封装到一个类中，让后调用该类的方法，就实现了方法的封装  
                        advice.beforeMethod(method);  
                        Object retVal = method.invoke(target, args);  
                        advice.afterMethod(method);  
                        return retVal;                        
                          
                    }  
                }  
                );  
        return proxy3;  
    }  
  
}