黑马程序员_高新技术

最新推荐文章于 2015-06-02 02:07:39 发布

Sunny_365

最新推荐文章于 2015-06-02 02:07:39 发布

阅读量573

点赞数

本文链接：https://blog.csdn.net/Sunny_365/article/details/8742271

版权

------- android培训、java培训、期待与您交流！ ----------

装箱拆箱

public class AutoBox {
	/**
	 * @param args
	 * 享元模式  flyweight
	 * 如果很多很小的对象有很多相同的东西，就可把他们变成一个对象，然后把不同的东西作为外部属性，作为办法的参数传入，相同的属性叫做对象的内部状态
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Integer iObj=3;//装箱
		System.out.println(iObj+12);//拆箱
		Integer i1=137;
		Integer i2=137;
		//-128-127
	}

静态导入

import static java.lang.Math.*;//静态导入
public class StaticImport {
	public static void main(String[] args)
	{
		System.out.println(max(3,6));
		System.out.println(abs(2-5));
	}
}

反射

Class类

1、Java程序中的各个类属于同一类事物，描述这类事物的Java类名就是Class。

2、Class类代表Java类，它的各个实例对象又分别对应什么呢？

对应各个类在内存中的字节码。

3、如何得到各个字节码对应的实例对象（Class类型）

类名.class，例如：System.class

对象.getClass()，例如：new Date.getClass()

Class.forName("类名")，例如：Class.forName("java.util.Date")

4、数组类型的Class实例对象：Class.isArray()

反射

1、反射就是把Java类中的各个成分映射成相应的java类。

2、Constructor类代表某个类中的一个构造方法

得到某个类所有的构造方法：

例子：Constructor [] constructors=Class.forName("java.lang.String").getConstructors();

得到某一个构造方法：

例子：Constructor constructor=Class.forName("java.lang.String").getConstructor(StringBuffer.class);

创建实例对象：

通常方式：String str=new String(new StringBuffer("abc"));

反射方式：String str=(String)constructor.newInstance(new StringBuffer("abc"));

3、Field类代表某个类中的一个成员变量

4、Method类代表某个类中的一个成员方法

得到类中的某个方法：Method charAt=Class.forName("java,lang,String").getMethod("charAt",int.class);

调用方法：

通常方式：str.charAt(1);

反射方式：charAt.invoke(str,1);

jdk1.4和jdk1.5的invoke方法的区别：

jdk1.5：public Object invoke(Object obj,Object...args)

jdk1.4：public Object invoke(Object obj,Object[] args)

import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Arrays;
public class ReflectTest {
	public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
		String str1="abc";
		Class cls1=str1.getClass();
		Class cls2=String.class;
		Class cls3=Class.forName("java.lang.String");
		System.out.println(cls1==cls2);//true
		System.out.println(cls1==cls3);//true
		
		System.out.println(cls1.isPrimitive());//false,是否是基本类型的字节码
		System.out.println(int.class.isPrimitive());//true
		System.out.println(int.class==Integer.class);//false
		System.out.println(int.class==Integer.TYPE);//true
		System.out.println(int[].class.isPrimitive());//false
		System.out.println(int[].class.isArray());//false
		//new String(new StringBuffer("abc"));
		Constructor constructor1=String.class.getConstructor(StringBuffer.class);
		String str2=(String)constructor1.newInstance(new StringBuffer("abc"));
		System.out.println(str2.charAt(2));
		ReflectPoint pt1=new ReflectPoint(3,5);
		Field fieldy=pt1.getClass().getField("y");
		System.out.println(fieldy.get(pt1));
		Field fieldx=pt1.getClass().getDeclaredField("x");//获取私有变量x
		fieldx.setAccessible(true);//暴力反射	
		System.out.println(fieldx.get(pt1));
		changStringValue(pt1);
		System.out.println(pt1);
		//str1.charAt(1);
		Method methodCharAt=String.class.getMethod("charAt", int.class);
		System.out.println(methodCharAt.invoke(str1, 1));
		//按1.4的语法调用
		System.out.println(methodCharAt.invoke(str1, new Object[] {2}));
		//TestArguments.main(new String[]{"111","222","333"});
		String startingClassName=args[0];
		Method mainMethod=Class.forName(startingClassName).getMethod("main", String[].class);
		//mainMethod.invoke(null, (Object)new String[]{"111","222","333"});
		mainMethod.invoke(null, new Object[]{new String[]{"111","222","333"}});
		int[] a1=new int[]{1,2,3};
		int[] a2=new int[4];
		int[] [] a3=new int[2][3];
		String[] a4=new String[]{"a","b","c"};
		System.out.println(a1.getClass()==a2.getClass());
		System.out.println(a1.getClass().getName());
		System.out.println(a1.getClass().getSuperclass().getName());
		System.out.println(a4.getClass().getSuperclass().getName());
		Object aObj1=a1;
		Object aObj2=a4;
		Object[] aObj4=a3;
		Object[] aObj5=a4;
		System.out.println(a1);
		System.out.println(a4);
		System.out.println(Arrays.asList(a1));
		System.out.println(Arrays.asList(a4));
		printObject(a4);
		printObject("xyz");
	}
	public static void printObject(Object obj)
	{
		Class clazz=obj.getClass();
		if(clazz.isArray()){
			int len=Array.getLength(obj);
			for(int i=0;i<len;i++)
			{
				System.out.println(Array.get(obj, 1));
			}
		}else{
			System.out.println(obj);
		}
	}
	private static void changStringValue(Object obj) throws Exception
	{
		Field[] fields=obj.getClass().getFields();
		for(Field field:fields)
		{
			if(field.getType()==String.class)
			{
				String oldValue=(String)field.get(obj);
				String newVale=oldValue.replace('b','a');
				field.set(obj, newVale);
			}
		}
	}
	
}
class TestArguments{
	public static void main(String[] args)
	{
		for(String arg : args)
		{
			System.out.println(arg);
		}
	}
}

JavaBean

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

import java.beans.IntrospectionException;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;
public class IntroSpectorText {
       public staticvoid main(String[] args) throws Exception {
              // TODO Auto-generated method stub
              ReflectPoint pt1=new ReflectPoint(3,5);
              String propertyName="x";
              PropertyDescriptor pd=newPropertyDescriptor(propertyName,pt1.getClass());
              Method methodGetX=pd.getReadMethod();
              Object reVal=methodGetX.invoke(pt1);            
              Method methodSetX=pd.getWriteMethod();
              methodSetX.invoke(pt1, 7);
              System.out.println(pt1.getX());
              /*
               *BeanInfo beanInfo=Introspector.getBeanInfo(pt1.getClass());
               *PropertyDescripter[] pds=beanInfo.getPropertyDescriptors();
               *Object reVal=null;
               *for(PropertyDexcriptor pd:pds){
               *   if(pd.getName.equals(propertyName))
               *   {
               *          MethodmethodGetX=pd.getReadMethod();
               *          reVal=methodGetX.invoke(pt1);
               *          break;
               *    }
               *}
               *return retVal;
               **/
       }
}

注解

注解相当于一种标记，在程序中加了注解就等于为程序打上了某种标记，没加，则等于没有某种标记，以后javac编译器，开发工具和其他程序可以用反射来了解你的类及各种元素上有无何种标记，看你有什么标记，就去干相应的事。标记可以加载包，类，字段，方法，方法的参数以及局部变量上。

类加载器

Java虚拟机中可以安装多个类加载器，系统默认三个主要类加载器，每个类负责加载特定位置的类：BootStrap，ExtClassLoader，AppClassLoader。

类加载器也是Java类，因为他是java类的类加载器本身也要被类加载器加载，显然必须有第一个类加载器不是java类，这正是BootStrap。

类加载器的委托机制

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

import java.io.*;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Properties;
public class ReflectText2 {
       public staticvoid main(String[] args) throws Exception {
              // TODO Auto-generated method stub          
              //加载配置文件
              //InputStream ips=newFileInputStream("config.propertites");
              //类加载器
              //InputStreamips=ReflectText2.class.getClassLoader().getResourceAsStream("com/sunna/config.propertites");
              InputStreamips=ReflectText2.class.getResourceAsStream("config.propertites");
              //定义Properties对象
              Properties props=new Properties();
              props.load(ips);
              ips.close();
              StringclassName=props.getProperty("className");
              Collectioncollections=(Collection)Class.forName(className).newInstance();
              //Collection collections=newArrayList();//输出4
              //Collection collections=new HashSet();//输出3
              ReflectPoint pt1=new ReflectPoint(3,3);
              ReflectPoint pt2=new ReflectPoint(5,5);
              ReflectPoint pt3=new ReflectPoint(3,3);
              collections.add(pt1);
              collections.add(pt2);
              collections.add(pt3);
              collections.add(pt1);
              //pt1.y=7;
              //collections.remove(pt1);//改了对象值就取不走了，会内存泄露
              System.out.println(collections.size());
       }
}

代理

程序中的代理要为已存在的多个具有相同接口的目标类的各个方法增加一些系统功能，例如，异常处理、日志、计算方法的运行时间、事务管理、等等。
系统中存在交叉业务，交叉业务的编程问题即为面向方面的编程（Aspect oriented program，简称AOP），AOP的目标就是要使交叉业务模块化。

importjava.lang.reflect.*;
importjava.util.ArrayList;
importjava.util.Collection; 
public class ProxyText {
       public static void main(String[] args) throws Exception {
              // TODOAuto-generated method stub
              ClassclazzProxy1=Proxy.getProxyClass(Collection.class.getClassLoader(),Collection.class);
              System.out.println(clazzProxy1.getName());//类名，输出结果com.sun.proxy.$Proxy0           
              System.out.println("---begingconstructors list---");
              Constructor[]constructors=clazzProxy1.getConstructors();
              for(Constructorconstructor : constructors)
              {
                     String name=constructor.getName();
                     StringBuilder sBuilder=newStringBuilder(name);
                     sBuilder.append('(');
                     Class[]clazzParams=constructor.getParameterTypes();
                     for(Class clazzParam:clazzParams){
                            sBuilder.append(clazzParam.getName()).append(',');
                     }
                     if(clazzParams!=null&&clazzParams.length!=0)
                     sBuilder.deleteCharAt(sBuilder.length()-1);
                     sBuilder.append(')');
                     System.out.println(sBuilder.toString());
              }            
              System.out.println("---begingmethods list---");
              Method[]methods=clazzProxy1.getMethods();
              for(Method method: methods)
              {
                     String name=method.getName();
                     StringBuilder sBuilder=newStringBuilder(name);
                     sBuilder.append('(');
                     Class[]clazzParams=method.getParameterTypes();
                     for(Class clazzParam:clazzParams){
                            sBuilder.append(clazzParam.getName()).append(',');
                     }
                     if(clazzParams!=null&&clazzParams.length!=0)
                     sBuilder.deleteCharAt(sBuilder.length()-1);
                     sBuilder.append(')');
                     System.out.println(sBuilder.toString());
              }              
              System.out.println("---begingcreate instance object---");
              Constructorconstructor=clazzProxy1.getConstructor(InvocationHandler.class);
              classMyInvocationHandler1 implements InvocationHandler{
                     @Override
                     public Object invoke(Object arg0, Methodarg1, Object[] arg2)
                                   throws Throwable {
                            //TODO Auto-generated method stub
                            returnnull;
                     }                   
              }
              Collectionproxy1=(Collection)constructor.newInstance(new MyInvocationHandler1());
              System.out.println(proxy1);//null
              proxy1.clear();//null
              //proxy1.size();//报错
              Collectionproxy2=(Collection)constructor.newInstance(new InvocationHandler(){
                     @Override
                     public Object invoke(Object proxy, Methodmethod, Object[] args)
                                   throws Throwable {
                            //TODO Auto-generated method stub
                            returnnull;
                     }                    
              });
              final Objecttarget=new ArrayList();
              Collection proxy3= (Collection)getProxy(target,new MyAdvice());
              proxy3.add("zxx");
              proxy3.add("lhm");
              proxy3.add("bxd");
              System.out.println(proxy3.size());
       }
//将目标抽取成了一个参数
       private static Object getProxy(final Object target,finalAdvice advice) {
              //final Objecttarget=new ArrayList();
              Objectproxy3=Proxy.newProxyInstance(
                            target.getClass().getClassLoader(),
                            /*newClass[]{Collection.class}, */
                            target.getClass().getInterfaces(),
                            newInvocationHandler(){                               
                                   public Object invoke(Object proxy, Methodmethod, Object[] args)
                                                 throws Throwable {                                                                                 
                                          advice.beforeMethod(method);
                                          ObjectretVal= method.invoke(target,args);
                                          advice.afterMethod(method);                                       
                                          returnretVal;
                                   }
                            }
                            );
              return proxy3;
       } 
}