深入解析Java与Android开发技术-优快云博客

本文详细探讨了Java和Android开发领域的核心概念和技术，包括枚举、泛型、动态代理、注解以及多种编程实践。文章深入浅出地解释了如何在实际项目中应用这些技术，帮助开发者提升技能并解决常见问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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

总结：

枚举

枚举就是要让某个类型的变量的取值只能为若干个固定值中的一个，否则，编译器就会报错。枚举可以让编译器在

编译时就可以控制源程序中填写的非法值，普通变量的方式在开发阶段无法实现这一目标。

枚举就相当于一个类，其中也可以定义构造方法、成员变量、普通方法和抽象方法。

枚举元素必须位于枚举体中的最开始部分，枚举元素列表的后要有分号与其他成员分隔。

把枚举中的成员方法或变量等放在枚举元素的前面，编译器报告错误。

带构造方法的枚举构造方法必须定义成私有的如果有多个构造方法，该如何选择哪个构造方法？

枚举元素MON和MON（）的效果一样，都是调用默认的构造方法。带方法的枚举定义枚举TrafficLamp 实现

普通的next方法实现抽象的next方法：每个元素分别是由枚举类的子类来生成的实例对象，这些子类采用类似内部类的方

式进行定义。增加上表示时间的构造方法

可变参数

可变参数只能放在参数列表的最后

当做数组使用

反射

问：如果传递给Method对象的invoke()方法的第一个参数为null,这有着什么样的意义呢？

答：该Method对象对应的是一个静态方法接受数组参数的成员方法进行反射：

解决方法：

1.Method对象.invoke(null,Object[]{new String[]{"xxx"}});

2.Method对象.invoke(null,(Object)new String[]{"xxx"});

beanutils支持级联操作， BeanUtils.setproperty(先反射出来对象，对象的属性名称，值);

BeanUtils.setproperty(pt1，"birthday.time"，"111");

java7的新特性： Map map = (name:"zxx",age:"100");

BeanUtils是以字符串的形式对java进行操作 PropertyUtils是以属性本身的类型进行操作

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

类名.class，例如，System.class

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

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

九个预定义Class实例对象：

参看Class.isPrimitive方法的帮助

Int.class == Integer.TYPE

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

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

java注解

总结：注解相当于一种标记，在程序中加了注解就等于为程序打上了某种标记，没加，则等于没有某种标记，以后，

javac编译器，开发工具和其他程序可以用反射来了解你的类及各种元素上有无何种标记，看你有什么标记，就去干相应的

事。标记可以加在包，类，字段，方法，方法的参数以及局部变量上。看java.lang包，可看到JDK中提供的最基本的

annotation。

泛型

ArrayList<E>类定义和ArrayList<Integer>类引用中涉及如下术语：

整个称为ArrayList<E>泛型类型 ArrayList<E>中的E称为类型变量或类型参数

整个ArrayList<Integer>称为参数化的类型

ArrayList<Integer>中的Integer称为类型参数的实例或实际类型参数

ArrayList<Integer>中的<>念着typeof

ArrayList称为原始类型参数化类型不考虑类型参数的继承关系：

Vector<String> v = new Vector<Object>(); //错误!///不写<Object>没错，写了就是明知故犯

Vector<Object> v = new Vector<String>(); //也错误!

Vector v1 = new Vector<String>();//可以

Vector<Object> v = v1;//可以

总结：使用?通配符可以引用其他各种参数化的类型，

?通配符定义的变量主要用作引用，可以调用与参数化无关的方法，不能调用与参数化有关的方法。

限定通配符的上边界：

正确：Vector<? extends Number> x = new Vector<Integer>();

错误：Vector<? extends Number> x = new Vector<String>();

限定通配符的下边界：

正确：Vector<? super Integer> x = new Vector<Number>();

错误：Vector<? super Integer> x = new Vector<Byte>();

提示：限定通配符总是包括自己。 ?只能用作引用，不能用它去给其他变量赋值

Vector<? extends Number> y = new Vector<Integer>();

Vector<Number> x = y;

上面的代码错误，原理与Vector<Object > x11 = new Vector<String>();相似，只能通过强制类型转换方式来

赋值。

总结：基本数据类型都Number类型

注意：

1.在对泛型进行参数化时，类型参数的实例必须是引用类型，不能是基础类型。

2.当一个变量被声明为泛型时，只能被实例变量和方法调用（还有内嵌类型），而不能被静态变量和静态方法

调用。因为静态成员是被所以参数化的类所共享的，所以静态成员不应该有类级别的类型参数

注意：

1) public static void applyVector (Vector<Date> v1){ }

2) public static void applyVector(Vector<Integer> v1){ }

不是方法重载，因为它们的字节码是一样的

重点：

通过变量名称获取变量的泛型类型

方法：public static void applyVector (Vector<Date> v1){ }

步骤：

1)Method applyMethod = 类名.class.getMethod("applyVector"，Vector)；

2)Type[] types = applyMethod.getGenericParameterTypes();

3)ParameterizedType pType = (ParameterizedType)types[0];

4)syso("pType.getRawType()");//获取参数类型

5)syso(pType.getACtualTypeArguments()[0]); 方法中的内部函数要访问方法中的局部变量，该变量必

须加final

重点——动态代理：

package cn.itcast.day3;

import java.lang.reflect.Method;

public class MyAdvice implements Advice {
	long beginTime = 0;
	public void afterMethod(Method method) {
		// TODO Auto-generated method stub
		System.out.println("从传智播客毕业上班啦！");		
		long endTime = System.currentTimeMillis();
		System.out.println(method.getName() + " running time of " + (endTime - beginTime));

	}

	public void beforeMethod(Method method) {
		// TODO Auto-generated method stub
		System.out.println("到传智播客来学习啦！");
		beginTime = System.currentTimeMillis();
	}

}

package cn.itcast.day3;

import java.lang.reflect.Method;

public interface Advice {
	void beforeMethod(Method method);
	void afterMethod(Method method);
}

package cn.itcast.day3;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.Collection;

public class ProxyTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) throws Exception{
		// TODO Auto-generated method stub
		Class clazzProxy1 = Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);
		System.out.println(clazzProxy1.getName());
		
		System.out.println("----------begin constructors list----------");
		/*$Proxy0()
		$Proxy0(InvocationHandler,int)*/
		Constructor[] constructors = clazzProxy1.getConstructors();
		for(Constructor constructor : constructors){
			String name = constructor.getName();
			StringBuilder sBuilder = new StringBuilder(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("----------begin methods list----------");
		/*$Proxy0()
		$Proxy0(InvocationHandler,int)*/
		Method[] methods = clazzProxy1.getMethods();
		for(Method method : methods){
			String name = method.getName();
			StringBuilder sBuilder = new StringBuilder(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("----------begin create instance object----------");
		//Object obj = clazzProxy1.newInstance();
		Constructor constructor = clazzProxy1.getConstructor(InvocationHandler.class);
		class MyInvocationHander1 implements InvocationHandler{

			public Object invoke(Object proxy, Method method, Object[] args)
					throws Throwable {
				// TODO Auto-generated method stub
				return null;
			}
		
		}
		Collection proxy1 = (Collection)constructor.newInstance(new MyInvocationHander1());
		
		System.out.println(proxy1);
		proxy1.clear();
		//proxy1.size();
		//System.out.println("111111111111111");
		
		Collection proxy2 = (Collection)constructor.newInstance(new InvocationHandler(){

			public Object invoke(Object proxy, Method method, Object[] args)
					throws Throwable {
				return null;
			}
			
		});
		
		final ArrayList target = new ArrayList();			
		Collection proxy3 = (Collection)getProxy(target,new MyAdvice());
		proxy3.add("zxx");
		proxy3.add("lhm");
		proxy3.add("bxd");
		System.out.println(proxy3.size());
		System.out.println(proxy3.getClass().getName());
	}

	private static Object getProxy(final Object target,final Advice advice) {
		Object proxy3 = Proxy.newProxyInstance(
				target.getClass().getClassLoader(),
				/*new Class[]{Collection.class},*/
				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;
	}

}