黑马程序员--java技术--高新技术
2013-11-03 22:30
344 查看
------- android培训、java培训、期待与您交流！
----------
1-7.eclipse的基本使用
工程管理和快捷键配置
eclipse视图管理和程序调试
配置eclipse的编译与运行环境
在eclipse中配置java模板代码
在eclipse中导入已有的工程
8.静态导入
import :语句可以导入一个类或包中的所有类
import static ：语句导入一个类中的某个静态方法或所有静态方法
9.for循环增强
for(类型 变量：数组){}
10.自动装箱与拆箱及享元模式
1、自动装箱：
Integer num1 = 12;
2、自动拆箱：
System.out.println(num1 + 12);
3、基本数据类型的对象缓存：
Integer num1 = 12;
Integer num2 = 12; 这块相等，<=127都是真的
System.out.println(num1 == num2);
Integer num3 = 129; 这块不相等，因为是对象,Integer取值范围为：-128-127
Integer num4 = 129;
System.out.println(num3 == num4);
Integer num5 = Integer.valueOf(12);
Integer num6 = Integer.valueOf(12) ; 这块的道理同上
System.out.println(num5 == num6);
11_枚举的作用介绍
1、为什么要有枚举
问题：要定义星期几或性别的变量，该怎么定义？假设用1-7分别表示星期一到星期日，但有人可能会写成int weekday = 0;或即使使用常量方式也无法阻止意外。
枚举就是要让某个类型的变量的取值只能为若干个固定值中的一个，否则，编译器就会报错。枚举可以让编译器在编译时就可以控制源程序中填写的非法值，普通变量的方式在开发阶段无法实现这一目标。
12_用普通类模拟枚举的实现原理
用普通类如何实现枚举功能，定义一个Weekday的类来模拟枚举功能。
1.私有的构造方法
2.每个元素分别用一个公有的静态成员变量表示
3.可以有若干公有方法或抽象方法。采用抽象方法定义nextDay就将大量的if.else语句转移成了一个个独立的类。
13_Java5枚举的基本应用
枚举的基本应用
举例：定义一个Weekday的枚举。
扩展：枚举类的values,valueOf,name,toString,ordinal等方法
总结：枚举是一种特殊的类，其中的每个元素都是该类的一个实例对象，例如可以调用WeekDay.SUN.getClass().getName和WeekDay.class.getName()。
14_实现带有构造方法的枚举
枚举的高级应用
1、枚举就相当于一个类，其中也可以定义构造方法、成员变量、普通方法和抽象方法。
2、枚举元素必须位于枚举体中的最开始部分，枚举元素列表的后要有分号与其他成员分隔。把枚举中的成员方法或变量等放在枚举元素的前面，编译器报告错误。
3、带构造方法的枚举
1.构造方法必须定义成私有的
2.如果有多个构造方法，该如何选择哪个构造方法？
3.枚举元素MON和MON（）的效果一样，都是调用默认的构造方法。
4、带抽象方法的枚举
1.定义枚举TrafficLamp
2.实现普通的next方法
3.实现抽象的next方法：每个元素分别是由枚举类的子类来生成的实例对象，这些子类采用类似内部类的方式进行定义。
4.增加上表示时间的构造方法
5、枚举只有一个成员时，就可以作为一种单例的实现方式。
public class EnumTest {
public static void main(String[] args) {
WeekDay weekDay2 = WeekDay.FRI;
System.out.println(weekDay2);
}
public enum WeekDay{
SUN(1),MON(),TUE,WED,THI,FRI,SAT;
private WeekDay(){System.out.println("first");}//空参数类型的构造函数
private WeekDay(int day){System.out.println("second");}//带有参数类型的构造函数
}
}
15_实现带有抽象方法的枚举
import java.util.
public class EnumTest {
public static void main(String[]
new Date(300){};
}
//带有抽象方法的枚举——交通灯
public enum TrafficLamp{
RED(30){
public TrafficLamp nextLamp(){
return GREEN;
}
},
GREEN(45){
public TrafficLamp nextLamp(){
return YELLOW;
}
},
YELLOW(5){
public TrafficLamp nextLamp(){
return RED;
}
};
public abstract TrafficLamp nextLamp();
private int time;
private TrafficLamp(int time){
this.time = time;
}
}
}
16_透彻分析反射的基础_Class类
反射的基石-->Class类
1、 Java程序中的各个Java类属于同一类事物，描述这类事物的Java类名就是Class。
2、对比提问：众多的人用一个什么类表示？众多的Java类用一个什么类表示？
人Person
Java类Class
3、对比提问： Person类代表人，它的实例对象就是张三，李四这样一个个具体的人， Class类代表Java类，它的各个实例对象又分别对应什么呢？
1.对应各个类在内存中的字节码，例如，Person类的字节码，ArrayList类的字节码，等等。
2.一个类被类加载器加载到内存中，占用一片存储空间，这个空间里面的内容就是类的字节码，不同的类的字节码是不同的，所以它们在内存中的内容是不同的，这一个个的
4、如何得到各个字节码对应的实例对象（ Class类型）
1.类名.class，例如，System.class
2.对象.getClass()，例如，new Date().getClass()
3.Class.forName("类名")，例如，Class.forName("java.util.Date");
5、九个预定义Class实例对象：
分别是boolean、byte、char、short、int、long、float、double和void
参看Class.isPrimitive（判定指定的 Class 对象是否表示一个基本类型）方法的帮助
int.class == Integer.TYPE
6、数组类型的Class实例对象
Class.isArray()
总之，只要是在源程序中出现的类型，都有各自的Class实例对象，例如，int[]，void…
常见Class方法：
Class<?>[] getInterfaces() 获取自己实现的多个接口
Method getMethods() 获取自己所有的方法列表
String getName() 获取类名
Package getPackege() 获取自己所属的包
17_理解反射的概念
1、反射就是把Java类中的各种成分映射成相应的java类。例如，一个Java类中用一个Class类的对象来表示，一个类中的组成部分：成员变量，方法，构造方法，包等等信息也用一个个的Java类来表示，就像汽车是一个类，汽车中的发动机，变速箱等等也是一个个的类。表示java类的Class类显然要提供一系列的方法，来获得其中的变量，方法，构造方法，修饰符，包等信息，这些信息就是用相应类的实例对象来表示，它们是Field、Method、Contructor、Package等等。
2、一个类中的每个成员都可以用相应的反射API类的一个实例对象来表示，通过调用Class类的方法可以得到这些实例对象后，得到这些实例对象后有什么用呢？怎么用呢？这正是学习和应用反射的要点。
18_构造方法的反射应用
1、Constructor类代表某个类中的一个构造方法
2、得到某个类所有的构造方法：
例子：Constructor [] constructors=Class.forName("java.lang.String").getConstructors();
3、得到某一个构造方法：
例子：
Constructor constructor=Class.forName(“java.lang.String”).getConstructor(StringBuffer.class);//获得方法时要用到类型
4、创建实例对象：
1.通常方式：String str = new String(new StringBuffer("abc"));
2.反射方式： String str = (String)constructor.newInstance(new StringBuffer("abc"));
调用获得的方法时要用到上面相同类型的实例对象
Class.newInstance()方法：
例子：String obj =(String)Class.forName("java.lang.String").newInstance();
该方法内部先得到默认的构造方法，然后用该构造方法创建实例对象。
该方法内部的具体代码是怎样写的呢？用到了缓存机制来保存默认构造方法的实例对象。
import java.lang.reflect.Constructor;
public class ReflectTest {
public static void main(String[] args)throws Exception {
// TODO Auto-generated methodstub
//new String(new StringBuffer("abc"));
Constructor constructor1 = String.class.getConstructor(StringBuffer.class);//这里的StringBuffer是选择哪个构造方法
String str2 = (String)constructor1.newInstance(/*"abc"*/new StringBuffer("abc"));//这里的StringBuffer是指要用StringBuffer的时候必须传递一个StringBuffer进去
//这里编译器只知道constructor1是一个构造方法，但不知道是谁的构造方法，因此这里需要进行强制转换成String类型的即可。
System.out.println(str2.charAt(2));
}
}
19_成员变量的反射
1、Field类代表某个类中的一个成员变量
2、演示用eclipse自动生成Java类的构造方法
3、问题：得到的Field对象是对应到类上面的成员变量，还是对应到对象上的成员变量？类只有一个，而该类的实例对象有多个，如果是与对象关联，哪关联的是哪个对象呢？所以字段fieldX 代表的是x的定义，而不是具体的x变量。
快捷键：Alt + Shift + S -->产生想对应的构造方法Generate Constructor using Fields
20_成员变量反射的综合案例
需求：将任意一个对象中的所有String类型的成员变量所对应的字符串内容中的"b"改成"a"。
ReflectPoint.java 演示包：
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
public class ReflectTest {
public static void main(String[] args)throws Exception {
// TODO Auto-generated methodstub
changeStringValue(pt1);
System.out.println(pt1);
}
//反射综合案例，重点掌握
public static void changeStringValue(Object obj)throws Exception{
Field[] fields = obj.getClass().getFields();
for(Field field : fields){
//if(field.getType().equals(String.class)){
if(field.getType()/*获取自己的类型*/ == String.class){
//由于比较的是同一份字节码，因此这里只能用"=="而不能用equals进行比较
String oldValue = (String)field.get(obj);
String newValue = oldValue.replace('b','a');//将旧值替换成新值
field.set(obj,newValue);
}
}
}
}
21_成员方法的反射
1、Method类代表某个类中的一个成员方法
2、得到类中的某一个方法：
例子： Method charAt =Class.forName("java.lang.String").getMethod("charAt",int.class);
3、调用方法：
通常方式：System.out.println(str.charAt(1));
反射方式：System.out.println(charAt.invoke(str, 1));
如果传递给Method对象的invoke()方法的第一个参数为null，说明该Method对象对应的是一个静态方法！
4、jdk1.4和jdk1.5的invoke方法的区别：
Jdk1.5：public Object invoke(Object obj,Object... args)
Jdk1.4：public Object invoke(Object obj,Object[] args)，即按jdk1.4的语法，需要将一个数组作为参数传递给invoke方法时，数组中的每个元素分别对应被调用方法中的一个参数，所以，调用charAt方法的代码也可以用Jdk1.4改写为 charAt.invoke(“str”, new Object[]{1})形式。
面向对象：只要把对象变成私有private，如果谁要操作这个对象，那么这个方法就应该作用到谁的身上，专家模式。
22_对接收数组参数的成员方法进行反射
用反射方式执行某个类中的main方法
1、目标：
写一个程序，这个程序能够根据用户提供的类名，去执行该类中的main方法。用普通方式调完后，大家要明白为什么要用反射方式去调啊？
2、问题：
启动Java程序的main方法的参数是一个字符串数组，即public static voidmain(String[] args)，通过反射方式来调用这个main方法时，如何为invoke方法传递参数呢？按jdk1.5的语法，整个数组是一个参数，而按jdk1.4的语法，数组中的每个元素对应一个参数，当把一个字符串数组作为参数传递给invoke方法时，javac会到底按照哪种语法进行处理呢？jdk1.5肯定要兼容jdk1.4的语法，会按jdk1.4的语法进行处理，即把数组打散成为若干个单独的参数。所以，在给main方法传递参数时，不能使用代码mainMethod.invoke(null,newString[]{“xxx”})，javac只把它当作jdk1.4的语法进行理解，而不把它当作jdk1.5的语法解释，因此会出现参数类型不对的问题。
3、解决办法：
mainMethod.invoke(null,new Object[]{new String[]{"xxx"}});
mainMethod.invoke(null,(Object)new String[]{"xxx"}); ，编译器会作特殊处理，编译时不把参数当作数组看待，也就不会数组打散成若干个参数了
23_数组与Object的关系及其反射类型
数组的反射
1、具有相同维数和元素类型的数组属于同一个类型，即具有相同的Class实例对象(此处比较与值无关)。
2、代表数组的Class实例对象的getSuperClass()方法返回的父类为Object类对应的Class。
3、基本类型的一维数组可以被当作Object类型使用，不能当作Object[]类型使用；非基本类型的一维数组，既可以当做Object类型使用，又可以当做Object[]类型使用。
4、Arrays.asList()方法处理int[]和String[]时的差异。
5、Array工具类用于完成对数组的反射操作。
24_数组的反射应用
Array工具类用于完成对数组的反射操作
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 methodstub
printObject(a4);
printObject("xyz");
//获取数组中的元素类型
Object[] aa = new Object[]{"a",1};
System.out.println(aa[1].getClass().getName());
}
private static void printObject(Object obj) {
// TODO Auto-generated methodstub
Class clazz = obj.getClass();
if(clazz.isArray()){
for(int x=0; x<Array.getLength(obj); x++){
System.out.println(Array.get(obj, x));
}
}
else{
System.out.println(obj);
}
}
}
25_ArrayList、HashSet的比较以及Hashcode分析
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
public class ReflectTest2 {
public static void main(String[] args) {
// TODO Auto-generated methodstub
//Collection collections = new ArrayList();
Collection collections = newHashSet();
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);//内存泄露，这里的pt1是移除不掉的，因为其Hashcode地址值已变
System.out.println(collections.size());
}
}
public class ReflectPoint {
private int x;
public int y;
public ReflectPoint(int x,int y) {
super();
this.x = x;
this.y = y;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + x;
result = prime * result + y;
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() !=obj.getClass())
return false;
ReflectPoint other = (ReflectPoint) obj;
if (x != other.x)
return false;
if (y != other.y)
return false;
return true;
}
}
26_框架的概念以及用反射技术开发框架的原理
反射的作用-->实现框架功能
1、框架与框架要解决的核心问题
我做房子卖给用户住，由用户自己安装门窗和空调，我做的房子就是框架，用户需要使用我的框架，把门窗插入进我提供的框架中。框架与工具类有区别，工具类被用户的类调用，而框架则是调用用户提供的类。
2、框架要解决的核心问题
我在写框架（房子）时，你这个用户可能还在上小学，还不会写程序呢？我写的框架程序怎样能调用到你以后写的类（门窗）呢？
因为在写才程序时无法知道要被调用的类名，所以，在程序中无法直接new 某个类的实例对象了，而要用反射方式来做。
3、案例
1.先直接用new 语句创建ArrayList和HashSet的实例对象，演示用eclipse自动生成 ReflectPoint类的equals和hashcode方法，比较两个集合的运行结果差异。
2.然后改为采用配置文件加反射的方式创建ArrayList和HashSet的实例对象，比较观察运行结果差异。
3.引入了elipse对资源文件的管理方式的讲解。
import java.io.FileInputStream;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Properties;
public class ReflectTest3 {
public static void main(String[] args)throws Exception{
// TODO Auto-generated methodstub
InputStream ips = new FileInputStream("config.properties");
Properties props = new Properties();
props.load(ips);
ips.close();
String className = props.getProperty("className");
Collection collections = (Collection)Class.forName(className).newInstance();
//Collection collections = new ArrayList();
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);
System.out.println(collections.size());
}
}
config.properties文件:
className=java.util.HashSet
这里在建立config.properties文件时，需要在javaenhance工程上单击右键->新建File文件，而其自动生成的文件则在JRE文件目录下，因此可以避免其余错误
27_用类加载器的方法管理资源和配置文件
1.getRealPath();//金山词霸//内部
一定要记住用完整的路径，但完整的路径不是硬编码，而是运算出来的。
2.类加载器可以将.class文件加载到内存当中去
3.配置文件一定要放在classpath执行路径下
注意：配置文件一定要区分相对路径和绝对路径，否则很容易出错
29_由内省引出JavaBean的讲解
1、JavaBean是一种特殊的Java类，主要用于传递数据信息，这种java类中的方法主要用于访问私有的字段，且方法名符合某种命名规则。
2、如果要在两个模块之间传递多个信息，可以将这些信息封装到一个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用肯定需要带来一些额外的好处，我们才会去
3、了解和应用JavaBean！好处如下：
1.在Java EE开发中，经常要使用到JavaBean。很多环境就要求按JavaBean方式进行操作，别人都这么用和要求这么做，那你就没什么挑选的余地！
2.JDK中提供了对JavaBean进行操作的一些API，这套API就称为内省。如果要你自己去通过getX方法来访问私有的x，怎么做，有一定难度吧？用内省这套api操作JavaBean比用普通类的方式更方便。
InstroSpector:内省，检查视察的意思，主要对JavaBean进行操作，其中JavaBean是一个特殊的Java类
5、Age --> 如果第二个字母是小的，则把第一个字母变成小的-->age
例如：
gettime-->time setTime-->time getCPU-->CPU
30_对JavaBean的简单内省操作
import java.beans.IntrospectionException;
import java.beans.PropertyDescriptor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class IntroSpectorTest {
public static void main(String[] args)throws Exception {
ReflectPoint pt1 = new ReflectPoint(3,5);
String propertyName = "x";
ObjectretVal = getProperty(pt1,propertyName);
System.out.println(retVal);
Objectvalue = 7;
setProperties(pt1,propertyName, value);
System.out.println(pt1.getX());
}
//设置value的值
private static void setProperties(Objectpt1, String propertyName,
Object value) throws IntrospectionException,
IllegalAccessException,InvocationTargetException {
PropertyDescriptor pd2 = new PropertyDescriptor(propertyName,pt1.getClass());
Method methodSetX = pd2.getWriteMethod();
methodSetX.invoke(pt1, value);
}
private static Object getProperty(Object pt1, String propertyName)
throws IntrospectionException, IllegalAccessException,
InvocationTargetException{
PropertyDescriptor pd = new PropertyDescriptor(propertyName,pt1.getClass());
Method methodGetX = pd.getReadMethod();
ObjectretVal = methodGetX.invoke(pt1);
return retVal;
}
小结：从上例可以看出Java Bean的优势：可以通过PropertyDescriptor（属性描述器？）来创建对象，然后用 对象.getWriterMethod来获取写入的方法，然后再用invoke调用。这就是反射
31_使用BeanUtils工具包操作JavaBean
Bean工具包
1、演示用eclipse如何加入jar包，先只是引入beanutils包，等程序运行出错后再引入logging包。
2、在前面内省例子的基础上，用BeanUtils类先get原来设置好的属性，再将其set为一个新值。
get属性时返回的结果为字符串，set属性时可以接受任意类型的对象，通常使用字符串。
3、用PropertyUtils类先get原来设置好的属性，再将其set为一个新值。
get属性时返回的结果为该属性本来的类型，set属性时只接受该属性本来的类型。
4、演示去掉JavaBean（ReflectPoint）的public修饰符时，BeanUtils工具包访问javabean属性时出现的问题。
导入需要的jar包操作步骤：在javaenhance工程上单击鼠标右键-->New-->SourceFolder-->Floder Name:lib--.复制需要使用的jar包，直接粘贴到新建的lib目录下，然后将其增加到build path环境中：单击导入的jar包右键-->Build Path-->Add toBuild Path即可
在使用IntroSpectorTest.java的时候运用到了JavaUtils时，只导入commons-beanutils.jar包是不够的，而且会报错：org/apache/commons/logging/LogFactory，因此这里还需要按照导入beanutils jar包的方法导入logging包，并且添加到Build Path环境变量中
BeanUtils是以字符串的形式对JavaBean进行操作，而PropertyUtils则是对属性本身类型对JavaBean进行操作；如果需要类型转换，则使用BeanUtils，否则使用PropertyUtils
Map map = {name:"zxx",age:16};
BeanUtils.setProperty(map, "name", "lhm");*/
PropertyUtils.setProperty(pt1,"x", 9);
System.out.println(PropertyUtils.getProperty(pt1,"x").getClass().getName());
32_了解和入门注解的应用
了解注解及Java提供的几个基本注解
1、先通过@SuppressWarnings的应用让大家认识和了解一下注解：
通过System.runFinalizersOnExit(true);的编译警告引出@SuppressWarnings("deprecation")
2、@Deprecated
直接在刚才的类中增加一个方法，并加上@Deprecated标注，在另外一个类中调用这个方法。
3、@Override
public boolean equals(Reflect other)方法与HashSet结合讲解
常用几个注解
1.Deprecated value = RUNTIME
用@Deprecated特点注释的程序元素，不鼓励程序员使用这样的元素，通常是因为它很危险或存在更好的选择。在使用不被赞成的程序元素或在不被赞成的代码中执行重写时，编译器会发生
2.Override value = SOURCE
表示一个方法声明重写超类中的另个一方法声明。如果方法利用此注释类型进行注解但没有重写超类方法，则编译器会生成一条错误
3.SuppressWarnings value = SOURCE
指示应该注释元素（以及包含在该注释元素中的所有程序元素）中取消现实制定的编译器警告。注意，在给定元素中取消现实的警告集市所有包含元素中取消显示的警告的超集。例如，如果注释一个雷来取消显示某个警告，同事注释一个方法来取消显示另一个警告，那么僵在此方法中同时取消显示着两个警告。
public class AnnotationTest {
@SuppressWarnings("deprecation")
public static void main(String[] args) {
// TODO Auto-generated methodstub
System.runFinalizersOnExit(true);
sayHello();
}
//1.标记某个方法过时；
//2.子类覆盖父类
//3.压缩警告
@Deprecated //提示编译器说明下面这个方法过时，让调用这个方法的程序能够识别
public static void sayHello(){
System.out.println("hi,黑马程序员");
}
}
33_注解的定义与反射调用
注解的应用
1、注解类
@interface A{}
2、应用了“注解类”的类
@A
Class B{}
3、对“应用了注解类的类”进行反射操作的类
class C{
B.class.isAnnotionPresent(A.class);
A a = B.class.getAnnotion(A.class);
}
注解就相当于一个你的源程序中药调用的一个类，要在源程序中应用某个注解，得先准备好了这个注解类。就像你要调用某个类，得先有开发好了这个类。
自定义注解
根据反射测试的问题，引出@Retention元注解的讲解，其三种取值：
java源文件：RetetionPolicy.SOURCE、
class文件: RetetionPolicy.CLASS、
内存中的字节码: RetetionPolicy.RUNTIME;
其中，注解的默认阶段处在class文件阶段
注解里面的枚举：Java.lang.annotation Enum RetentionPolicy，其中该枚举有三个取值：CLASS：编译器将把注释记录在类文件中，但在运行时VM不需要保留注释。
RUNTIME：编译器将把注释记录在类文件中，在运行时VM将保留注释，因此可以反射性地读取。
SOURCE：编译器要丢弃的注释。
@ItheimaAnnotation
public class AnnotationTest {
@SuppressWarnings("deprecation")
@ItheimaAnnotation
public static void main(String[] args)throws Exception {
// TODO Auto-generated methodstub
System.runFinalizersOnExit(true);
sayHello();
if(AnnotationTest.class.isAnnotationPresent(ItheimaAnnotation.class)){
ItheimaAnnotation annotation = (ItheimaAnnotation)AnnotationTest.class.getAnnotation(ItheimaAnnotation.class);
System.out.println(annotation);
}
}
//1.标记某个方法过时；
//2.子类覆盖父类
//3.压缩警告
@Deprecated //提示编译器说明下面这个方法过时，让调用这个方法的程序能够识别
public static void sayHello(){
//System.out.println("hi,黑马程序员");
}
}
34_为注解添加各种属性
1、什么是注解的属性
一个注解相当于一个胸牌，如果你胸前贴了胸牌，就是传智播客的学生，否则，就不是。如果还想区分出是传智播客哪个班的学生，这时候可以为胸牌在增加一个属性来进行区分。加了属性的标记效果为：@MyAnnotation(color="red")
2、定义基本类型的属性和应用属性：
在注解类中增加String color();
@MyAnnotation(color="red")
3、用反射方式获得注解对应的实例对象后，再通过该对象调用属性对应的方法
MyAnnotation a =(MyAnnotation)AnnotationTest.class.getAnnotation(MyAnnotation.class);
System.out.println(a.color());
可以认为上面这个@MyAnnotation是MyAnnotaion类的一个实例对象
4、为属性指定缺省值：
String color()default "yellow";
5、value属性：
String value()default "zxx";
如果注解中有一个名称为value的属性，且你只想设置value属性（即其他属性都采用默认值或者你只有一个value属性），那么可以省略value=部分，例如：@MyAnnotation("lhm")。
@ItheimaAnnotation(annotationAttr=@MetaAnnotation("flx"), color="red",value="abc", arrayAttr={1,2,3} )
public class AnnotationTest {
@SuppressWarnings("deprecation")
@ItheimaAnnotation("xyz")
public static void main(String[] args)throws Exception {
// TODO Auto-generated methodstub
System.runFinalizersOnExit(true);
sayHello();
if(AnnotationTest.class.isAnnotationPresent(ItheimaAnnotation.class)){
ItheimaAnnotation annotation = (ItheimaAnnotation)AnnotationTest.class.getAnnotation(ItheimaAnnotation.class);
System.out.println(annotation.lamp().nextLamp().toString());
System.out.println(annotation.annotationAttr().value());
}
}
}
35_入门泛型的基本应用
import java.lang.reflect.Constructor;
import java.util.ArrayList;
public class GenericTest {
public static void main(String[] args)throws Exception{
// TODO Auto-generated methodstub
/*ArrayList collection = new ArrayList();
collection.add(1);
collection.add(1L);
collection.add("abc");
int i =(Integer)collection.get(1);*/
ArrayList<String>al = new ArrayList<String>();
al.add("abc");
al.add("bbb");
al.add("acd");
String element =al.get(2);
System.out.println(element);
Constructor<String>constructor1 = String.class.getConstructor(StringBuffer.class);//这里的StringBuffer是选择哪个构造方法
//将Constructor添加String类型的泛型后，后面的返回值前就不再需要将其强制转换成String类型了
String str2 =constructor1.newInstance(/*"abc"*/new StringBuffer("abc"));
System.out.println(str2.charAt(2));
}
}
36_泛型的内部原理及更深应用
泛型是提供给javac编译器使用的，可以限定集合中的输入类型，让编译器挡住源程序中的非法输入，编译器编译带类型说明的集合时会去除掉“类型”信息，使程序运行效率不受影响，对于参数化的泛型类型，getClass()方法的返回值和原始类型完全一样。由于编译生成的字节码会去掉泛型的类型信息，只要能跳过编译器，就可以往某个泛型集合中加入其它类型的数据，例如，用反射得到集合，再调用其add方法即可。
1、ArrayList<E>类定义和ArrayList<Integer>类引用中涉及如下术语：
1.整个称为ArrayList<E>泛型类型
2.ArrayList<E>中的E称为类型变量或类型参数
3.整个ArrayList<Integer>称为参数化的类型
4.ArrayList<Integer>中的Integer称为类型参数的实例或实际类型参数
5.ArrayList<Integer>中的<>念着typeof
6.ArrayList称为原始类型
2、参数化类型与原始类型的兼容性：
1.参数化类型可以引用一个原始类型的对象，编译报告警告，例如，
Collection<String> c = new Vector();//可不可以，不就是编译器一句话的事吗？
2.原始类型可以引用一个参数化类型的对象，编译报告警告，例如，
Collection c = new Vector<String>();//原来的方法接受一个集合参数，新的类型也要能传进去
3、参数化类型不考虑类型参数的继承关系：
Vector<String> v = new Vector<Object>(); //错误!
//不写<Object>没错，写了就是明知故犯
Vector<Object> v = new Vector<String>(); // 错误!
37_泛型的通配符扩展应用
1、使用?通配符可以引用其他各种参数化的类型，?通配符定义的变量主要用作引用，可以调用与参数化无关的方法，不能调用与参数化有关的方法。
2、限定通配符的上边界：
正确：Vector<? extends Number> x = new Vector<Integer>();
错误：Vector<? extends Number> x = new Vector<String>();
3、限定通配符的下边界：
正确：Vector<? super Integer> x = new Vector<Number>();
错误：Vector<? super Integer> x = new Vector<Byte>();
38_泛型集合的综合应用案例
HashMap<String,Integer> maps = new HashMap<String,Integer>();
maps.put("zxx", 28);
maps.put("lhm", 35);
maps.put("flx", 33);
Set<Map.Entry<String,Integer>>entrySet = maps.entrySet();
for(Map.Entry<String, Integer> entry :entrySet){
System.out.println(entry.getKey() +":" + entry.getValue());
}
39_自定义泛型方法及其应用
1、自定义泛型模板中，其函数结构相似，但类型不同，这里可以使用一个通用的方法，它可以适用于各种类型，例如：
template<classT>
Tadd(T x,T y){
return(T)(x+y);
}
其中，代码里面的T代表一种任意数据类型
2、Java中的泛型类型（或者泛型）类似于C++中的模板。但是这种相似性仅限于表面，Java语言中的泛型基本上完全是在编译器中实现，用于编译器执行类型检查和类型推断，然后生成普通的非凡行的字节码，这种实现技术成为擦除（erasure）（编译器使用泛型类型信息保证类型安全，然后再生成字节码之前将其清除）。这是因为扩展虚拟机指令集来支持泛型呗认为是无法接受的，这会为Java厂商升级其JVM造成难以逾越的障碍。所以，Java的泛型采用了可以完全在编译器中实现的擦除方法。
3、泛型中是如何处理异常的
publicstatic <T extends Exception> sayHello() throws T{
try{}
catch(Exception e){
throw (T)e;
}
}
其中：T必定是Exception的子类，然后在处理catch的时候，还是用Exception e而不能用T代替，最后将抛出的e降至转换成(T)这种类型即可；
40_自定义泛型方法的练习与类型推断总结
泛型方法的练习题
1、编写一个泛型方法，自动将Object类型的对象转换成其他类型。
classGenericTest{
public static voidmain(String[] args){
Object obj = “abc”;
String a =autoConvert(obj);
}
public static <T> TautoConvert(Object obj){
return (T)obj;
}
}
2、根据调用泛型方法时实际传递的参数类型或返回值的类型来推断，具体规则如下：
1.当某个类型变量只在整个参数列表中的所有参数和返回值中的一处被应用了，那么根据调用方法时该处的实际应用类型来确定，这很容易凭着感觉推断出来，即直接根据调用方法时传递的参数类型或返回值来决定泛型参数的类型，例如：
swap(new String[3],3,4) static <E> voidswap(E[] a, int i, int j)
2.当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型都对应同一种类型来确定，这很容易凭着感觉推断出来，例如：
add(3,5) static<T> T add(T a, T b)
3.当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型对应到了不同的类型，且没有使用返回值，这时候取多个参数中的最大交集类型，例如，下面语句实际对应的类型就是Number了，编译没问题，只是运行时出问题：
fill(new Integer[3],3.5f) static <T> void fill(T[] a, T v)
4.当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型对应到了不同的类型，并且使用返回值，这时候优先考虑返回值的类型，例如，下面语句实际对应的类型就是Integer了，编译将报告错误，将变量x的类型改为float，对比eclipse报告的错误提示，接着再将变量x类型改为Number，则没有了错误：
int x =(3,3.5f) static <T> T add(T a, T b)
5.参数类型的类型推断具有传递性，下面第一种情况推断实际参数类型为Object，编译没有问题，而第二种情况则根据参数化的Vector类实例将类型变量直接确定为String类型，编译将出现问题：
copy(newInteger[5],new String[5]) static <T> void copy(T[] a,T[] b);
copy(newVector<String>(), new Integer[5]) static <T> void copy(Collection<T> a , T[] b);
41_自定义泛型类的应用
1、如果类的实例对象中的多处都要用到同一个泛型参数，即这些地方引用的泛型类型要保持同一个实际类型时，这时候就要采用泛型类型的方式进行定义，也就是类级别的泛型，语法格式如下：
publicclass GenericDao<T> {
privateT field1;
publicvoid save(T obj){}
publicT getById(int id){}
}
2、类级别的泛型是根据引用该类名时指定的类型信息来参数化类型变量的，例如，如下两种方式都可以：
GenericDao<String> dao = null;
new genericDao<String>();
注意：
1.在对泛型类型进行参数化时，类型参数的实例必须是引用类型，不能是基本类型。
2.当一个变量被声明为泛型时，只能被实例变量、方法和内部类调用，而不能被静态变量和静态方法调用。因为静态成员是被所有参数化的类所共享的，所以静态成员不应该有类级别的类型参数。
import java.util.Set;
//dao--> Data Access Object:数据访问对象-->crud:create增、read检索、update改、delete删
public class GenericDao<T> {
//为了让程序里的T即返回值类型是统一的，如果只在方法上定义其返回值类型，最后得到的数据可能不是统一类型，
//因此这里可以将T返回值定义在类上，因此就能统一返回值类型，保证了数据的安全性
public void add(T x){ }
public T findById(int id){
return null;
}
public void delete(T obj){
}
public void delete(int id){
}
public void update(T obj){
}
public TfindByUserName(String name){
return null;
}
public Set<T> findByConditions(String where){
return null;
}
}
42_通过反射获得泛型的实际类型参数
class GenericTest{
public static void main(String[] args){
//以泛型的方式得到实际类型的参数
//Vector<Data> v1 = new Vector<Date>();
Method applyMethod =GenericTest.class.getMethod("applyVector", Vector.class);
Type[] types =applyMethod.getGenericParameterTypes();//获取参数值类型
ParameterizedType pType= (ParameterizedType)types[0];
System.out.println(pType.getRawType());
System.out.println(pType.getActualTypeArguments());
}
public static void applyVector(Vector<Date> v1){
}
43_类加载器及其委托机制的深入分析
1、Java虚拟机中可以安装多个类加载器，系统默认三个主要类加载器，每个类负责加载特定位置的类：BootStrap,ExtClassLoader,AppClassLoader
2、类加载器也是Java类，因为其他是java类的类加载器本身也要被类加载器加载，显然必须有第一个类加载器不是不是java类，这正是BootStrap。
3、Java虚拟机中的所有类装载器采用具有父子关系的树形结构进行组织，在实例化每个类装载器对象时，需要为其指定一个父级类装载器对象或者默认采用系统类装载器为其父级类加载。
public class ClassLoaderTest {
public static void main(String[] args) {
// TODO Auto-generated methodstub
Object obj = ClassLoaderTest.class.getClassLoader().getClass().getName();
System.out.println(obj);
Object obj1 = System.class.getClassLoader();
System.out.println(obj1);
//Java类加载器中有一个特殊的类加载器：BootStrap
ClassLoader loader =ClassLoaderTest.class.getClassLoader();
while(loader !=null){
System.out.println(loader.getClass().getName());//获取其类加载器的名称
loader =loader.getParent();//获取其类加载器的父类名称
}
System.out.println(loader);
}
}
4、类加载器的委托机制
1.当Java虚拟机要加载一个类时，到底派出哪个类加载器去加载呢？
a.首先当前线程的类加载器去加载线程中的第一个类。
b.如果类A中引用了类B，Java虚拟机将使用加载类A的类装载器来加载类B。
c.还可以直接调用ClassLoader.loadClass()方法来指定某个类加载器去加载某个类。
2.每个类加载器加载类时，又先委托给其上级类加载器。
a.当所有祖宗类加载器没有加载到类，回到发起者类加载器，还加载不了，则抛ClassNotFoundException，不是再去找发起者类加载器的儿子，因为没有getChild方法，即使有，那有多个儿子，找哪一个呢？
b.对着类加载器的层次结构图和委托加载原理，解释先前将ClassLoaderTest输出成jre/lib/ext目录下的itcast.jar包中后，运行结果为ExtClassLoader的原因。
44_自定义类加载器的编写原理分析
1、自定义的类加载器的必须继承ClassLoader
loadClass方法与findClass方法
defineClass方法
2、编程步骤：
1.编写一个对文件内容进行简单加密的程序。
2.编写了一个自己的类装载器，可实现对加密过的类进行装载和解密。
3.编写一个程序调用类加载器加载类，在源程序中不能用该类名定义引用变量，因为编译器无法识别这个类。程序中可以除了使用ClassLoader.load方法之外，还可以使用设置线程的上下文类加载器或者系统类加载器，然后再使用Class.forName。
3、实验步骤：
1.对不带包名的class文件进行加密，加密结果存放到另外一个目录，例如： javaMyClassLoader MyTest.class F:\itcast
2.运行加载类的程序，结果能够被正常加载，但打印出来的类装载器名称为AppClassLoader：java MyClassLoader MyTest F:\itcast
3.用加密后的类文件替换CLASSPATH环境下的类文件，再执行上一步操作就出问题了，错误说明是AppClassLoader类装载器装载失败。
4.删除CLASSPATH环境下的类文件，再执行上一步操作就没问题了。
4、findClass
protected Class<?> findClass(Stringname) throws ClassNotFoundException
使用指定的二进制名称查找类。此方法应该被类加载器的实现重写，该实现按照委托模型来加载雷。在通过父类加载器检查所请求的类后，此方法将被loadClass方法调用，默认实现抛出一个ClassNotFoundException；
45_编写对class文件进行加密的工具类
import java.util.Date;
public class ClassLoaderAttachmentextends Date {
public String toString(){
return "hello,itheima";
}
}
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
public class MyClassLoader {
//编写对class文件进行加密的工具类
public static void main(String[] args)throws Exception{
// TODO Auto-generated methodstub
String srcPath =args[0];
String destDir = args[1];
FileInputStream fis = new FileInputStream(srcPath);
String destFileName =srcPath.substring(srcPath.lastIndexOf('\\')+1);
String destPath = destDir +"\\"+ destFileName;
FileOutputStream fos = new FileOutputStream(destPath);
cypher(fis,fos);
fis.close();
fos.close();
}
private static void cypher(InputStream ips,OutputStream ops)throws Exception{
int b = -1;
while((b=ips.read())!=-1){
ops.write(b ^ 0xff);
}
}
}
46_编写和测试自己编写的解密类加载器
import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
public class MyClassLoader1 extends ClassLoader{
public static void main(String[] args)throws Exception {
// TODO Auto-generated methodstub
String srcPath = args[0];
String destDir = args[1];
FileInputStream fis = new FileInputStream(srcPath);
//目标原名称
String destFileName =srcPath.substring(srcPath.lastIndexOf('\\')+1);
//目标原路径
String destPath =destDir + "\\" + destFileName;
FileOutputStream fos = new FileOutputStream(destPath);
cypher(fis,fos);
fis.close();
fos.close();
}
public static void cypher(InputStream ips, OutputStream ops)throws Exception{
int b = -1;
while((b=ips.read())!=-1){
ops.write(b ^ 0xff);
}
}
//产生一个classDir成员变量
private String classDir;
@Override
protected Class<?> findClass(String name)throws ClassNotFoundException {
// TODO Auto-generated methodstub
String classFileName = classDir + "\\" + name.substring(name.lastIndexOf('.')+1) +".class";
try{
//由于这里是子类抛出异常,只能使用try,catch处理,因为其子类要抛的异常比父类范围大
FileInputStream fis= newFileInputStream(classFileName);
//定义一个字节输入流
ByteArrayOutputStreambos = new ByteArrayOutputStream();
cypher(fis,bos);
fis.close();
byte[] bytes = bos.toByteArray();
return defineClass(bytes,0,bytes.length);
}catch(Exception e){
e.printStackTrace();
}
return super.findClass(name);
}
//创建一个不带参数的MyClassLoader
public MyClassLoader1(){
//创建一个带参数的MyClassLoader
public MyClassLoader1(String classD
this.classDir
public class ClassLoaderTest {
public static void main(String[] args)throws Exception{
// TODO Auto-generated methodstub
Object obj = ClassLoaderTest.class.getClassLoader().getClass().getName();
System.out.println(obj);
Object obj1 = System.class.getClassLoader();
System.out.println(obj1);
//Java类加载器中有一个特殊的类加载器：BootStrap
ClassLoader loader =ClassLoaderTest.class.getClassLoader();
while(loader !=null){
System.out.println(loader.getClass().getName());//获取其类加载器的名称
loader =loader.getParent();//获取其类加载器的父类名称
}
System.out.println(loader);
//System.out.println(new ClassLoaderAttachment().toString());
Class clazz = new MyClassLoader1("itheimalib").loadClass("com.itheima.day2.ClassLoaderAttachment");
//由于这里是自定义的ClassLoaderAttachment类,因此编译器是无法识别的,所以得将其强制转换
//ClassLoaderAttachment d1 = (ClassLoaderAttachment)clazz.newInstance();
//由于之前定义的是Date类,因此这里可以直接将其转成Date的类
Date d1 =(Date)clazz.newInstance();
System.out.println(d1);
}
}
import java.util.Date;
public class ClassLoaderAttachmentextends Date {
public StringtoString(){
return"hello,itheima";
}
}
47_类加载器的一个高级问题的实验分析
1.编写一个能打印出自己的类加载器名称和当前类加载器的父子结构关系链的MyServlet，正常发布后，看到打印结果为WebAppClassloader。
2.把MyServlet.class文件打jar包，放到ext目录中，重启tomcat，发现找不到HttpServlet的错误。
3.把servlet.jar也放到ext目录中，问题解决了，打印的结果是ExtclassLoader 。
48_分析代理类的作用与原理及AOP概念
代理的概念与作用
程序中的代理
1、要为已存在的多个具有相同接口的目标类的各个方法增加一些系统功能，例如，异常处理、日志、计算方法的运行时间、事务管理、等等，你准备如何做？
2、编写一个与目标类具有相同接口的代理类，代理类的每个方法调用目标类的相同方法，并在调用方法时加上系统功能的代码。（参看下页的原理图）
3、如果采用工厂模式和配置文件的方式进行管理，则不需要修改客户端程序，在配置文件中配置是使用目标类、还是代理类，这样以后很容易切换，譬如，想要日志功能时就配置代理类，否则配置目标类，这样，增加系统功能很容易，以后运行一段时间后，又想去掉系统功能也很容易。
class X{
void sayHello(){
System.out.println("hello,itheima");
}
}
XProxy{
void sayHello(){
starttime;
X.sayHello();
endtime;
}
}
AOP：交叉业务的编程问题即为面向方面的编程（Aspect orientedprogram ,简称AOP），AOP的目标就是要使交叉业务模块化。可以采用将切面代码移动到原始方法的周围，这与直接在方法中编写切面代码的运行效果是一样的，使用代理技术正好可以解决这种问题，代理是实现AOP功能的核心和关键技术
动态代理技术
1、要为系统中的各种接口的类增加代理功能，那将需要太多的代理类，全部采用静态代理方式，将是一件非常麻烦的事情！写成百上千个代理类，是不是太累！
2、JVM可以在运行期动态生成出类的字节码，这种动态生成的类往往被用作代理类，即动态代理类。
3、JVM生成的动态类必须实现一个或多个接口，所以，JVM生成的动态类只能用作具有相同接口的目标类的代理。
4、CGLIB库可以动态生成一个类的子类，一个类的子类也可以用作该类的代理，所以，如果要为一个没有实现接口的类生成动态代理类，那么可以使用CGLIB库。
5、代理类的各个方法中通常除了要调用目标的相应方法和对外返回目标返回的结果外，还可以在代理方法中的如下四个位置加上系统功能代码：
1.在调用目标方法之前
2.在调用目标方法之后
3.在调用目标方法前后
4.在处理目标方法异常的catch块中
49_创建动态类及查看其方法列表信息
1、分析JVM动态生成的类
1、创建实现了Collection接口的动态类和查看其名称，分析Proxy.getProxyClass方法的各个参数。
2、编码列出动态类中的所有构造方法和参数签名
3、编码列出动态类中的所有方法和参数签名
4、创建动态类的实例对象
1.用反射获得构造方法
2.编写一个最简单的InvocationHandler类
3.调用构造方法创建动态类的实例对象，并将编写的InvocationHandler类的实例对象传进去
4.打印创建的对象和调用对象的没有返回值的方法和getClass方法，演示调用其他有返回值的方法报告了异常。
5.将创建动态类的实例对象的代理改成匿名内部类的形式编写，锻炼大家习惯匿名内部类。
5、总结思考：让jvm创建动态类及其实例对象，需要给它提供哪些信息?
三个方面：
1.生成的类中有哪些方法，通过让其实现哪些接口的方式进行告知；
2.产生的类字节码必须有个一个关联的类加载器对象；
3.生成的类中的方法的代码是怎样的，也得由我们提供。把我们的代码写在一个约定好了接口对象的方法中，把对象传给它，它调用我的方法，即相当于插入了我的代码。提供执行代码的对象就是那个InvocationHandler对象，它是在创建动态类的实例对象的构造方法时传递进去的。在上面的InvocationHandler对象的invoke方法中加一点代码，就可以看到这些代码被调用运行了。
6、用Proxy.newInstance方法直接一步就创建出代理对象。
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Collection;
public class ProxyTest {
publicstatic void main(String[] args) {
//TODO Auto-generated method stub
ClassclazzProxy1 = Proxy.getProxyClass(Collection.class.getClassLoader(),Collection.class);;
System.out.println(clazzProxy1.getName());
//获取所有的构造方法,这里定义一个构造方法数组
System.out.println("----------beginconstructor----------");
/*
$Proxy0()
$Proxy0(InvocationHandler,int)
*/
Constructor[]constructors = clazzProxy1.getConstructors();
for(Constructorconstructor : constructors){
Stringname = constructor.getName();
//为了提高效率,这里使用StringBuilder,而StringBuilder不考虑安全问题,因此效率比StringBuffer更高
StringBuildersb = new StringBuilder(name);
sb.append('(');
Class[]clazzParams = constructor.getParameterTypes();
for(ClassclazzParam : clazzParams){
sb.append(clazzParam.getName()).append(',');
}
if(clazzParams!= null && clazzParams.length != 0)
sb.deleteCharAt(sb.length()-1);//删除最后一个元素
sb.append(')');
System.out.println(sb.toString());
}
//通过创建的动态类获取其所有方法
Method[]methods = clazzProxy1.getMethods();
for(Methodmethod : methods){
Stringname = method.getName();
//为了提高效率,这里使用StringBuilder,而StringBuilder不考虑安全问题,因此效率比StringBuffer更高
StringBuildersb = new StringBuilder(name);
sb.append('(');
Class[]clazzParams = method.getParameterTypes();
for(ClassclazzParam : clazzParams){
sb.append(clazzParam.getName()).append(',');
}
if(clazzParams!= null && clazzParams.length != 0)
sb.deleteCharAt(sb.length()-1);//删除最后一个元素
sb.append(')');
System.out.println(sb.toString());
}
}
}
50_创建动态类的实例对象及调用其方法
分析JVM动态生成的类
1、创建实现了Collection接口的动态类和查看其名称，分析Proxy.getProxyClass方法的各个参数。
2、编码列出动态类中的所有构造方法和参数签名
3、编码列出动态类中的所有方法和参数签名
4、创建动态类的实例对象
1.用反射获得构造方法
2.编写一个最简单的InvocationHandler类
3.调用构造方法创建动态类的实例对象，并将编写的InvocationHandler类的实例对象传进去
4.打印创建的对象和调用对象的没有返回值的方法和getClass方法，演示调用其他有返回值的方法报告了异常。
5.将创建动态类的实例对象的代理改成匿名内部类的形式编写，锻炼大家习惯匿名内部类。
总结思考：让jvm创建动态类及其实例对象，需要给它提供哪些信息?
三个方面：
1.生成的类中有哪些方法，通过让其实现哪些接口的方式进行告知；
2.产生的类字节码必须有个一个关联的类加载器对象；
3.生成的类中的方法的代码是怎样的，也得由我们提供。把我们的代码写在一个约定好了接口对象的方法中，把对象传给它，它调用我的方法，即相当于插入了我的代码。提供执行代码的对象就是那个InvocationHandler对象，它是在创建动态类的实例对象的构造方法时传递进去的。在上面的InvocationHandler对象的invoke方法中加一点代码，就可以看到这些代码被调用运行了。
5、用Proxy.newInstance方法直接一步就创建出代理对象。
52_完成InvocationHandler对象的内部功能
Collection proxy2 = (Collection)constructor.newInstance(new InvocationHandler(){
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
// TODO Auto-generated methodstub
return null;
}
});
Collection proxy3 =(Collection)Proxy.newProxyInstance(
Collection.class.getClassLoader(),//类加载器
new Class[]{Collection.class},//接口
new InvocationHandler(){
ArrayList target = new ArrayList();
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
// TODO Auto-generated methodstub
long startTime = System.currentTimeMillis();
Object retVal= method.invoke(target, args);
long endTime = System.currentTimeMillis();
System.out.println(method.getName() +"running time is "+ (endTime - startTime)+"毫秒");
return retVal;
}
});//InvocationHandler
proxy3.add("zxx");
proxy3.add("lhm");
proxy3.add("bxd");
System.out.println(proxy3.size());
}
53_总结分析动态代理类的设计原理与结构
1、分析动态代理的工作原理图
2、怎样将目标类传进去？
1.直接在InvocationHandler实现类中创建目标类的实例对象，可以看运行效果和加入日志代码，但没有实际意义。
2.为InvocationHandler实现类注入目标类的实例对象，不能采用匿名内部类的形式了。
3.让匿名的InvocationHandler实现类访问外面方法中的目标类实例对象的final类型的引用变量。
3、将创建代理的过程改为一种更优雅的方式，eclipse重构出一个getProxy方法绑定接收目标同时返回代理对象，让调用者更懒惰，更方便，调用者甚至不用接触任何代理的API。
4、将系统功能代码模块化，即将切面代码也改为通过参数形式提供，怎样把要执行的系统功能代码以参数形式提供？
1.把要执行的代码装到一个对象的某个方法里，然后把这个对象作为参数传递，接收者只要调用这个对象的方法，即等于执行了外界提供的代码！
2.为bind方法增加一个Advice参数。
54_编写可生成代理和插入通告的通用方法
private static Object getProxy(final Object target,final Advice advice) {
Object proxy3 = Proxy.newProxyInstance(
//Collection.class.getClassLoader(),//类加载器
target.getClass().getClassLoader(),
/*new Class[]{Collection.class}, //接口*/
target.getClass().getInterfaces(),
new InvocationHandler(){
//把目标对象作为参数传递出去
//ArrayList target = new ArrayList();
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
long startTime = System.currentTimeMillis();
advice.beforeMethod(method);
ObjectretVal = method.invoke(target, args);
advice.afterMethod(method);
long endTime = System.currentTimeMillis();
System.out.println(method.getName() +"running time is "+ (endTime - startTime)+"毫秒");
return retVal;
}
});
return proxy3;
}
import java.lang.reflect.Method;
public interface Advice {
void beforeMethod(Method method);
void afterMethod(Methodmethod);
}
import java.lang.reflect.Method;
public class MyAdvice implements Advice {
long startTime = 0;
@Override
public void beforeMethod(Methodmethod) {
// TODO Auto-generated methodstub
System.out.println("到传智播客学习啦");
startTime = System.currentTimeMillis();
}
@Override
public void afterMethod(Method method){
// TODO Auto-generated methodstub
System.out.println("从传智播客毕业上班啦！");
long endTime = System.currentTimeMillis();
System.out.println(method.getName() +"running time is "+ (endTime - startTime)+"毫秒");
}
}
55_实现类似spring的可配置的AOP框架
实现AOP功能的封装与配置
1、工厂类BeanFactory负责创建目标类或代理类的实例对象，并通过配置文件实现切换。其getBean方法根据参数字符串返回一个相应的实例对象，如果参数字符串在配置文件中对应的类名不是ProxyFactoryBean，则直接返回该类的实例对象，否则，返回该类实例对象的getProxy方法返回的对象。
2、BeanFactory的构造方法接收代表配置文件的输入流对象，配置文件格式如下：
#xxx=java.util.ArrayList
xxx=cn.itcast.ProxyFactoryBean
xxx.target=java.util.ArrayList
xxx.advice=cn.itcast.MyAdvice
3、ProxyFacotryBean充当封装生成动态代理的工厂，需要为工厂类提供哪些配置参数信息？
1.目标
2.通知
4、编写客户端应用：
1.编写实现Advice接口的类和在配置文件中进行配置
2.调用BeanFactory获取对象
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
import com.itheima.day3.Advice;
public class BeanFactory {
//定义一个配置文件
Properties props = new Properties();
public BeanFactory(InputStream ips) {
try {
props.load(ips);//加载输入的配置文件
} catch (IOException e) {
// TODO Auto-generated catchblock
e.printStackTrace();
}
}
//对于JavaBean来讲，一定要有一个不带参数的构造方法
public Object getBean(String name){
String className = props.getProperty(name);
Object bean = null;
try {
Class clazz =Class.forName(className);
bean =clazz.newInstance();
} catch (Exception e) {
// TODO Auto-generated catchblock
e.printStackTrace();
}
if(bean instanceof ProxyFactoryBean){
Object proxy = null;
ProxyFactoryBeanproxyFactoryBean = (ProxyFactoryBean)bean;
try {
Advice advice =(Advice)Class.forName(props.getProperty(name +".advice")).newInstance();
Object target =Class.forName(props.getProperty(name +".target")).newInstance();
proxyFactoryBean.setAdvice(advice);
proxyFactoryBean.setTarget(target);
proxy =((ProxyFactoryBean)bean).getProxy();
} catch (Exception e) {
// TODO Auto-generated catchblock
e.printStackTrace();
}
return proxy;
}
return bean;
}
}
#xxx=java.util.ArrayList
xxx=com.itheima.day3.aopframework.ProxyFactoryBean
xxx.advice=com.itheima.day3.MyAdvice
xxx.target=java.util.ArrayList
import java.io.InputStream;
public class AopFrameworkTest {
public static void main(String[] args)throws Exception{
// TODO Auto-generated methodstub
InputStream ips = AopFrameworkTest.class.getResourceAsStream("config.properties");
Object bean = new BeanFactory(ips).getBean("xxx");
System.out.println(bean.getClass().getName());
}
}
----------
1-7.eclipse的基本使用
工程管理和快捷键配置
eclipse视图管理和程序调试
配置eclipse的编译与运行环境
在eclipse中配置java模板代码
在eclipse中导入已有的工程
8.静态导入
import :语句可以导入一个类或包中的所有类
import static ：语句导入一个类中的某个静态方法或所有静态方法
9.for循环增强
for(类型 变量：数组){}
10.自动装箱与拆箱及享元模式
1、自动装箱：
Integer num1 = 12;
2、自动拆箱：
System.out.println(num1 + 12);
3、基本数据类型的对象缓存：
Integer num1 = 12;
Integer num2 = 12; 这块相等，<=127都是真的
System.out.println(num1 == num2);
Integer num3 = 129; 这块不相等，因为是对象,Integer取值范围为：-128-127
Integer num4 = 129;
System.out.println(num3 == num4);
Integer num5 = Integer.valueOf(12);
Integer num6 = Integer.valueOf(12) ; 这块的道理同上
System.out.println(num5 == num6);
11_枚举的作用介绍
1、为什么要有枚举
问题：要定义星期几或性别的变量，该怎么定义？假设用1-7分别表示星期一到星期日，但有人可能会写成int weekday = 0;或即使使用常量方式也无法阻止意外。
枚举就是要让某个类型的变量的取值只能为若干个固定值中的一个，否则，编译器就会报错。枚举可以让编译器在编译时就可以控制源程序中填写的非法值，普通变量的方式在开发阶段无法实现这一目标。
12_用普通类模拟枚举的实现原理
用普通类如何实现枚举功能，定义一个Weekday的类来模拟枚举功能。
1.私有的构造方法
2.每个元素分别用一个公有的静态成员变量表示
3.可以有若干公有方法或抽象方法。采用抽象方法定义nextDay就将大量的if.else语句转移成了一个个独立的类。
13_Java5枚举的基本应用
枚举的基本应用
举例：定义一个Weekday的枚举。
扩展：枚举类的values,valueOf,name,toString,ordinal等方法
总结：枚举是一种特殊的类，其中的每个元素都是该类的一个实例对象，例如可以调用WeekDay.SUN.getClass().getName和WeekDay.class.getName()。
14_实现带有构造方法的枚举
枚举的高级应用
1、枚举就相当于一个类，其中也可以定义构造方法、成员变量、普通方法和抽象方法。
2、枚举元素必须位于枚举体中的最开始部分，枚举元素列表的后要有分号与其他成员分隔。把枚举中的成员方法或变量等放在枚举元素的前面，编译器报告错误。
3、带构造方法的枚举
1.构造方法必须定义成私有的
2.如果有多个构造方法，该如何选择哪个构造方法？
3.枚举元素MON和MON（）的效果一样，都是调用默认的构造方法。
4、带抽象方法的枚举
1.定义枚举TrafficLamp
2.实现普通的next方法
3.实现抽象的next方法：每个元素分别是由枚举类的子类来生成的实例对象，这些子类采用类似内部类的方式进行定义。
4.增加上表示时间的构造方法
5、枚举只有一个成员时，就可以作为一种单例的实现方式。
public class EnumTest {
public static void main(String[] args) {
WeekDay weekDay2 = WeekDay.FRI;
System.out.println(weekDay2);
}
public enum WeekDay{
SUN(1),MON(),TUE,WED,THI,FRI,SAT;
private WeekDay(){System.out.println("first");}//空参数类型的构造函数
private WeekDay(int day){System.out.println("second");}//带有参数类型的构造函数
}
}
15_实现带有抽象方法的枚举
import java.util.
public class EnumTest {
public static void main(String[]
new Date(300){};
}
//带有抽象方法的枚举——交通灯
public enum TrafficLamp{
RED(30){
public TrafficLamp nextLamp(){
return GREEN;
}
},
GREEN(45){
public TrafficLamp nextLamp(){
return YELLOW;
}
},
YELLOW(5){
public TrafficLamp nextLamp(){
return RED;
}
};
public abstract TrafficLamp nextLamp();
private int time;
private TrafficLamp(int time){
this.time = time;
}
}
}
16_透彻分析反射的基础_Class类
反射的基石-->Class类
1、 Java程序中的各个Java类属于同一类事物，描述这类事物的Java类名就是Class。
2、对比提问：众多的人用一个什么类表示？众多的Java类用一个什么类表示？
人Person
Java类Class
3、对比提问： Person类代表人，它的实例对象就是张三，李四这样一个个具体的人， Class类代表Java类，它的各个实例对象又分别对应什么呢？
1.对应各个类在内存中的字节码，例如，Person类的字节码，ArrayList类的字节码，等等。
2.一个类被类加载器加载到内存中，占用一片存储空间，这个空间里面的内容就是类的字节码，不同的类的字节码是不同的，所以它们在内存中的内容是不同的，这一个个的
4、如何得到各个字节码对应的实例对象（ Class类型）
1.类名.class，例如，System.class
2.对象.getClass()，例如，new Date().getClass()
3.Class.forName("类名")，例如，Class.forName("java.util.Date");
5、九个预定义Class实例对象：
分别是boolean、byte、char、short、int、long、float、double和void
参看Class.isPrimitive（判定指定的 Class 对象是否表示一个基本类型）方法的帮助
int.class == Integer.TYPE
6、数组类型的Class实例对象
Class.isArray()
总之，只要是在源程序中出现的类型，都有各自的Class实例对象，例如，int[]，void…
常见Class方法：
Class<?>[] getInterfaces() 获取自己实现的多个接口
Method getMethods() 获取自己所有的方法列表
String getName() 获取类名
Package getPackege() 获取自己所属的包
17_理解反射的概念
1、反射就是把Java类中的各种成分映射成相应的java类。例如，一个Java类中用一个Class类的对象来表示，一个类中的组成部分：成员变量，方法，构造方法，包等等信息也用一个个的Java类来表示，就像汽车是一个类，汽车中的发动机，变速箱等等也是一个个的类。表示java类的Class类显然要提供一系列的方法，来获得其中的变量，方法，构造方法，修饰符，包等信息，这些信息就是用相应类的实例对象来表示，它们是Field、Method、Contructor、Package等等。
2、一个类中的每个成员都可以用相应的反射API类的一个实例对象来表示，通过调用Class类的方法可以得到这些实例对象后，得到这些实例对象后有什么用呢？怎么用呢？这正是学习和应用反射的要点。
18_构造方法的反射应用
1、Constructor类代表某个类中的一个构造方法
2、得到某个类所有的构造方法：
例子：Constructor [] constructors=Class.forName("java.lang.String").getConstructors();
3、得到某一个构造方法：
例子：
Constructor constructor=Class.forName(“java.lang.String”).getConstructor(StringBuffer.class);//获得方法时要用到类型
4、创建实例对象：
1.通常方式：String str = new String(new StringBuffer("abc"));
2.反射方式： String str = (String)constructor.newInstance(new StringBuffer("abc"));
调用获得的方法时要用到上面相同类型的实例对象
Class.newInstance()方法：
例子：String obj =(String)Class.forName("java.lang.String").newInstance();
该方法内部先得到默认的构造方法，然后用该构造方法创建实例对象。
该方法内部的具体代码是怎样写的呢？用到了缓存机制来保存默认构造方法的实例对象。
import java.lang.reflect.Constructor;
public class ReflectTest {
public static void main(String[] args)throws Exception {
// TODO Auto-generated methodstub
//new String(new StringBuffer("abc"));
Constructor constructor1 = String.class.getConstructor(StringBuffer.class);//这里的StringBuffer是选择哪个构造方法
String str2 = (String)constructor1.newInstance(/*"abc"*/new StringBuffer("abc"));//这里的StringBuffer是指要用StringBuffer的时候必须传递一个StringBuffer进去
//这里编译器只知道constructor1是一个构造方法，但不知道是谁的构造方法，因此这里需要进行强制转换成String类型的即可。
System.out.println(str2.charAt(2));
}
}
19_成员变量的反射
1、Field类代表某个类中的一个成员变量
2、演示用eclipse自动生成Java类的构造方法
3、问题：得到的Field对象是对应到类上面的成员变量，还是对应到对象上的成员变量？类只有一个，而该类的实例对象有多个，如果是与对象关联，哪关联的是哪个对象呢？所以字段fieldX 代表的是x的定义，而不是具体的x变量。
快捷键：Alt + Shift + S -->产生想对应的构造方法Generate Constructor using Fields
20_成员变量反射的综合案例
需求：将任意一个对象中的所有String类型的成员变量所对应的字符串内容中的"b"改成"a"。
ReflectPoint.java 演示包：
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
public class ReflectTest {
public static void main(String[] args)throws Exception {
// TODO Auto-generated methodstub
changeStringValue(pt1);
System.out.println(pt1);
}
//反射综合案例，重点掌握
public static void changeStringValue(Object obj)throws Exception{
Field[] fields = obj.getClass().getFields();
for(Field field : fields){
//if(field.getType().equals(String.class)){
if(field.getType()/*获取自己的类型*/ == String.class){
//由于比较的是同一份字节码，因此这里只能用"=="而不能用equals进行比较
String oldValue = (String)field.get(obj);
String newValue = oldValue.replace('b','a');//将旧值替换成新值
field.set(obj,newValue);
}
}
}
}
21_成员方法的反射
1、Method类代表某个类中的一个成员方法
2、得到类中的某一个方法：
例子： Method charAt =Class.forName("java.lang.String").getMethod("charAt",int.class);
3、调用方法：
通常方式：System.out.println(str.charAt(1));
反射方式：System.out.println(charAt.invoke(str, 1));
如果传递给Method对象的invoke()方法的第一个参数为null，说明该Method对象对应的是一个静态方法！
4、jdk1.4和jdk1.5的invoke方法的区别：
Jdk1.5：public Object invoke(Object obj,Object... args)
Jdk1.4：public Object invoke(Object obj,Object[] args)，即按jdk1.4的语法，需要将一个数组作为参数传递给invoke方法时，数组中的每个元素分别对应被调用方法中的一个参数，所以，调用charAt方法的代码也可以用Jdk1.4改写为 charAt.invoke(“str”, new Object[]{1})形式。
面向对象：只要把对象变成私有private，如果谁要操作这个对象，那么这个方法就应该作用到谁的身上，专家模式。
22_对接收数组参数的成员方法进行反射
用反射方式执行某个类中的main方法
1、目标：
写一个程序，这个程序能够根据用户提供的类名，去执行该类中的main方法。用普通方式调完后，大家要明白为什么要用反射方式去调啊？
2、问题：
启动Java程序的main方法的参数是一个字符串数组，即public static voidmain(String[] args)，通过反射方式来调用这个main方法时，如何为invoke方法传递参数呢？按jdk1.5的语法，整个数组是一个参数，而按jdk1.4的语法，数组中的每个元素对应一个参数，当把一个字符串数组作为参数传递给invoke方法时，javac会到底按照哪种语法进行处理呢？jdk1.5肯定要兼容jdk1.4的语法，会按jdk1.4的语法进行处理，即把数组打散成为若干个单独的参数。所以，在给main方法传递参数时，不能使用代码mainMethod.invoke(null,newString[]{“xxx”})，javac只把它当作jdk1.4的语法进行理解，而不把它当作jdk1.5的语法解释，因此会出现参数类型不对的问题。
3、解决办法：
mainMethod.invoke(null,new Object[]{new String[]{"xxx"}});
mainMethod.invoke(null,(Object)new String[]{"xxx"}); ，编译器会作特殊处理，编译时不把参数当作数组看待，也就不会数组打散成若干个参数了
23_数组与Object的关系及其反射类型
数组的反射
1、具有相同维数和元素类型的数组属于同一个类型，即具有相同的Class实例对象(此处比较与值无关)。
2、代表数组的Class实例对象的getSuperClass()方法返回的父类为Object类对应的Class。
3、基本类型的一维数组可以被当作Object类型使用，不能当作Object[]类型使用；非基本类型的一维数组，既可以当做Object类型使用，又可以当做Object[]类型使用。
4、Arrays.asList()方法处理int[]和String[]时的差异。
5、Array工具类用于完成对数组的反射操作。
24_数组的反射应用
Array工具类用于完成对数组的反射操作
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 methodstub
printObject(a4);
printObject("xyz");
//获取数组中的元素类型
Object[] aa = new Object[]{"a",1};
System.out.println(aa[1].getClass().getName());
}
private static void printObject(Object obj) {
// TODO Auto-generated methodstub
Class clazz = obj.getClass();
if(clazz.isArray()){
for(int x=0; x<Array.getLength(obj); x++){
System.out.println(Array.get(obj, x));
}
}
else{
System.out.println(obj);
}
}
}
25_ArrayList、HashSet的比较以及Hashcode分析
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
public class ReflectTest2 {
public static void main(String[] args) {
// TODO Auto-generated methodstub
//Collection collections = new ArrayList();
Collection collections = newHashSet();
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);//内存泄露，这里的pt1是移除不掉的，因为其Hashcode地址值已变
System.out.println(collections.size());
}
}
public class ReflectPoint {
private int x;
public int y;
public ReflectPoint(int x,int y) {
super();
this.x = x;
this.y = y;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + x;
result = prime * result + y;
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() !=obj.getClass())
return false;
ReflectPoint other = (ReflectPoint) obj;
if (x != other.x)
return false;
if (y != other.y)
return false;
return true;
}
}
26_框架的概念以及用反射技术开发框架的原理
反射的作用-->实现框架功能
1、框架与框架要解决的核心问题
我做房子卖给用户住，由用户自己安装门窗和空调，我做的房子就是框架，用户需要使用我的框架，把门窗插入进我提供的框架中。框架与工具类有区别，工具类被用户的类调用，而框架则是调用用户提供的类。
2、框架要解决的核心问题
我在写框架（房子）时，你这个用户可能还在上小学，还不会写程序呢？我写的框架程序怎样能调用到你以后写的类（门窗）呢？
因为在写才程序时无法知道要被调用的类名，所以，在程序中无法直接new 某个类的实例对象了，而要用反射方式来做。
3、案例
1.先直接用new 语句创建ArrayList和HashSet的实例对象，演示用eclipse自动生成 ReflectPoint类的equals和hashcode方法，比较两个集合的运行结果差异。
2.然后改为采用配置文件加反射的方式创建ArrayList和HashSet的实例对象，比较观察运行结果差异。
3.引入了elipse对资源文件的管理方式的讲解。
import java.io.FileInputStream;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Properties;
public class ReflectTest3 {
public static void main(String[] args)throws Exception{
// TODO Auto-generated methodstub
InputStream ips = new FileInputStream("config.properties");
Properties props = new Properties();
props.load(ips);
ips.close();
String className = props.getProperty("className");
Collection collections = (Collection)Class.forName(className).newInstance();
//Collection collections = new ArrayList();
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);
System.out.println(collections.size());
}
}
config.properties文件:
className=java.util.HashSet
这里在建立config.properties文件时，需要在javaenhance工程上单击右键->新建File文件，而其自动生成的文件则在JRE文件目录下，因此可以避免其余错误
27_用类加载器的方法管理资源和配置文件
1.getRealPath();//金山词霸//内部
一定要记住用完整的路径，但完整的路径不是硬编码，而是运算出来的。
2.类加载器可以将.class文件加载到内存当中去
3.配置文件一定要放在classpath执行路径下
注意：配置文件一定要区分相对路径和绝对路径，否则很容易出错
29_由内省引出JavaBean的讲解
1、JavaBean是一种特殊的Java类，主要用于传递数据信息，这种java类中的方法主要用于访问私有的字段，且方法名符合某种命名规则。
2、如果要在两个模块之间传递多个信息，可以将这些信息封装到一个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用肯定需要带来一些额外的好处，我们才会去
3、了解和应用JavaBean！好处如下：
1.在Java EE开发中，经常要使用到JavaBean。很多环境就要求按JavaBean方式进行操作，别人都这么用和要求这么做，那你就没什么挑选的余地！
2.JDK中提供了对JavaBean进行操作的一些API，这套API就称为内省。如果要你自己去通过getX方法来访问私有的x，怎么做，有一定难度吧？用内省这套api操作JavaBean比用普通类的方式更方便。
InstroSpector:内省，检查视察的意思，主要对JavaBean进行操作，其中JavaBean是一个特殊的Java类
5、Age --> 如果第二个字母是小的，则把第一个字母变成小的-->age
例如：
gettime-->time setTime-->time getCPU-->CPU
30_对JavaBean的简单内省操作
import java.beans.IntrospectionException;
import java.beans.PropertyDescriptor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class IntroSpectorTest {
public static void main(String[] args)throws Exception {
ReflectPoint pt1 = new ReflectPoint(3,5);
String propertyName = "x";
ObjectretVal = getProperty(pt1,propertyName);
System.out.println(retVal);
Objectvalue = 7;
setProperties(pt1,propertyName, value);
System.out.println(pt1.getX());
}
//设置value的值
private static void setProperties(Objectpt1, String propertyName,
Object value) throws IntrospectionException,
IllegalAccessException,InvocationTargetException {
PropertyDescriptor pd2 = new PropertyDescriptor(propertyName,pt1.getClass());
Method methodSetX = pd2.getWriteMethod();
methodSetX.invoke(pt1, value);
}
private static Object getProperty(Object pt1, String propertyName)
throws IntrospectionException, IllegalAccessException,
InvocationTargetException{
PropertyDescriptor pd = new PropertyDescriptor(propertyName,pt1.getClass());
Method methodGetX = pd.getReadMethod();
ObjectretVal = methodGetX.invoke(pt1);
return retVal;
}
小结：从上例可以看出Java Bean的优势：可以通过PropertyDescriptor（属性描述器？）来创建对象，然后用 对象.getWriterMethod来获取写入的方法，然后再用invoke调用。这就是反射
31_使用BeanUtils工具包操作JavaBean
Bean工具包
1、演示用eclipse如何加入jar包，先只是引入beanutils包，等程序运行出错后再引入logging包。
2、在前面内省例子的基础上，用BeanUtils类先get原来设置好的属性，再将其set为一个新值。
get属性时返回的结果为字符串，set属性时可以接受任意类型的对象，通常使用字符串。
3、用PropertyUtils类先get原来设置好的属性，再将其set为一个新值。
get属性时返回的结果为该属性本来的类型，set属性时只接受该属性本来的类型。
4、演示去掉JavaBean（ReflectPoint）的public修饰符时，BeanUtils工具包访问javabean属性时出现的问题。
导入需要的jar包操作步骤：在javaenhance工程上单击鼠标右键-->New-->SourceFolder-->Floder Name:lib--.复制需要使用的jar包，直接粘贴到新建的lib目录下，然后将其增加到build path环境中：单击导入的jar包右键-->Build Path-->Add toBuild Path即可
在使用IntroSpectorTest.java的时候运用到了JavaUtils时，只导入commons-beanutils.jar包是不够的，而且会报错：org/apache/commons/logging/LogFactory，因此这里还需要按照导入beanutils jar包的方法导入logging包，并且添加到Build Path环境变量中
BeanUtils是以字符串的形式对JavaBean进行操作，而PropertyUtils则是对属性本身类型对JavaBean进行操作；如果需要类型转换，则使用BeanUtils，否则使用PropertyUtils
Map map = {name:"zxx",age:16};
BeanUtils.setProperty(map, "name", "lhm");*/
PropertyUtils.setProperty(pt1,"x", 9);
System.out.println(PropertyUtils.getProperty(pt1,"x").getClass().getName());
32_了解和入门注解的应用
了解注解及Java提供的几个基本注解
1、先通过@SuppressWarnings的应用让大家认识和了解一下注解：
通过System.runFinalizersOnExit(true);的编译警告引出@SuppressWarnings("deprecation")
2、@Deprecated
直接在刚才的类中增加一个方法，并加上@Deprecated标注，在另外一个类中调用这个方法。
3、@Override
public boolean equals(Reflect other)方法与HashSet结合讲解
常用几个注解
1.Deprecated value = RUNTIME
用@Deprecated特点注释的程序元素，不鼓励程序员使用这样的元素，通常是因为它很危险或存在更好的选择。在使用不被赞成的程序元素或在不被赞成的代码中执行重写时，编译器会发生
2.Override value = SOURCE
表示一个方法声明重写超类中的另个一方法声明。如果方法利用此注释类型进行注解但没有重写超类方法，则编译器会生成一条错误
3.SuppressWarnings value = SOURCE
指示应该注释元素（以及包含在该注释元素中的所有程序元素）中取消现实制定的编译器警告。注意，在给定元素中取消现实的警告集市所有包含元素中取消显示的警告的超集。例如，如果注释一个雷来取消显示某个警告，同事注释一个方法来取消显示另一个警告，那么僵在此方法中同时取消显示着两个警告。
public class AnnotationTest {
@SuppressWarnings("deprecation")
public static void main(String[] args) {
// TODO Auto-generated methodstub
System.runFinalizersOnExit(true);
sayHello();
}
//1.标记某个方法过时；
//2.子类覆盖父类
//3.压缩警告
@Deprecated //提示编译器说明下面这个方法过时，让调用这个方法的程序能够识别
public static void sayHello(){
System.out.println("hi,黑马程序员");
}
}
33_注解的定义与反射调用
注解的应用
1、注解类
@interface A{}
2、应用了“注解类”的类
@A
Class B{}
3、对“应用了注解类的类”进行反射操作的类
class C{
B.class.isAnnotionPresent(A.class);
A a = B.class.getAnnotion(A.class);
}
注解就相当于一个你的源程序中药调用的一个类，要在源程序中应用某个注解，得先准备好了这个注解类。就像你要调用某个类，得先有开发好了这个类。
自定义注解
根据反射测试的问题，引出@Retention元注解的讲解，其三种取值：
java源文件：RetetionPolicy.SOURCE、
class文件: RetetionPolicy.CLASS、
内存中的字节码: RetetionPolicy.RUNTIME;
其中，注解的默认阶段处在class文件阶段
注解里面的枚举：Java.lang.annotation Enum RetentionPolicy，其中该枚举有三个取值：CLASS：编译器将把注释记录在类文件中，但在运行时VM不需要保留注释。
RUNTIME：编译器将把注释记录在类文件中，在运行时VM将保留注释，因此可以反射性地读取。
SOURCE：编译器要丢弃的注释。
@ItheimaAnnotation
public class AnnotationTest {
@SuppressWarnings("deprecation")
@ItheimaAnnotation
public static void main(String[] args)throws Exception {
// TODO Auto-generated methodstub
System.runFinalizersOnExit(true);
sayHello();
if(AnnotationTest.class.isAnnotationPresent(ItheimaAnnotation.class)){
ItheimaAnnotation annotation = (ItheimaAnnotation)AnnotationTest.class.getAnnotation(ItheimaAnnotation.class);
System.out.println(annotation);
}
}
//1.标记某个方法过时；
//2.子类覆盖父类
//3.压缩警告
@Deprecated //提示编译器说明下面这个方法过时，让调用这个方法的程序能够识别
public static void sayHello(){
//System.out.println("hi,黑马程序员");
}
}
34_为注解添加各种属性
1、什么是注解的属性
一个注解相当于一个胸牌，如果你胸前贴了胸牌，就是传智播客的学生，否则，就不是。如果还想区分出是传智播客哪个班的学生，这时候可以为胸牌在增加一个属性来进行区分。加了属性的标记效果为：@MyAnnotation(color="red")
2、定义基本类型的属性和应用属性：
在注解类中增加String color();
@MyAnnotation(color="red")
3、用反射方式获得注解对应的实例对象后，再通过该对象调用属性对应的方法
MyAnnotation a =(MyAnnotation)AnnotationTest.class.getAnnotation(MyAnnotation.class);
System.out.println(a.color());
可以认为上面这个@MyAnnotation是MyAnnotaion类的一个实例对象
4、为属性指定缺省值：
String color()default "yellow";
5、value属性：
String value()default "zxx";
如果注解中有一个名称为value的属性，且你只想设置value属性（即其他属性都采用默认值或者你只有一个value属性），那么可以省略value=部分，例如：@MyAnnotation("lhm")。
@ItheimaAnnotation(annotationAttr=@MetaAnnotation("flx"), color="red",value="abc", arrayAttr={1,2,3} )
public class AnnotationTest {
@SuppressWarnings("deprecation")
@ItheimaAnnotation("xyz")
public static void main(String[] args)throws Exception {
// TODO Auto-generated methodstub
System.runFinalizersOnExit(true);
sayHello();
if(AnnotationTest.class.isAnnotationPresent(ItheimaAnnotation.class)){
ItheimaAnnotation annotation = (ItheimaAnnotation)AnnotationTest.class.getAnnotation(ItheimaAnnotation.class);
System.out.println(annotation.lamp().nextLamp().toString());
System.out.println(annotation.annotationAttr().value());
}
}
}
35_入门泛型的基本应用
import java.lang.reflect.Constructor;
import java.util.ArrayList;
public class GenericTest {
public static void main(String[] args)throws Exception{
// TODO Auto-generated methodstub
/*ArrayList collection = new ArrayList();
collection.add(1);
collection.add(1L);
collection.add("abc");
int i =(Integer)collection.get(1);*/
ArrayList<String>al = new ArrayList<String>();
al.add("abc");
al.add("bbb");
al.add("acd");
String element =al.get(2);
System.out.println(element);
Constructor<String>constructor1 = String.class.getConstructor(StringBuffer.class);//这里的StringBuffer是选择哪个构造方法
//将Constructor添加String类型的泛型后，后面的返回值前就不再需要将其强制转换成String类型了
String str2 =constructor1.newInstance(/*"abc"*/new StringBuffer("abc"));
System.out.println(str2.charAt(2));
}
}
36_泛型的内部原理及更深应用
泛型是提供给javac编译器使用的，可以限定集合中的输入类型，让编译器挡住源程序中的非法输入，编译器编译带类型说明的集合时会去除掉“类型”信息，使程序运行效率不受影响，对于参数化的泛型类型，getClass()方法的返回值和原始类型完全一样。由于编译生成的字节码会去掉泛型的类型信息，只要能跳过编译器，就可以往某个泛型集合中加入其它类型的数据，例如，用反射得到集合，再调用其add方法即可。
1、ArrayList<E>类定义和ArrayList<Integer>类引用中涉及如下术语：
1.整个称为ArrayList<E>泛型类型
2.ArrayList<E>中的E称为类型变量或类型参数
3.整个ArrayList<Integer>称为参数化的类型
4.ArrayList<Integer>中的Integer称为类型参数的实例或实际类型参数
5.ArrayList<Integer>中的<>念着typeof
6.ArrayList称为原始类型
2、参数化类型与原始类型的兼容性：
1.参数化类型可以引用一个原始类型的对象，编译报告警告，例如，
Collection<String> c = new Vector();//可不可以，不就是编译器一句话的事吗？
2.原始类型可以引用一个参数化类型的对象，编译报告警告，例如，
Collection c = new Vector<String>();//原来的方法接受一个集合参数，新的类型也要能传进去
3、参数化类型不考虑类型参数的继承关系：
Vector<String> v = new Vector<Object>(); //错误!
//不写<Object>没错，写了就是明知故犯
Vector<Object> v = new Vector<String>(); // 错误!
37_泛型的通配符扩展应用
1、使用?通配符可以引用其他各种参数化的类型，?通配符定义的变量主要用作引用，可以调用与参数化无关的方法，不能调用与参数化有关的方法。
2、限定通配符的上边界：
正确：Vector<? extends Number> x = new Vector<Integer>();
错误：Vector<? extends Number> x = new Vector<String>();
3、限定通配符的下边界：
正确：Vector<? super Integer> x = new Vector<Number>();
错误：Vector<? super Integer> x = new Vector<Byte>();
38_泛型集合的综合应用案例
HashMap<String,Integer> maps = new HashMap<String,Integer>();
maps.put("zxx", 28);
maps.put("lhm", 35);
maps.put("flx", 33);
Set<Map.Entry<String,Integer>>entrySet = maps.entrySet();
for(Map.Entry<String, Integer> entry :entrySet){
System.out.println(entry.getKey() +":" + entry.getValue());
}
39_自定义泛型方法及其应用
1、自定义泛型模板中，其函数结构相似，但类型不同，这里可以使用一个通用的方法，它可以适用于各种类型，例如：
template<classT>
Tadd(T x,T y){
return(T)(x+y);
}
其中，代码里面的T代表一种任意数据类型
2、Java中的泛型类型（或者泛型）类似于C++中的模板。但是这种相似性仅限于表面，Java语言中的泛型基本上完全是在编译器中实现，用于编译器执行类型检查和类型推断，然后生成普通的非凡行的字节码，这种实现技术成为擦除（erasure）（编译器使用泛型类型信息保证类型安全，然后再生成字节码之前将其清除）。这是因为扩展虚拟机指令集来支持泛型呗认为是无法接受的，这会为Java厂商升级其JVM造成难以逾越的障碍。所以，Java的泛型采用了可以完全在编译器中实现的擦除方法。
3、泛型中是如何处理异常的
publicstatic <T extends Exception> sayHello() throws T{
try{}
catch(Exception e){
throw (T)e;
}
}
其中：T必定是Exception的子类，然后在处理catch的时候，还是用Exception e而不能用T代替，最后将抛出的e降至转换成(T)这种类型即可；
40_自定义泛型方法的练习与类型推断总结
泛型方法的练习题
1、编写一个泛型方法，自动将Object类型的对象转换成其他类型。
classGenericTest{
public static voidmain(String[] args){
Object obj = “abc”;
String a =autoConvert(obj);
}
public static <T> TautoConvert(Object obj){
return (T)obj;
}
}
2、根据调用泛型方法时实际传递的参数类型或返回值的类型来推断，具体规则如下：
1.当某个类型变量只在整个参数列表中的所有参数和返回值中的一处被应用了，那么根据调用方法时该处的实际应用类型来确定，这很容易凭着感觉推断出来，即直接根据调用方法时传递的参数类型或返回值来决定泛型参数的类型，例如：
swap(new String[3],3,4) static <E> voidswap(E[] a, int i, int j)
2.当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型都对应同一种类型来确定，这很容易凭着感觉推断出来，例如：
add(3,5) static<T> T add(T a, T b)
3.当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型对应到了不同的类型，且没有使用返回值，这时候取多个参数中的最大交集类型，例如，下面语句实际对应的类型就是Number了，编译没问题，只是运行时出问题：
fill(new Integer[3],3.5f) static <T> void fill(T[] a, T v)
4.当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型对应到了不同的类型，并且使用返回值，这时候优先考虑返回值的类型，例如，下面语句实际对应的类型就是Integer了，编译将报告错误，将变量x的类型改为float，对比eclipse报告的错误提示，接着再将变量x类型改为Number，则没有了错误：
int x =(3,3.5f) static <T> T add(T a, T b)
5.参数类型的类型推断具有传递性，下面第一种情况推断实际参数类型为Object，编译没有问题，而第二种情况则根据参数化的Vector类实例将类型变量直接确定为String类型，编译将出现问题：
copy(newInteger[5],new String[5]) static <T> void copy(T[] a,T[] b);
copy(newVector<String>(), new Integer[5]) static <T> void copy(Collection<T> a , T[] b);
41_自定义泛型类的应用
1、如果类的实例对象中的多处都要用到同一个泛型参数，即这些地方引用的泛型类型要保持同一个实际类型时，这时候就要采用泛型类型的方式进行定义，也就是类级别的泛型，语法格式如下：
publicclass GenericDao<T> {
privateT field1;
publicvoid save(T obj){}
publicT getById(int id){}
}
2、类级别的泛型是根据引用该类名时指定的类型信息来参数化类型变量的，例如，如下两种方式都可以：
GenericDao<String> dao = null;
new genericDao<String>();
注意：
1.在对泛型类型进行参数化时，类型参数的实例必须是引用类型，不能是基本类型。
2.当一个变量被声明为泛型时，只能被实例变量、方法和内部类调用，而不能被静态变量和静态方法调用。因为静态成员是被所有参数化的类所共享的，所以静态成员不应该有类级别的类型参数。
import java.util.Set;
//dao--> Data Access Object:数据访问对象-->crud:create增、read检索、update改、delete删
public class GenericDao<T> {
//为了让程序里的T即返回值类型是统一的，如果只在方法上定义其返回值类型，最后得到的数据可能不是统一类型，
//因此这里可以将T返回值定义在类上，因此就能统一返回值类型，保证了数据的安全性
public void add(T x){ }
public T findById(int id){
return null;
}
public void delete(T obj){
}
public void delete(int id){
}
public void update(T obj){
}
public TfindByUserName(String name){
return null;
}
public Set<T> findByConditions(String where){
return null;
}
}
42_通过反射获得泛型的实际类型参数
class GenericTest{
public static void main(String[] args){
//以泛型的方式得到实际类型的参数
//Vector<Data> v1 = new Vector<Date>();
Method applyMethod =GenericTest.class.getMethod("applyVector", Vector.class);
Type[] types =applyMethod.getGenericParameterTypes();//获取参数值类型
ParameterizedType pType= (ParameterizedType)types[0];
System.out.println(pType.getRawType());
System.out.println(pType.getActualTypeArguments());
}
public static void applyVector(Vector<Date> v1){
}
43_类加载器及其委托机制的深入分析
1、Java虚拟机中可以安装多个类加载器，系统默认三个主要类加载器，每个类负责加载特定位置的类：BootStrap,ExtClassLoader,AppClassLoader
2、类加载器也是Java类，因为其他是java类的类加载器本身也要被类加载器加载，显然必须有第一个类加载器不是不是java类，这正是BootStrap。
3、Java虚拟机中的所有类装载器采用具有父子关系的树形结构进行组织，在实例化每个类装载器对象时，需要为其指定一个父级类装载器对象或者默认采用系统类装载器为其父级类加载。
public class ClassLoaderTest {
public static void main(String[] args) {
// TODO Auto-generated methodstub
Object obj = ClassLoaderTest.class.getClassLoader().getClass().getName();
System.out.println(obj);
Object obj1 = System.class.getClassLoader();
System.out.println(obj1);
//Java类加载器中有一个特殊的类加载器：BootStrap
ClassLoader loader =ClassLoaderTest.class.getClassLoader();
while(loader !=null){
System.out.println(loader.getClass().getName());//获取其类加载器的名称
loader =loader.getParent();//获取其类加载器的父类名称
}
System.out.println(loader);
}
}
4、类加载器的委托机制
1.当Java虚拟机要加载一个类时，到底派出哪个类加载器去加载呢？
a.首先当前线程的类加载器去加载线程中的第一个类。
b.如果类A中引用了类B，Java虚拟机将使用加载类A的类装载器来加载类B。
c.还可以直接调用ClassLoader.loadClass()方法来指定某个类加载器去加载某个类。
2.每个类加载器加载类时，又先委托给其上级类加载器。
a.当所有祖宗类加载器没有加载到类，回到发起者类加载器，还加载不了，则抛ClassNotFoundException，不是再去找发起者类加载器的儿子，因为没有getChild方法，即使有，那有多个儿子，找哪一个呢？
b.对着类加载器的层次结构图和委托加载原理，解释先前将ClassLoaderTest输出成jre/lib/ext目录下的itcast.jar包中后，运行结果为ExtClassLoader的原因。
44_自定义类加载器的编写原理分析
1、自定义的类加载器的必须继承ClassLoader
loadClass方法与findClass方法
defineClass方法
2、编程步骤：
1.编写一个对文件内容进行简单加密的程序。
2.编写了一个自己的类装载器，可实现对加密过的类进行装载和解密。
3.编写一个程序调用类加载器加载类，在源程序中不能用该类名定义引用变量，因为编译器无法识别这个类。程序中可以除了使用ClassLoader.load方法之外，还可以使用设置线程的上下文类加载器或者系统类加载器，然后再使用Class.forName。
3、实验步骤：
1.对不带包名的class文件进行加密，加密结果存放到另外一个目录，例如： javaMyClassLoader MyTest.class F:\itcast
2.运行加载类的程序，结果能够被正常加载，但打印出来的类装载器名称为AppClassLoader：java MyClassLoader MyTest F:\itcast
3.用加密后的类文件替换CLASSPATH环境下的类文件，再执行上一步操作就出问题了，错误说明是AppClassLoader类装载器装载失败。
4.删除CLASSPATH环境下的类文件，再执行上一步操作就没问题了。
4、findClass
protected Class<?> findClass(Stringname) throws ClassNotFoundException
使用指定的二进制名称查找类。此方法应该被类加载器的实现重写，该实现按照委托模型来加载雷。在通过父类加载器检查所请求的类后，此方法将被loadClass方法调用，默认实现抛出一个ClassNotFoundException；
45_编写对class文件进行加密的工具类
import java.util.Date;
public class ClassLoaderAttachmentextends Date {
public String toString(){
return "hello,itheima";
}
}
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
public class MyClassLoader {
//编写对class文件进行加密的工具类
public static void main(String[] args)throws Exception{
// TODO Auto-generated methodstub
String srcPath =args[0];
String destDir = args[1];
FileInputStream fis = new FileInputStream(srcPath);
String destFileName =srcPath.substring(srcPath.lastIndexOf('\\')+1);
String destPath = destDir +"\\"+ destFileName;
FileOutputStream fos = new FileOutputStream(destPath);
cypher(fis,fos);
fis.close();
fos.close();
}
private static void cypher(InputStream ips,OutputStream ops)throws Exception{
int b = -1;
while((b=ips.read())!=-1){
ops.write(b ^ 0xff);
}
}
}
46_编写和测试自己编写的解密类加载器
import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
public class MyClassLoader1 extends ClassLoader{
public static void main(String[] args)throws Exception {
// TODO Auto-generated methodstub
String srcPath = args[0];
String destDir = args[1];
FileInputStream fis = new FileInputStream(srcPath);
//目标原名称
String destFileName =srcPath.substring(srcPath.lastIndexOf('\\')+1);
//目标原路径
String destPath =destDir + "\\" + destFileName;
FileOutputStream fos = new FileOutputStream(destPath);
cypher(fis,fos);
fis.close();
fos.close();
}
public static void cypher(InputStream ips, OutputStream ops)throws Exception{
int b = -1;
while((b=ips.read())!=-1){
ops.write(b ^ 0xff);
}
}
//产生一个classDir成员变量
private String classDir;
@Override
protected Class<?> findClass(String name)throws ClassNotFoundException {
// TODO Auto-generated methodstub
String classFileName = classDir + "\\" + name.substring(name.lastIndexOf('.')+1) +".class";
try{
//由于这里是子类抛出异常,只能使用try,catch处理,因为其子类要抛的异常比父类范围大
FileInputStream fis= newFileInputStream(classFileName);
//定义一个字节输入流
ByteArrayOutputStreambos = new ByteArrayOutputStream();
cypher(fis,bos);
fis.close();
byte[] bytes = bos.toByteArray();
return defineClass(bytes,0,bytes.length);
}catch(Exception e){
e.printStackTrace();
}
return super.findClass(name);
}
//创建一个不带参数的MyClassLoader
public MyClassLoader1(){
//创建一个带参数的MyClassLoader
public MyClassLoader1(String classD
this.classDir
public class ClassLoaderTest {
public static void main(String[] args)throws Exception{
// TODO Auto-generated methodstub
Object obj = ClassLoaderTest.class.getClassLoader().getClass().getName();
System.out.println(obj);
Object obj1 = System.class.getClassLoader();
System.out.println(obj1);
//Java类加载器中有一个特殊的类加载器：BootStrap
ClassLoader loader =ClassLoaderTest.class.getClassLoader();
while(loader !=null){
System.out.println(loader.getClass().getName());//获取其类加载器的名称
loader =loader.getParent();//获取其类加载器的父类名称
}
System.out.println(loader);
//System.out.println(new ClassLoaderAttachment().toString());
Class clazz = new MyClassLoader1("itheimalib").loadClass("com.itheima.day2.ClassLoaderAttachment");
//由于这里是自定义的ClassLoaderAttachment类,因此编译器是无法识别的,所以得将其强制转换
//ClassLoaderAttachment d1 = (ClassLoaderAttachment)clazz.newInstance();
//由于之前定义的是Date类,因此这里可以直接将其转成Date的类
Date d1 =(Date)clazz.newInstance();
System.out.println(d1);
}
}
import java.util.Date;
public class ClassLoaderAttachmentextends Date {
public StringtoString(){
return"hello,itheima";
}
}
47_类加载器的一个高级问题的实验分析
1.编写一个能打印出自己的类加载器名称和当前类加载器的父子结构关系链的MyServlet，正常发布后，看到打印结果为WebAppClassloader。
2.把MyServlet.class文件打jar包，放到ext目录中，重启tomcat，发现找不到HttpServlet的错误。
3.把servlet.jar也放到ext目录中，问题解决了，打印的结果是ExtclassLoader 。
48_分析代理类的作用与原理及AOP概念
代理的概念与作用
程序中的代理
1、要为已存在的多个具有相同接口的目标类的各个方法增加一些系统功能，例如，异常处理、日志、计算方法的运行时间、事务管理、等等，你准备如何做？
2、编写一个与目标类具有相同接口的代理类，代理类的每个方法调用目标类的相同方法，并在调用方法时加上系统功能的代码。（参看下页的原理图）
3、如果采用工厂模式和配置文件的方式进行管理，则不需要修改客户端程序，在配置文件中配置是使用目标类、还是代理类，这样以后很容易切换，譬如，想要日志功能时就配置代理类，否则配置目标类，这样，增加系统功能很容易，以后运行一段时间后，又想去掉系统功能也很容易。
class X{
void sayHello(){
System.out.println("hello,itheima");
}
}
XProxy{
void sayHello(){
starttime;
X.sayHello();
endtime;
}
}
AOP：交叉业务的编程问题即为面向方面的编程（Aspect orientedprogram ,简称AOP），AOP的目标就是要使交叉业务模块化。可以采用将切面代码移动到原始方法的周围，这与直接在方法中编写切面代码的运行效果是一样的，使用代理技术正好可以解决这种问题，代理是实现AOP功能的核心和关键技术
动态代理技术
1、要为系统中的各种接口的类增加代理功能，那将需要太多的代理类，全部采用静态代理方式，将是一件非常麻烦的事情！写成百上千个代理类，是不是太累！
2、JVM可以在运行期动态生成出类的字节码，这种动态生成的类往往被用作代理类，即动态代理类。
3、JVM生成的动态类必须实现一个或多个接口，所以，JVM生成的动态类只能用作具有相同接口的目标类的代理。
4、CGLIB库可以动态生成一个类的子类，一个类的子类也可以用作该类的代理，所以，如果要为一个没有实现接口的类生成动态代理类，那么可以使用CGLIB库。
5、代理类的各个方法中通常除了要调用目标的相应方法和对外返回目标返回的结果外，还可以在代理方法中的如下四个位置加上系统功能代码：
1.在调用目标方法之前
2.在调用目标方法之后
3.在调用目标方法前后
4.在处理目标方法异常的catch块中
49_创建动态类及查看其方法列表信息
1、分析JVM动态生成的类
1、创建实现了Collection接口的动态类和查看其名称，分析Proxy.getProxyClass方法的各个参数。
2、编码列出动态类中的所有构造方法和参数签名
3、编码列出动态类中的所有方法和参数签名
4、创建动态类的实例对象
1.用反射获得构造方法
2.编写一个最简单的InvocationHandler类
3.调用构造方法创建动态类的实例对象，并将编写的InvocationHandler类的实例对象传进去
4.打印创建的对象和调用对象的没有返回值的方法和getClass方法，演示调用其他有返回值的方法报告了异常。
5.将创建动态类的实例对象的代理改成匿名内部类的形式编写，锻炼大家习惯匿名内部类。
5、总结思考：让jvm创建动态类及其实例对象，需要给它提供哪些信息?
三个方面：
1.生成的类中有哪些方法，通过让其实现哪些接口的方式进行告知；
2.产生的类字节码必须有个一个关联的类加载器对象；
3.生成的类中的方法的代码是怎样的，也得由我们提供。把我们的代码写在一个约定好了接口对象的方法中，把对象传给它，它调用我的方法，即相当于插入了我的代码。提供执行代码的对象就是那个InvocationHandler对象，它是在创建动态类的实例对象的构造方法时传递进去的。在上面的InvocationHandler对象的invoke方法中加一点代码，就可以看到这些代码被调用运行了。
6、用Proxy.newInstance方法直接一步就创建出代理对象。
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Collection;
public class ProxyTest {
publicstatic void main(String[] args) {
//TODO Auto-generated method stub
ClassclazzProxy1 = Proxy.getProxyClass(Collection.class.getClassLoader(),Collection.class);;
System.out.println(clazzProxy1.getName());
//获取所有的构造方法,这里定义一个构造方法数组
System.out.println("----------beginconstructor----------");
/*
$Proxy0()
$Proxy0(InvocationHandler,int)
*/
Constructor[]constructors = clazzProxy1.getConstructors();
for(Constructorconstructor : constructors){
Stringname = constructor.getName();
//为了提高效率,这里使用StringBuilder,而StringBuilder不考虑安全问题,因此效率比StringBuffer更高
StringBuildersb = new StringBuilder(name);
sb.append('(');
Class[]clazzParams = constructor.getParameterTypes();
for(ClassclazzParam : clazzParams){
sb.append(clazzParam.getName()).append(',');
}
if(clazzParams!= null && clazzParams.length != 0)
sb.deleteCharAt(sb.length()-1);//删除最后一个元素
sb.append(')');
System.out.println(sb.toString());
}
//通过创建的动态类获取其所有方法
Method[]methods = clazzProxy1.getMethods();
for(Methodmethod : methods){
Stringname = method.getName();
//为了提高效率,这里使用StringBuilder,而StringBuilder不考虑安全问题,因此效率比StringBuffer更高
StringBuildersb = new StringBuilder(name);
sb.append('(');
Class[]clazzParams = method.getParameterTypes();
for(ClassclazzParam : clazzParams){
sb.append(clazzParam.getName()).append(',');
}
if(clazzParams!= null && clazzParams.length != 0)
sb.deleteCharAt(sb.length()-1);//删除最后一个元素
sb.append(')');
System.out.println(sb.toString());
}
}
}
50_创建动态类的实例对象及调用其方法
分析JVM动态生成的类
1、创建实现了Collection接口的动态类和查看其名称，分析Proxy.getProxyClass方法的各个参数。
2、编码列出动态类中的所有构造方法和参数签名
3、编码列出动态类中的所有方法和参数签名
4、创建动态类的实例对象
1.用反射获得构造方法
2.编写一个最简单的InvocationHandler类
3.调用构造方法创建动态类的实例对象，并将编写的InvocationHandler类的实例对象传进去
4.打印创建的对象和调用对象的没有返回值的方法和getClass方法，演示调用其他有返回值的方法报告了异常。
5.将创建动态类的实例对象的代理改成匿名内部类的形式编写，锻炼大家习惯匿名内部类。
总结思考：让jvm创建动态类及其实例对象，需要给它提供哪些信息?
三个方面：
1.生成的类中有哪些方法，通过让其实现哪些接口的方式进行告知；
2.产生的类字节码必须有个一个关联的类加载器对象；
3.生成的类中的方法的代码是怎样的，也得由我们提供。把我们的代码写在一个约定好了接口对象的方法中，把对象传给它，它调用我的方法，即相当于插入了我的代码。提供执行代码的对象就是那个InvocationHandler对象，它是在创建动态类的实例对象的构造方法时传递进去的。在上面的InvocationHandler对象的invoke方法中加一点代码，就可以看到这些代码被调用运行了。
5、用Proxy.newInstance方法直接一步就创建出代理对象。
52_完成InvocationHandler对象的内部功能
Collection proxy2 = (Collection)constructor.newInstance(new InvocationHandler(){
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
// TODO Auto-generated methodstub
return null;
}
});
Collection proxy3 =(Collection)Proxy.newProxyInstance(
Collection.class.getClassLoader(),//类加载器
new Class[]{Collection.class},//接口
new InvocationHandler(){
ArrayList target = new ArrayList();
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
// TODO Auto-generated methodstub
long startTime = System.currentTimeMillis();
Object retVal= method.invoke(target, args);
long endTime = System.currentTimeMillis();
System.out.println(method.getName() +"running time is "+ (endTime - startTime)+"毫秒");
return retVal;
}
});//InvocationHandler
proxy3.add("zxx");
proxy3.add("lhm");
proxy3.add("bxd");
System.out.println(proxy3.size());
}
53_总结分析动态代理类的设计原理与结构
1、分析动态代理的工作原理图
2、怎样将目标类传进去？
1.直接在InvocationHandler实现类中创建目标类的实例对象，可以看运行效果和加入日志代码，但没有实际意义。
2.为InvocationHandler实现类注入目标类的实例对象，不能采用匿名内部类的形式了。
3.让匿名的InvocationHandler实现类访问外面方法中的目标类实例对象的final类型的引用变量。
3、将创建代理的过程改为一种更优雅的方式，eclipse重构出一个getProxy方法绑定接收目标同时返回代理对象，让调用者更懒惰，更方便，调用者甚至不用接触任何代理的API。
4、将系统功能代码模块化，即将切面代码也改为通过参数形式提供，怎样把要执行的系统功能代码以参数形式提供？
1.把要执行的代码装到一个对象的某个方法里，然后把这个对象作为参数传递，接收者只要调用这个对象的方法，即等于执行了外界提供的代码！
2.为bind方法增加一个Advice参数。
54_编写可生成代理和插入通告的通用方法
private static Object getProxy(final Object target,final Advice advice) {
Object proxy3 = Proxy.newProxyInstance(
//Collection.class.getClassLoader(),//类加载器
target.getClass().getClassLoader(),
/*new Class[]{Collection.class}, //接口*/
target.getClass().getInterfaces(),
new InvocationHandler(){
//把目标对象作为参数传递出去
//ArrayList target = new ArrayList();
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
long startTime = System.currentTimeMillis();
advice.beforeMethod(method);
ObjectretVal = method.invoke(target, args);
advice.afterMethod(method);
long endTime = System.currentTimeMillis();
System.out.println(method.getName() +"running time is "+ (endTime - startTime)+"毫秒");
return retVal;
}
});
return proxy3;
}
import java.lang.reflect.Method;
public interface Advice {
void beforeMethod(Method method);
void afterMethod(Methodmethod);
}
import java.lang.reflect.Method;
public class MyAdvice implements Advice {
long startTime = 0;
@Override
public void beforeMethod(Methodmethod) {
// TODO Auto-generated methodstub
System.out.println("到传智播客学习啦");
startTime = System.currentTimeMillis();
}
@Override
public void afterMethod(Method method){
// TODO Auto-generated methodstub
System.out.println("从传智播客毕业上班啦！");
long endTime = System.currentTimeMillis();
System.out.println(method.getName() +"running time is "+ (endTime - startTime)+"毫秒");
}
}
55_实现类似spring的可配置的AOP框架
实现AOP功能的封装与配置
1、工厂类BeanFactory负责创建目标类或代理类的实例对象，并通过配置文件实现切换。其getBean方法根据参数字符串返回一个相应的实例对象，如果参数字符串在配置文件中对应的类名不是ProxyFactoryBean，则直接返回该类的实例对象，否则，返回该类实例对象的getProxy方法返回的对象。
2、BeanFactory的构造方法接收代表配置文件的输入流对象，配置文件格式如下：
#xxx=java.util.ArrayList
xxx=cn.itcast.ProxyFactoryBean
xxx.target=java.util.ArrayList
xxx.advice=cn.itcast.MyAdvice
3、ProxyFacotryBean充当封装生成动态代理的工厂，需要为工厂类提供哪些配置参数信息？
1.目标
2.通知
4、编写客户端应用：
1.编写实现Advice接口的类和在配置文件中进行配置
2.调用BeanFactory获取对象
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
import com.itheima.day3.Advice;
public class BeanFactory {
//定义一个配置文件
Properties props = new Properties();
public BeanFactory(InputStream ips) {
try {
props.load(ips);//加载输入的配置文件
} catch (IOException e) {
// TODO Auto-generated catchblock
e.printStackTrace();
}
}
//对于JavaBean来讲，一定要有一个不带参数的构造方法
public Object getBean(String name){
String className = props.getProperty(name);
Object bean = null;
try {
Class clazz =Class.forName(className);
bean =clazz.newInstance();
} catch (Exception e) {
// TODO Auto-generated catchblock
e.printStackTrace();
}
if(bean instanceof ProxyFactoryBean){
Object proxy = null;
ProxyFactoryBeanproxyFactoryBean = (ProxyFactoryBean)bean;
try {
Advice advice =(Advice)Class.forName(props.getProperty(name +".advice")).newInstance();
Object target =Class.forName(props.getProperty(name +".target")).newInstance();
proxyFactoryBean.setAdvice(advice);
proxyFactoryBean.setTarget(target);
proxy =((ProxyFactoryBean)bean).getProxy();
} catch (Exception e) {
// TODO Auto-generated catchblock
e.printStackTrace();
}
return proxy;
}
return bean;
}
}
#xxx=java.util.ArrayList
xxx=com.itheima.day3.aopframework.ProxyFactoryBean
xxx.advice=com.itheima.day3.MyAdvice
xxx.target=java.util.ArrayList
import java.io.InputStream;
public class AopFrameworkTest {
public static void main(String[] args)throws Exception{
// TODO Auto-generated methodstub
InputStream ips = AopFrameworkTest.class.getResourceAsStream("config.properties");
Object bean = new BeanFactory(ips).getBean("xxx");
System.out.println(bean.getClass().getName());
}
}
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 黑马程序员_Java高新技术_动态代理技术的深入理解
- 黑马程序员--java高新技术--动态代理技术的深入讲解
- 黑马程序员---java高新技术----反射技术
- 黑马程序员_Java高新技术(3)动态代理和AOP技术
- 黑马程序员_java高新技术之反射技术
- 黑马程序员 java高新技术<四>--类加载器、动态代理技术的深入讲解与应用
- 黑马程序员————java高薪技术---反射单元1
- 黑马程序员--java技术blog---第四篇：IO流（3）
- 黑马程序员——Java高新技术---反射
- 黑马程序员—java高新技术_枚举&反射&内省
- 黑马程序员——Java高新技术---交通灯管理系统
- 黑马程序员JAVA高新技术(一)
- 黑马程序员＿java中泛型（通配符）与反射技术
- 黑马程序员 Java基础 I/O技术
- 黑马程序员——【Java高新技术】——案例：银行业务调度系统
- 黑马程序员_java高新技术之_正则表达式
- 黑马程序员 Java高新技术-jdk1.5深入反射和泛型
- 黑马程序员----java高新技术--泛型
- 黑马程序员__JAVA基础加强__高新技术(三)
- 黑马程序员—JAVA高新技术_JDK1.5新特性